diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 106d715..418f2f1 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -64,6 +64,6 @@ jobs: shell: julia --project=docs --color=yes {0} run: | using Documenter: DocMeta, doctest - using Dysts - DocMeta.setdocmeta!(Dysts, :DocTestSetup, :(using Dysts); recursive=true) - doctest(Dysts) + using ChaoticDynamicalSystemLibrary + DocMeta.setdocmeta!(ChaoticDynamicalSystemLibrary, :DocTestSetup, :(using ChaoticDynamicalSystemLibrary); recursive=true) + doctest(ChaoticDynamicalSystemLibrary) diff --git a/LICENSE.md b/LICENSE.md new file mode 100755 index 0000000..f49a4e1 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/Project.toml b/Project.toml index 4e0b4a5..3ea0e34 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,14 @@ -name = "Dysts" +name = "ChaoticDynamicalSystemLibrary" uuid = "55704126-756f-498a-a54f-434b72ecbddd" authors = ["Nathanael Bosch and contributors"] -version = "1.0.0-DEV" +version = "0.1.0" + +[deps] +ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" +SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462" [compat] julia = "1.6" diff --git a/README.md b/README.md index c673001..72c591c 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,51 @@ -# Dysts +# ChaoticDynamicalSystemLibrary.jl -[![Stable](https://img.shields.io/badge/docs-stable-blue.svg)](https://nathanaelbosch.github.io/Dysts.jl/stable/) -[![Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://nathanaelbosch.github.io/Dysts.jl/dev/) -[![Build Status](https://github.com/nathanaelbosch/Dysts.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/nathanaelbosch/Dysts.jl/actions/workflows/CI.yml?query=branch%3Amain) -[![Coverage](https://codecov.io/gh/nathanaelbosch/Dysts.jl/branch/main/graph/badge.svg)](https://codecov.io/gh/nathanaelbosch/Dysts.jl) +[![Stable](https://img.shields.io/badge/docs-stable-blue.svg)](https://nathanaelbosch.github.io/ChaoticDynamicalSystemLibrary.jl/stable/) +[![Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://nathanaelbosch.github.io/ChaoticDynamicalSystemLibrary.jl/dev/) +[![Build Status](https://github.com/nathanaelbosch/ChaoticDynamicalSystemLibrary.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/nathanaelbosch/ChaoticDynamicalSystemLibrary.jl/actions/workflows/CI.yml?query=branch%3Amain) +[![Coverage](https://codecov.io/gh/nathanaelbosch/ChaoticDynamicalSystemLibrary.jl/branch/main/graph/badge.svg)](https://codecov.io/gh/nathanaelbosch/ChaoticDynamicalSystemLibrary.jl) + +ChaoticDynamicalSystemLibrary.jl is a collection of chaotic dynamical systems for the Julia [SciML](https://sciml.ai/) ecosystem. + +The package is a partial port of the [`dysts`](https://github.com/williamgilpin/dysts) Python package developed by [William Gilpin](https://github.com/williamgilpin). +It implements many (but not all) of the same systems, but does not provide any functionality to simulate them. +In contrast to [`dysts`](https://github.com/williamgilpin/dysts), the main focus of this package is not to be a benchmark for general time-series ML models, but only to provide a collection of ODEs. +Their simulation is left to other packages, such as [DifferentialEquations.jl](https://diffeq.sciml.ai/stable/). + +--- + +**[**William Gilpin**](https://github.com/williamgilpin) deserves most of the credit for this package. +He is the original author of the [`dysts`](https://github.com/williamgilpin/dysts), and without [`dysts`](https://github.com/williamgilpin/dysts) this package would not exist.** + +--- + + + +## Installation + +```julia +import Pkg +Pkg.add("ChaoticDynamicalSystemLibrary") +``` + +## Usage + +```julia +using ChaoticDynamicalSystemLibrary, DifferentialEquations, Plots + +prob = ChaoticDynamicalSystemLibrary.Lorenz() +sol = solve(prob, Tsit5(), tspan=(0, 100)) +plot(sol, idxs=(1, 2, 3)) +``` +![Lorenz Simulation](./docs/src/readmeplot.svg?raw=true "Lorenz Simulation") + +For a full list of the available systems, see the [documentation](https://nathanaelbosch.github.io/ChaoticDynamicalSystemLibrary.jl/stable/). + + +## Acknowledgements + +- [William Gilpin](https://github.com/williamgilpin) / [`dysts`](https://github.com/williamgilpin/dysts): + The foundation that this package is based on. +- [Jürgen Meier](http://www.3d-meier.de/tut19/Seite1.html) and + [J. C. Sprott](http://sprott.physics.wisc.edu/sprott.htm): + `dysts` contains systems from both collections, and therefore so does this package. diff --git a/docs/Project.toml b/docs/Project.toml index b5722bd..f255384 100644 --- a/docs/Project.toml +++ b/docs/Project.toml @@ -1,3 +1,4 @@ [deps] +ChaoticDynamicalSystemLibrary = "55704126-756f-498a-a54f-434b72ecbddd" Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" -Dysts = "55704126-756f-498a-a54f-434b72ecbddd" +LiveServer = "16fef848-5104-11e9-1b77-fb7a48bbb589" diff --git a/docs/make.jl b/docs/make.jl index e9e9917..1bba379 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -1,18 +1,19 @@ -using Dysts +using ChaoticDynamicalSystemLibrary using Documenter -DocMeta.setdocmeta!(Dysts, :DocTestSetup, :(using Dysts); recursive=true) +DocMeta.setdocmeta!(ChaoticDynamicalSystemLibrary, :DocTestSetup, :(using ChaoticDynamicalSystemLibrary); recursive=true) makedocs(; - modules=[Dysts], + modules=[ChaoticDynamicalSystemLibrary], authors="Nathanael Bosch and contributors", - repo="https://github.com/nathanaelbosch/Dysts.jl/blob/{commit}{path}#{line}", - sitename="Dysts.jl", + repo="https://github.com/nathanaelbosch/ChaoticDynamicalSystemLibrary.jl/blob/{commit}{path}#{line}", + sitename="ChaoticDynamicalSystemLibrary.jl", format=Documenter.HTML(; prettyurls=get(ENV, "CI", "false") == "true", - canonical="https://nathanaelbosch.github.io/Dysts.jl", + canonical="https://nathanaelbosch.github.io/ChaoticDynamicalSystemLibrary.jl", edit_link="main", assets=String[], + size_threshold_ignore = ["index.md"], ), pages=[ "Home" => "index.md", @@ -20,6 +21,6 @@ makedocs(; ) deploydocs(; - repo="github.com/nathanaelbosch/Dysts.jl", + repo="github.com/nathanaelbosch/ChaoticDynamicalSystemLibrary.jl", devbranch="main", ) diff --git a/docs/src/index.md b/docs/src/index.md index 158c040..76f74a4 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -1,14 +1,27 @@ ```@meta -CurrentModule = Dysts +CurrentModule = ChaoticDynamicalSystemLibrary ``` -# Dysts +# ChaoticDynamicalSystemLibrary.jl -Documentation for [Dysts](https://github.com/nathanaelbosch/Dysts.jl). +ChaoticDynamicalSystemLibrary.jl is a collection of chaotic dynamical systems for the Julia [SciML](https://sciml.ai/) ecosystem. -```@index -``` +The package is a partial port of the [`dysts`](https://github.com/williamgilpin/dysts) Python package developed by [William Gilpin](https://github.com/williamgilpin). +It implements many (but not all) of the same systems, but does not provide any functionality to simulate them. +In contrast to [`dysts`](https://github.com/williamgilpin/dysts), the main focus of this package is not to be a benchmark for general time-series ML models, but only to provide a collection of ODEs. +Their simulation is left to other packages, such as [DifferentialEquations.jl](https://diffeq.sciml.ai/stable/). + +--- + +**[William Gilpin](https://github.com/williamgilpin) deserves most of the credit for this package. +He is the original author of the [`dysts`](https://github.com/williamgilpin/dysts), and without [`dysts`](https://github.com/williamgilpin/dysts) this package would not exist.** + +--- + +## Full list of all dynamical systems: ```@autodocs -Modules = [Dysts] +Modules = [ChaoticDynamicalSystemLibrary] +Public = false +Pages = ["chaotic_attractors.jl"] ``` diff --git a/docs/src/readmeplot.svg b/docs/src/readmeplot.svg new file mode 100644 index 0000000..8e4ebe4 --- /dev/null +++ b/docs/src/readmeplot.svg @@ -0,0 +1,53 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/ChaoticDynamicalSystemLibrary.jl b/src/ChaoticDynamicalSystemLibrary.jl new file mode 100644 index 0000000..82b90d0 --- /dev/null +++ b/src/ChaoticDynamicalSystemLibrary.jl @@ -0,0 +1,85 @@ +module ChaoticDynamicalSystemLibrary + +using JSON, Markdown +using LinearAlgebra +using SciMLBase +using ComponentArrays + + +function dict_with_string_keys_to_symbol_keys(d::Dict) + new_d = Dict() + for (k, v) in d + new_d[Symbol(k)] = v + end + return new_d +end + +function dict_to_componentarray(d::Dict) + return ComponentArray(dict_with_string_keys_to_symbol_keys(d)) +end + + +function make_docstring(f) + data = ATTRACTOR_DATA[string(f)] + header = """ + $f() + + $(data["description"]) + """ + + stats = """ + + ## Stats + """ + "correlation_dimenension" in keys(data) && (stats *= """ + - Correlation dimension: `$(data["correlation_dimension"])` + """) + "embedding_dimension" in keys(data) && (stats *= """ + - Embedding dimension: `$(data["embedding_dimension"])` + """) + "hamiltonian" in keys(data) && (stats *= """ + - Hamiltonian: `$(data["hamiltonian"])` + """) + "kaplan_yorke_dimension" in keys(data) && (stats *= """ + - Kaplan-Yorke dimension: `$(data["kaplan_yorke_dimension"])` + """) + "lyapunov_spectrum_estimated" in keys(data) && (stats *= """ + - Lyapunov spectrum (estimated): `$(data["lyapunov_spectrum_estimated"])` + """) + "maximum_lyapunov_estimated" in keys(data) && (stats *= """ + - Maximum Lyapunov exponent (estimated): `$(data["maximum_lyapunov_estimated"])` + """) + "multiscale_entropy" in keys(data) && (stats *= """ + - Multiscale Entropy: `$(data["multiscale_entropy"])` + """) + "nonautonomous" in keys(data) && (stats *= """ + - Non-autonomous: `$(data["nonautonomous"])` + """) + "period" in keys(data) && (stats *= """ + - Period: `$(data["period"])` + """) + "pesin_entropy" in keys(data) && (stats *= """ + - Pesin entropy: `$(data["pesin_entropy"])` + """) + + citation = """ + + ## References + $(data["citation"]) + """ + + code_string = """ + + ## Original code from the [`dysts`](https://github.com/williamgilpin/dysts) Python package + + ```python + """ * originalcode(f) * """ + ``` + """ + + return header * stats * citation * code_string +end + +include("chaotic_attractors.jl") + +end diff --git a/src/Dysts.jl b/src/Dysts.jl deleted file mode 100644 index 5928990..0000000 --- a/src/Dysts.jl +++ /dev/null @@ -1,5 +0,0 @@ -module Dysts - -# Write your package code here. - -end diff --git a/src/chaotic_attractors.jl b/src/chaotic_attractors.jl new file mode 100644 index 0000000..d90e5c9 --- /dev/null +++ b/src/chaotic_attractors.jl @@ -0,0 +1,4169 @@ +ATTRACTOR_DATA = JSON.parsefile(joinpath(@__DIR__, "chaotic_attractors.json")) + +function Lorenz end +originalcode(::typeof(Lorenz)) = """ +class Lorenz(DynSys): + @staticjit + def _rhs(x, y, z, t, beta, rho, sigma): + xdot = sigma * y - sigma * x + ydot = rho * x - x * z - y + zdot = x * y - beta * z + return xdot, ydot, zdot + @staticjit + def _jac(x, y, z, t, beta, rho, sigma): + row1 = [-sigma, sigma, 0] + row2 = [rho - z, -1, -x] + row3 = [y, x, -beta] + return [row1, row2, row3] +""" +@doc make_docstring(Lorenz) +function Lorenz() + function rhs(du, u, p, t) + beta, rho, sigma = p + du[1] = sigma * (u[2] - u[1]) + du[2] = u[1] * (rho - u[3]) - u[2] + du[3] = u[1] * u[2] - beta * u[3] + end + function jac(J, u, p, t) + beta, rho, sigma = p + J[1, 1] = -sigma + J[1, 2] = sigma + J[1, 3] = 0 + J[2, 1] = rho - u[3] + J[2, 2] = -1 + J[2, 3] = -u[1] + J[3, 1] = u[2] + J[3, 2] = u[1] + J[3, 3] = -beta + end + u0 = Float64.(ATTRACTOR_DATA["Lorenz"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Lorenz"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs, jac=jac) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + + +function LorenzBounded end +originalcode(::typeof(LorenzBounded)) = """ +class LorenzBounded(DynSys): + @staticjit + def _rhs(x, y, z, t, beta, r, rho, sigma): + xdot = sigma * y - sigma * x - sigma/r**2 * y * x ** 2 - sigma/r**2 * y ** 3 - sigma/r**2 * y * z ** 2 + sigma/r**2 * x ** 3 + sigma/r**2 * x * y ** 2 + sigma/r**2 * x * z ** 2 + ydot = rho * x - x * z - y - rho/r**2 * x ** 3 - rho/r**2 * x * y ** 2 - rho/r**2 * x * z ** 2 + 1/r**2 * z * x ** 3 + 1/r**2 * x * z * y ** 2 + 1/r**2 * x * z ** 3 + 1/r**2 * y * x ** 2 + 1/r**2 * y ** 3 + 1/r**2 * y * z ** 2 + zdot = x * y - beta * z - 1/r**2 * y * x ** 3 - 1/r**2 * x * y ** 3 - 1/r**2 * x * y * z ** 2 + beta/r**2 * z * x ** 2 + beta/r**2 * z * y ** 2 + beta/r**2 * z ** 3 + return xdot, ydot, zdot +""" +@doc make_docstring(LorenzBounded) +function LorenzBounded() + function rhs(du, u, p, t) + beta, r, rho, sigma = p + x, y, z = u + du[1] = sigma * y - sigma * x - sigma/r^2 * y * x^2 - sigma/r^2 * y^3 - sigma/r^2 * y * z^2 + sigma/r^2 * x^3 + sigma/r^2 * x * y^2 + sigma/r^2 * x * z^2 + du[2] = rho * x - x * z - y - rho/r^2 * x^3 - rho/r^2 * x * y^2 - rho/r^2 * x * z^2 + 1/r^2 * z * x^3 + 1/r^2 * x * z * y^2 + 1/r^2 * x * z^3 + 1/r^2 * y * x^2 + 1/r^2 * y^3 + 1/r^2 * y * z^2 + du[3] = x * y - beta * z - 1/r^2 * y * x^3 - 1/r^2 * x * y^3 - 1/r^2 * x * y * z^2 + beta/r^2 * z * x^2 + beta/r^2 * z * y^2 + beta/r^2 * z^3 + end + u0 = Float64.(ATTRACTOR_DATA["LorenzBounded"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["LorenzBounded"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + + +function LorenzCoupled end +originalcode(::typeof(LorenzCoupled)) = """ +class LorenzCoupled(DynSys): + @staticjit + def _rhs(x1, y1, z1, x2, y2, z2, t, beta, eps, rho, rho1, rho2, sigma): + x1dot = sigma * y1 - sigma * x1 + y1dot = rho1 * x1 - x1 * z1 - y1 + z1dot = x1 * y1 - beta * z1 + x2dot = sigma * y2 - sigma * x2 + eps * x1 - eps * x2 + y2dot = rho2 * x2 - x2 * z2 - y2 + z2dot = x2 * y2 - beta * z2 + return x1dot, y1dot, z1dot, x2dot, y2dot, z2dot +""" +@doc make_docstring(LorenzCoupled) +function LorenzCoupled() + function rhs(du, u, p, t) + beta, eps, rho, rho1, rho2, sigma = p + du[1] = sigma * (u[2] - u[1]) + du[2] = rho1 * u[1] - u[1] * u[3] - u[2] + du[3] = u[1] * u[2] - beta * u[3] + du[4] = sigma * (u[5] - u[4]) + eps * u[1] - eps * u[4] + du[5] = rho2 * u[4] - u[4] * u[6] - u[5] + du[6] = u[4] * u[5] - beta * u[6] + end + u0 = Float64.(ATTRACTOR_DATA["LorenzCoupled"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["LorenzCoupled"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Lorenz96 end +originalcode(::typeof(Lorenz96)) = """ +class Lorenz96(DynSys): + def rhs(self, X, t): + Xdot = np.zeros_like(X) + Xdot[0] = (X[1] - X[-2]) * X[-1] - X[0] + self.f + Xdot[1] = (X[2] - X[-1]) * X[0] - X[1] + self.f + Xdot[-1] = (X[0] - X[-3]) * X[-2] - X[-1] + self.f + Xdot[2:-1] = (X[3:] - X[:-3]) * X[1:-2] - X[2:-1] + self.f + return Xdot +""" +@doc make_docstring(Lorenz96) Lorenz96 +function Lorenz96() + function rhs(du, u, p, t) + f = p[1] + du[1] = (u[2] - u[end-1]) * u[end] - u[1] + f + du[2] = (u[3] - u[end]) * u[1] - u[2] + f + du[end] = (u[1] - u[end-2]) * u[end-1] - u[end] + f + @simd ivdep for i in 3:(length(u)-1) + du[i] = (u[i+1] - u[i-2]) * u[i-1] - u[i] + f + end + end + u0 = Float64.(ATTRACTOR_DATA["Lorenz96"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Lorenz96"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Lorenz84 end +originalcode(::typeof(Lorenz84)) = """ +class Lorenz84(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, f, g): + xdot = -a * x - y ** 2 - z ** 2 + a * f + ydot = -y + x * y - b * x * z + g + zdot = -z + b * x * y + x * z + return xdot, ydot, zdot +""" +@doc make_docstring(Lorenz84) Lorenz84 +function Lorenz84() + function rhs(du, u, p, t) + a, b, f, g = p + du[1] = -a * u[1] - u[2]^2 - u[3]^2 + a * f + du[2] = -u[2] + u[1] * u[2] - b * u[1] * u[3] + g + du[3] = -u[3] + b * u[1] * u[2] + u[1] * u[3] + end + u0 = Float64.(ATTRACTOR_DATA["Lorenz84"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Lorenz84"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Rossler end +originalcode(::typeof(Rossler)) = """ +class Rossler(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = -y - z + ydot = x + a * y + zdot = b + z * x - c * z + return xdot, ydot, zdot +""" +@doc make_docstring(Rossler) Rossler +function Rossler() + function rhs(du, u, p, t) + a, b, c = p + du[1] = -u[2] - u[3] + du[2] = u[1] + a * u[2] + du[3] = b + u[3] * u[1] - c * u[3] + end + u0 = Float64.(ATTRACTOR_DATA["Rossler"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Rossler"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Thomas end +originalcode(::typeof(Thomas)) = """ +class Thomas(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = -a * x + b * np.sin(y) + ydot = -a * y + b * np.sin(z) + zdot = -a * z + b * np.sin(x) + return xdot, ydot, zdot +""" +@doc make_docstring(Thomas) Thomas +function Thomas() + function rhs(du, u, p, t) + a, b = p + du[1] = -a * u[1] + b * sin(u[2]) + du[2] = -a * u[2] + b * sin(u[3]) + du[3] = -a * u[3] + b * sin(u[1]) + end + u0 = Float64.(ATTRACTOR_DATA["Thomas"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Thomas"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function DoublePendulum end +originalcode(::typeof(DoublePendulum)) = """ +class DoublePendulum(DynSys): + @staticjit + def _rhs(th1, th2, p1, p2, t, d, m): + g = 9.82 + pre = 6 / (m * d ** 2) + denom = 16 - 9 * np.cos(th1 - th2) ** 2 + th1_dot = pre * (2 * p1 - 3 * np.cos(th1 - th2) * p2) / denom + th2_dot = pre * (8 * p2 - 3 * np.cos(th1 - th2) * p1) / denom + p1_dot = ( + -0.5 + * (m * d ** 2) + * (th1_dot * th2_dot * np.sin(th1 - th2) + 3 * (g / d) * np.sin(th1)) + ) + p2_dot = ( + -0.5 + * (m * d ** 2) + * (-th1_dot * th2_dot * np.sin(th1 - th2) + 3 * (g / d) * np.sin(th2)) + ) + return th1_dot, th2_dot, p1_dot, p2_dot +""" +@doc make_docstring(DoublePendulum) DoublePendulum +function DoublePendulum() + function rhs(du, u, p, t) + d, m = p + g = 9.82 + pre = 6 / (m * d^2) + denom = 16 - 9 * cos(u[1] - u[2])^2 + du[1] = pre * (2 * u[3] - 3 * cos(u[1] - u[2]) * u[4]) / denom + du[2] = pre * (8 * u[4] - 3 * cos(u[1] - u[2]) * u[3]) / denom + du[3] = -0.5 * (m * d^2) * (du[1] * du[2] * sin(u[1] - u[2]) + 3 * (g / d) * sin(u[1])) + du[4] = -0.5 * (m * d^2) * (-du[1] * du[2] * sin(u[1] - u[2]) + 3 * (g / d) * sin(u[2])) + end + u0 = Float64.(ATTRACTOR_DATA["DoublePendulum"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["DoublePendulum"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function SwingingAtwood end +originalcode(::typeof(SwingingAtwood)) = """ +class SwingingAtwood(DynSys): + @staticjit + def _rhs(r, th, pr, pth, t, m1, m2): + g = 9.82 + rdot = pr / (m1 + m2) + thdot = pth / (m1 * r ** 2) + prdot = pth ** 2 / (m1 * r ** 3) - m2 * g + m1 * g * np.cos(th) + pthdot = -m1 * g * r * np.sin(th) + return rdot, thdot, prdot, pthdot + + @staticjit + def _postprocessing(r, th, pr, pth): + return r, np.sin(th), pr, pth +""" +@doc make_docstring(SwingingAtwood) SwingingAtwood +function SwingingAtwood() + function rhs(du, u, p, t) + m1, m2 = p + g = 9.82 + du[1] = u[3] / (m1 + m2) + du[2] = u[4] / (m1 * u[1]^2) + du[3] = u[4]^2 / (m1 * u[1]^3) - m2 * g + m1 * g * cos(u[2]) + du[4] = -m1 * g * u[1] * sin(u[2]) + end + u0 = Float64.(ATTRACTOR_DATA["SwingingAtwood"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SwingingAtwood"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function GuckenheimerHolmes end +originalcode(::typeof(GuckenheimerHolmes)) = """ +class GuckenheimerHolmes(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d, e, f): + xdot = a * x - b * y + c * z * x + d * z * x ** 2 + d * z * y ** 2 + ydot = a * y + b * x + c * z * y + zdot = e - z ** 2 - f * x ** 2 - f * y ** 2 - a * z ** 3 + return xdot, ydot, zdot +""" +@doc make_docstring(GuckenheimerHolmes) GuckenheimerHolmes +function GuckenheimerHolmes() + function rhs(du, u, p, t) + a, b, c, d, e, f = p + du[1] = a * u[1] - b * u[2] + c * u[3] * u[1] + d * u[3] * u[1]^2 + d * u[3] * u[2]^2 + du[2] = a * u[2] + b * u[1] + c * u[3] * u[2] + du[3] = e - u[3]^2 - f * u[1]^2 - f * u[2]^2 - a * u[3]^3 + end + u0 = Float64.(ATTRACTOR_DATA["GuckenheimerHolmes"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["GuckenheimerHolmes"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function HenonHeiles end +originalcode(::typeof(HenonHeiles)) = """ +class HenonHeiles(DynSys): + @staticjit + def _rhs(x, y, px, py, t, lam): + xdot = px + ydot = py + pxdot = -x - 2 * lam * x * y + pydot = -y - lam * x ** 2 + lam * y ** 2 + return xdot, ydot, pxdot, pydot +""" +@doc make_docstring(HenonHeiles) HenonHeiles +function HenonHeiles() + function rhs(du, u, p, t) + lam = p[1] + du[1] = u[3] + du[2] = u[4] + du[3] = -u[1] - 2 * lam * u[1] * u[2] + du[4] = -u[2] - lam * u[1]^2 + lam * u[2]^2 + end + u0 = Float64.(ATTRACTOR_DATA["HenonHeiles"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HenonHeiles"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Halvorsen end +originalcode(::typeof(Halvorsen)) = """ +class Halvorsen(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = -a * x - b * y - b * z - y ** 2 + ydot = -a * y - b * z - b * x - z ** 2 + zdot = -a * z - b * x - b * y - x ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(Halvorsen) Halvorsen +function Halvorsen() + function rhs(du, u, p, t) + a, b = p + du[1] = -a * u[1] - b * u[2] - b * u[3] - u[2]^2 + du[2] = -a * u[2] - b * u[3] - b * u[1] - u[3]^2 + du[3] = -a * u[3] - b * u[1] - b * u[2] - u[1]^2 + end + u0 = Float64.(ATTRACTOR_DATA["Halvorsen"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Halvorsen"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Chua end +originalcode(::typeof(Chua)) = """ +class Chua(DynSys): + @staticjit + def _rhs(x, y, z, t, alpha, beta, m0, m1): + ramp_x = m1 * x + 0.5 * (m0 - m1) * (np.abs(x + 1) - np.abs(x - 1)) + xdot = alpha * (y - x - ramp_x) + ydot = x - y + z + zdot = -beta * y + return xdot, ydot, zdot +""" +@doc make_docstring(Chua) Chua +function Chua() + function rhs(du, u, p, t) + alpha, beta, m0, m1 = p + ramp_x = m1 * u[1] + 0.5 * (m0 - m1) * (abs(u[1] + 1) - abs(u[1] - 1)) + du[1] = alpha * (u[2] - u[1] - ramp_x) + du[2] = u[1] - u[2] + u[3] + du[3] = -beta * u[2] + end + u0 = Float64.(ATTRACTOR_DATA["Chua"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Chua"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function MultiChua end +originalcode(::typeof(MultiChua)) = """ +class MultiChua(DynSys): + def diode(self, x): + m, c = self.m, self.c + total = m[-1] * x + for i in range(1, 6): + total += 0.5 * (m[i - 1] - m[i]) * (np.abs(x + c[i]) - np.abs(x - c[i])) + return total + + def rhs(self, X, t): + x, y, z = X + xdot = self.a * (y - self.diode(x)) + ydot = x - y + z + zdot = -self.b * y + return (xdot, ydot, zdot) +""" +@doc make_docstring(MultiChua) MultiChua +function MultiChua() + function diode(x, m, c) + total = m[end] * x + @simd ivdep for i in 1:5 + total += 0.5 * (m[i] - m[i+1]) * (abs(x + c[i]) - abs(x - c[i])) + end + return total + end + function rhs(du, u, p, t) + a, b, m, c = p + du[1] = a * (u[2] - diode(u[1], m, c)) + du[2] = u[1] - u[2] + u[3] + du[3] = -b * u[2] + end + u0 = Float64.(ATTRACTOR_DATA["MultiChua"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["MultiChua"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Duffing end +originalcode(::typeof(Duffing)) = """ +class Duffing(DynSys): + @staticjit + def _rhs(x, y, z, t, alpha, beta, delta, gamma, omega): + xdot = y + ydot = -delta * y - beta * x - alpha * x ** 3 + gamma * np.cos(z) + zdot = omega + return xdot, ydot, zdot + + @staticjit + def _postprocessing(x, y, z): + return x, y, np.cos(z) +""" +@doc make_docstring(Duffing) Duffing +function Duffing() + function rhs(du, u, p, t) + alpha, beta, delta, gamma, omega = p + du[1] = u[2] + du[2] = -delta * u[2] - beta * u[1] - alpha * u[1]^3 + gamma * cos(u[3]) + du[3] = omega + end + u0 = Float64.(ATTRACTOR_DATA["Duffing"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Duffing"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function MackeyGlass end +originalcode(::typeof(MackeyGlass)) = """ +class MackeyGlass(DynSysDelay): + @staticjit + def _rhs(x, xt, t, beta, gamma, n, tau): + xdot = beta * (xt / (1 + xt ** n)) - gamma * x + return xdot +""" +@doc make_docstring(MackeyGlass) MackeyGlass +function MackeyGlass() + function rhs(du, u, p, t) + beta, gamma, n = p + du[1] = beta * (u[2] / (1 + u[2]^n)) - gamma * u[1] + end + u0 = Float64.(ATTRACTOR_DATA["MackeyGlass"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["MackeyGlass"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = DDEProblem(f, u0, tspan, p, constant_lags=[1.0]) + return prob +end + +function IkedaDelay end +originalcode(::typeof(IkedaDelay)) = """ +class IkedaDelay(DynSysDelay): + @staticjit + def _rhs(x, xt, t, c, mu, tau, x0): + xdot = mu * np.sin(xt - x0) - c * x + return xdot +""" +@doc make_docstring(IkedaDelay) IkedaDelay +function IkedaDelay() + function rhs(du, u, p, t) + c, mu, x0 = p + du[1] = mu * sin(u[2] - x0) - c * u[1] + end + u0 = Float64.(ATTRACTOR_DATA["IkedaDelay"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["IkedaDelay"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = DDEProblem(f, u0, tspan, p, constant_lags=[1.0]) + return prob +end + + +# class SprottDelay(IkedaDelay): +# pass + + +# class VossDelay(DynSysDelay): +# @staticjit +# def _rhs(x, xt, t, alpha, tau): +# f = -10.44 * xt ** 3 - 13.95 * xt ** 2 - 3.63 * xt + 0.85 +# xdot = -alpha * x + f +# return xdot + + +# class ScrollDelay(DynSysDelay): +# @staticjit +# def _rhs(x, xt, t, alpha, beta, tau): +# f = np.tanh(10 * xt) +# xdot = -alpha * xt + beta * f +# return xdot + + +# class PiecewiseCircuit(DynSysDelay): +# @staticjit +# def _rhs(x, xt, t, alpha, beta, c, tau): +# f = -((xt / c) ** 3) + 3 * xt / c +# xdot = -alpha * xt + beta * f +# return xdot + + +# # ## this was not chaotic +# # class ENSODelay(DynSysDelay): +# # @staticjit +# # def _rhs(x, xt, t, alpha, beta, tau): +# # xdot = x - x**3 - alpha * xt + beta +# # return xdot + +function DoubleGyre end +originalcode(::typeof(DoubleGyre)) = """ +class DoubleGyre(DynSys): + @staticjit + def _rhs(x, y, z, t, alpha, eps, omega): + a = eps * np.sin(z) + b = 1 - 2 * eps * np.sin(z) + f = a * x ** 2 + b * x + dx = -alpha * np.pi * np.sin(np.pi * f) * np.cos(np.pi * y) + dy = alpha * np.pi * np.cos(np.pi * f) * np.sin(np.pi * y) * (2 * a * x + b) + dz = omega + return dx, dy, dz + + @staticjit + def _postprocessing(x, y, z): + return x, y, np.sin(z) +""" +@doc make_docstring(DoubleGyre) DoubleGyre +function DoubleGyre() + function rhs(du, u, p, t) + alpha, eps, omega = p + a = eps * sin(u[3]) + b = 1 - 2 * eps * sin(u[3]) + f = a * u[1]^2 + b * u[1] + du[1] = -alpha * pi * sin(pi * f) * cos(pi * u[2]) + du[2] = alpha * pi * cos(pi * f) * sin(pi * u[2]) * (2 * a * u[1] + b) + du[3] = omega + end + u0 = Float64.(ATTRACTOR_DATA["DoubleGyre"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["DoubleGyre"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function BlinkingRotlet end +originalcode(::typeof(BlinkingRotlet)) = """ +class BlinkingRotlet(DynSys): + @staticjit + def _rotlet(r, theta, a, b, bc): + \"\"\"A rotlet velocity field\"\"\" + kappa = a ** 2 + (b ** 2 * r ** 2) / a ** 2 - 2 * b * r * np.cos(theta) + gamma = (1 - r ** 2 / a ** 2) * (a ** 2 - (b ** 2 * r ** 2) / a ** 2) + iota = (b ** 2 * r) / a ** 2 - b * np.cos(theta) + zeta = b ** 2 + r ** 2 - 2 * b * r * np.cos(theta) + nu = a ** 2 + b ** 2 - (2 * b ** 2 * r ** 2) / a ** 2 + vr = b * np.sin(theta) * (-bc * (gamma / kappa ** 2) - 1 / kappa + 1 / zeta) + vth = ( + bc * (gamma * iota) / kappa ** 2 + + bc * r * nu / (a ** 2 * kappa) + + iota / kappa + - (r - b * np.cos(theta)) / zeta + ) + return vr, vth + + @staticjit + def _protocol(t, tau, stiffness=20): + return 0.5 + 0.5 * np.tanh(tau * stiffness * np.sin(2 * np.pi * t / tau)) + + def rhs(self, X, t): + r, theta, tt = X + weight = self._protocol(tt, self.tau) + dr1, dth1 = self._rotlet(r, theta, self.a, self.b, self.bc) + dr2, dth2 = self._rotlet(r, theta, self.a, -self.b, self.bc) + dr = weight * dr1 + (1 - weight) * dr2 + dth = (weight * dth1 + (1 - weight) * dth2) / r + dtt = 1 + return self.sigma * dr, self.sigma * dth, dtt + + def _postprocessing(self, r, th, tt): + return r * np.cos(th), r * np.sin(th), np.sin(2 * np.pi * tt / self.tau) +""" +@doc make_docstring(BlinkingRotlet) BlinkingRotlet +function BlinkingRotlet() + function rotlet(r, theta, a, b, bc) + kappa = a^2 + (b^2 * r^2) / a^2 - 2 * b * r * cos(theta) + gamma = (1 - r^2 / a^2) * (a^2 - (b^2 * r^2) / a^2) + iota = (b^2 * r) / a^2 - b * cos(theta) + zeta = b^2 + r^2 - 2 * b * r * cos(theta) + nu = a^2 + b^2 - (2 * b^2 * r^2) / a^2 + vr = b * sin(theta) * (-bc * (gamma / kappa^2) - 1 / kappa + 1 / zeta) + vth = bc * (gamma * iota) / kappa^2 + bc * r * nu / (a^2 * kappa) + iota / kappa - (r - b * cos(theta)) / zeta + return vr, vth + end + function protocol(t, tau, stiffness=20) + return 0.5 + 0.5 * tanh(tau * stiffness * sin(2 * pi * t / tau)) + end + function rhs(du, u, p, t) + a, b, bc, tau, sigma = p + r, theta, tt = u + weight = protocol(tt, tau) + dr1, dth1 = rotlet(r, theta, a, b, bc) + dr2, dth2 = rotlet(r, theta, a, -b, bc) + dr = weight * dr1 + (1 - weight) * dr2 + dth = (weight * dth1 + (1 - weight) * dth2) / r + dtt = 1 + du[1] = sigma * dr + du[2] = sigma * dth + du[3] = dtt + end + u0 = Float64.(ATTRACTOR_DATA["BlinkingRotlet"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["BlinkingRotlet"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function LidDrivenCavityFlow end +originalcode(::typeof(LidDrivenCavityFlow)) = """ +class LidDrivenCavityFlow(DynSys): + @staticjit + def _lid(x, y, a, b, tau, u1, u2): + \"\"\"The velocity field when the left domain drives\"\"\" + prefactor1 = 2 * u1 * np.sin(np.pi * x / a) / (2 * b * np.pi + a * np.sinh(2 * np.pi * b / a)) + prefactor2 = 2 * u2 * np.sin(2 * np.pi * x / a) / (4 * b * np.pi + a * np.sinh(4 * np.pi * b / a)) + vx1 = -b * np.pi * np.sinh(np.pi * b / a) * np.sinh(np.pi * y / a) + np.cosh(np.pi * b / a) * (np.pi * y * np.cosh(np.pi * y /a) + a * np.sinh(np.pi * y / a)) + vx2 = -2 * b * np.pi * np.sinh(2 * np.pi * b / a) * np.sinh(2 * np.pi * y / a) + np.cosh(2 * np.pi * b / a) * (2 * np.pi * y * np.cosh(2 * np.pi * y / a) + a * np.sinh(2 * np.pi * y / a)) + vx = prefactor1 * vx1 + prefactor2 * vx2 + + prefactor1 = 2 * np.pi * u1 * np.cos(np.pi * x / a) / (2 * b * np.pi + a * np.sinh(2 * np.pi * b / a)) + prefactor2 = 4 * np.pi * u2 * np.cos(2 * np.pi * x / a) / (4 * b * np.pi + a * np.sinh(4 * np.pi * b / a)) + vy1 = b * np.sinh(np.pi * b / a) * np.cosh(np.pi * y / a) - np.cosh(np.pi * b / a) * y * np.sinh(np.pi * y / a) + vy2 = b * np.sinh(2 * np.pi * b / a) * np.cosh(2 * np.pi * y / a) - np.cosh(2 * np.pi * b / a) * y * np.sinh(2 * np.pi * y / a) + vy = prefactor1 * vy1 + prefactor2 * vy2 + + # vy1 = b * np.sinh(np.pi * b / a) * np.cosh(np.pi * y / a) - np.cosh(np.pi * b / a) * y * np.sinh(np.pi * y / a) + # vy2 = b * np.sinh(2 * np.pi * b / a) * np.cosh(2 * np.pi * y / a) - np.cosh(2 * np.pi * b / a) * y * np.sinh(2 * np.pi * y / a) + # vy = np.pi * prefactor1 * vy1 + 2 * np.pi * prefactor2 * vy2 + + return vx, vy + + # @staticjit + # def _right(x, y, a, b, tau, u1, u2): + # \"\"\"The velocity field when the right domain drives\"\"\" + # prefactor1 = 2 * u1 * np.sin(np.pi * x / a) / (2 * b * np.pi + a * np.sinh(2 * np.pi * b / a)) + # prefactor2 = 2 * u2 * np.sin(2 * np.pi * x / a) / (4 * b * np.pi + a * np.sinh(4 * np.pi * b / a)) + # vx1 = -b * np.pi * np.sinh(np.pi * b / a) * np.sinh(np.pi * y / a) - np.cosh(np.pi * b / a) * (np.pi * y * np.cosh(np.pi * y /a) + a * np.sinh(np.pi * y /a)) + # vx2 = -4 * b * np.pi * np.sinh(2 * np.pi * b / a) * np.sinh(2 * np.pi * y / a) - np.cosh(2 * np.pi * b / a) * (2 * np.pi * y * np.cosh(2 * np.pi * y /a) + a * np.sinh(2 * np.pi * y /a)) + # vx = prefactor1 * vx1 - prefactor2 * vx2 + + # prefactor1 = 2 * np.pi * u1 * np.cos(np.pi * x / a) / (2 * b * np.pi + a * np.sinh(2 * np.pi * b / a)) + # prefactor2 = 4 * np.pi * u2 * np.cos(2 * np.pi * x / a) / (4 * b * np.pi + a * np.sinh(4 * np.pi * b / a)) + # vy1 = -b * np.sinh(np.pi * b / a) * np.cosh(np.pi * y / a) + np.cosh(np.pi * b / a) * y * np.sinh(np.pi * y / a) + # vy2 = -2 * b * np.sinh(2 * np.pi * b / a) * np.cosh(2 * np.pi * y / a) + np.cosh(2 * np.pi * b / a) * 2 * y * np.sinh(2 * np.pi * y / a) + # vy = prefactor1 * vy1 + prefactor2 * vy2 + + # return vx, vy + + @staticjit + def _protocol(t, tau, stiffness=20): + return 0.5 + 0.5 * np.tanh(tau * stiffness * np.sin(2 * np.pi * t / tau)) + + def rhs(self, X, t): + x, y, tt = X + weight = self._protocol(tt, self.tau) + dx1, dy1 = self._lid(x, y, self.a, self.b, self.tau, self.u1, self.u2) + dx2, dy2 = self._lid(x, y, self.a, self.b, self.tau, -self.u1, self.u2) + dx = weight * dx1 + (1 - weight) * dx2 + dy = weight * dy1 + (1 - weight) * dy2 + dtt = 1 + return dx, dy, dtt + + def _postprocessing(self, x, y, tt): + return x, y, np.sin(2 * np.pi * tt / self.tau) +""" +@doc make_docstring(LidDrivenCavityFlow) LidDrivenCavityFlow +function LidDrivenCavityFlow() + function lid(x, y, a, b, tau, u1, u2) + prefactor1 = 2 * u1 * sin(pi * x / a) / (2 * b * pi + a * sinh(2 * pi * b / a)) + prefactor2 = 2 * u2 * sin(2 * pi * x / a) / (4 * b * pi + a * sinh(4 * pi * b / a)) + vx1 = -b * pi * sinh(pi * b / a) * sinh(pi * y / a) + cosh(pi * b / a) * (pi * y * cosh(pi * y /a) + a * sinh(pi * y / a)) + vx2 = -2 * b * pi * sinh(2 * pi * b / a) * sinh(2 * pi * y / a) + cosh(2 * pi * b / a) * (2 * pi * y * cosh(2 * pi * y / a) + a * sinh(2 * pi * y / a)) + vx = prefactor1 * vx1 + prefactor2 * vx2 + + prefactor1 = 2 * pi * u1 * cos(pi * x / a) / (2 * b * pi + a * sinh(2 * pi * b / a)) + prefactor2 = 4 * pi * u2 * cos(2 * pi * x / a) / (4 * b * pi + a * sinh(4 * pi * b / a)) + vy1 = b * sinh(pi * b / a) * cosh(pi * y / a) - cosh(pi * b / a) * y * sinh(pi * y / a) + vy2 = b * sinh(2 * pi * b / a) * cosh(2 * pi * y / a) - cosh(2 * pi * b / a) * y * sinh(2 * pi * y / a) + vy = prefactor1 * vy1 + prefactor2 * vy2 + + return vx, vy + end + function protocol(t, tau, stiffness=20) + return 0.5 + 0.5 * tanh(tau * stiffness * sin(2 * pi * t / tau)) + end + function rhs(du, u, p, t) + a, b, tau, u1, u2 = p + x, y, tt = u + weight = protocol(tt, tau) + dx1, dy1 = lid(x, y, a, b, tau, u1, u2) + dx2, dy2 = lid(x, y, a, b, tau, -u1, u2) + dx = weight * dx1 + (1 - weight) * dx2 + dy = weight * dy1 + (1 - weight) * dy2 + dtt = 1 + du[1] = dx + du[2] = dy + du[3] = dtt + end + u0 = Float64.(ATTRACTOR_DATA["LidDrivenCavityFlow"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["LidDrivenCavityFlow"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +# class BlinkingVortex(BlinkingRotlet): +# pass + +# class InteriorSquirmer(DynSys): + +# @staticjit +# def _rhs_static(r, th, t, a, g, n): + +# nvals = np.arange(1, n + 1) +# sinvals, cosvals = np.sin(th * nvals), np.cos(th * nvals) +# rnvals = r ** nvals + +# vrn = g * cosvals + a * sinvals +# vrn *= (nvals * rnvals * (r ** 2 - 1)) / r + +# vth = 2 * r + (r ** 2 - 1) * nvals / r +# vth *= a * cosvals - g * sinvals +# vth *= rnvals + +# return np.sum(vrn), np.sum(vth) / r + +# @staticjit +# def _jac_static(r, th, t, a, g, n): + +# nvals = np.arange(1, n + 1) +# sinvals, cosvals = np.sin(th * nvals), np.cos(th * nvals) +# rnvals = r ** nvals +# trigsum = a * sinvals + g * cosvals +# trigskew = a * cosvals - g * sinvals + +# j11 = np.copy(trigsum) +# j11 *= nvals * rnvals * (2 * r ** 2 + (r ** 2 - 1) * (nvals - 1)) +# j11 = (1 / r ** 2) * np.sum(j11) + +# j12 = np.copy(trigskew) +# j12 *= -(nvals ** 2) * rnvals * (1 - r ** 2) / r +# j12 = np.sum(j12) + +# j21 = 2 * rnvals * (2 * nvals + 1) * (-np.copy(trigskew)) +# j21 += (n * (1 - r ** 2) * rnvals * (nvals - 1) / r ** 2) * np.copy( +# g * sinvals + a * cosvals +# ) +# j21 = -np.sum(j21) + +# j22 = np.copy(trigsum) +# j22 *= -nvals * rnvals * (2 * r + (r ** 2 - 1) * nvals / r) +# j22 = np.sum(j22) +# # (1 / r**2) * + +# ## Correct for polar coordinates +# vth = np.copy(trigskew) +# vth *= 2 * r + (r ** 2 - 1) * nvals / r +# vth *= rnvals +# vth = np.sum(vth) / r +# j21 = j21 / r - vth / r +# j22 /= r + +# return np.array([[j11, j12], [j21, j22]]) + +# @staticjit +# def _protocol(t, tau, stiffness=20): +# return 0.5 + 0.5 * np.tanh(tau * stiffness * np.sin(2 * np.pi * t / tau)) + +# def _postprocessing(self, r, th, tt): +# return r * np.cos(th), r * np.sin(th), np.sin(2 * np.pi * tt / self.tau) + +# def jac(self, X, t): +# r, th = X[0], X[1] +# phase = self._protocol(t, self.tau) +# return self._jac_static(r, th, t, self.a * phase, self.g * (1 - phase), self.n) + +# def rhs(self, X, t): +# r, th, tt = X +# phase = self._protocol(tt, self.tau) +# dtt = 1 +# dr, dth = self._rhs_static(r, th, t, self.a * phase, self.g * (1 - phase), self.n) +# return dr, dth, dtt + +function OscillatingFlow end +originalcode(::typeof(OscillatingFlow)) = """ +class OscillatingFlow(DynSys): + @staticjit + def _rhs(x, y, z, t, b, k, omega, u): + f = x + b * np.sin(z) + dx = u * np.cos(k * y) * np.sin(k * f) + dy = -u * np.sin(k * y) * np.cos(k * f) + dz = omega + return dx, dy, dz + + def _postprocessing(self, x, y, z): + return np.cos(self.k * x), y, np.sin(z) +""" +@doc make_docstring(OscillatingFlow) OscillatingFlow +function OscillatingFlow() + function rhs(du, u, p, t) + x, y, z = u + b, k, omega, u = p + f = x + b * sin(z) + du[1] = u * cos(k * y) * sin(k * f) + du[2] = -u * sin(k * y) * cos(k * f) + du[3] = omega + end + u0 = Float64.(ATTRACTOR_DATA["OscillatingFlow"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["OscillatingFlow"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function BickleyJet end +originalcode(::typeof(BickleyJet)) = """ +class BickleyJet(DynSys): + @staticjit + def _rhs(y, x, z, t, ell, eps, k, omega, sigma, u): + sechy = 1 / np.cosh(y / ell) + inds = np.arange(3) + un = k[inds] * (x - z * sigma[inds]) + dx = u * sechy ** 2 * (-1 - 2 * np.dot(np.cos(un), eps) * np.tanh(y / ell)) + dy = ell * u * sechy ** 2 * np.dot(eps * k, np.sin(un)) + dz = omega + return dy, dx, dz + + def _postprocessing(self, x, y, z): + km = np.min(self.k) + sm = np.min(self.sigma) + return x, np.sin(km * y), np.sin(self.omega * z * km * sm) +""" +@doc make_docstring(BickleyJet) BickleyJet +function BickleyJet() + function rhs(du, u, p, t) + y, x, z = u + ell, eps, k, omega, sigma, u = p + sechy = 1 / cosh(y / ell) + un = k .* (x - z .* sigma) + du[1] = u * sechy^2 * (-1 - 2 * dot(cos.(un), eps) * tanh(y / ell)) + du[2] = ell * u * sechy^2 * dot(eps .* k, sin.(un)) + du[3] = omega + end + u0 = Float64.(ATTRACTOR_DATA["BickleyJet"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["BickleyJet"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function ArnoldBeltramiChildress end +originalcode(::typeof(ArnoldBeltramiChildress)) = """ +class ArnoldBeltramiChildress(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + dx = a * np.sin(z) + c * np.cos(y) + dy = b * np.sin(x) + a * np.cos(z) + dz = c * np.sin(y) + b * np.cos(x) + return dx, dy, dz + + @staticjit + def _postprocessing(x, y, z): + return np.sin(x), np.cos(y), np.sin(z) +""" +@doc make_docstring(ArnoldBeltramiChildress) ArnoldBeltramiChildress +function ArnoldBeltramiChildress() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = a * sin(z) + c * cos(y) + du[2] = b * sin(x) + a * cos(z) + du[3] = c * sin(y) + b * cos(x) + end + u0 = Float64.(ATTRACTOR_DATA["ArnoldBeltramiChildress"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ArnoldBeltramiChildress"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function JerkCircuit end +originalcode(::typeof(JerkCircuit)) = """ +class JerkCircuit(DynSys): + @staticjit + def _rhs(x, y, z, t, eps, y0): + xdot = y + ydot = z + zdot = -z - x - eps * (np.exp(y / y0) - 1) + return xdot, ydot, zdot +""" +@doc make_docstring(JerkCircuit) JerkCircuit +function JerkCircuit() + function rhs(du, u, p, t) + x, y, z = u + eps, y0 = p + du[1] = y + du[2] = z + du[3] = -z - x - eps * (exp(y / y0) - 1) + end + u0 = Float64.(ATTRACTOR_DATA["JerkCircuit"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["JerkCircuit"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function ForcedBrusselator end +originalcode(::typeof(ForcedBrusselator)) = """ +class ForcedBrusselator(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, f, w): + xdot = a + x ** 2 * y - (b + 1) * x + f * np.cos(z) + ydot = b * x - x ** 2 * y + zdot = w + return xdot, ydot, zdot + + @staticjit + def _postprocessing(x, y, z): + return x, y, np.sin(z) +""" +@doc make_docstring(ForcedBrusselator) ForcedBrusselator +function ForcedBrusselator() + function rhs(du, u, p, t) + x, y, z = u + a, b, f, w = p + du[1] = a + x^2 * y - (b + 1) * x + f * cos(z) + du[2] = b * x - x^2 * y + du[3] = w + end + u0 = Float64.(ATTRACTOR_DATA["ForcedBrusselator"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ForcedBrusselator"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function WindmiReduced end +originalcode(::typeof(WindmiReduced)) = """ +class WindmiReduced(DynSys): + @staticjit + def _rhs(i, v, p, t, a1, b1, b2, b3, d1, vsw): + idot = a1 * (vsw - v) + vdot = b1 * i - b2 * p ** 1 / 2 - b3 * v + pdot = ( + vsw ** 2 - p ** (5 / 4) * vsw ** (1 / 2) * (1 + np.tanh(d1 * (i - 1))) / 2 + ) + return idot, vdot, pdot +""" +@doc make_docstring(WindmiReduced) WindmiReduced +function WindmiReduced() + function rhs(du, u, p, t) + i, v, p = u + a1, b1, b2, b3, d1, vsw = p + du[1] = a1 * (vsw - v) + du[2] = b1 * i - b2 * p^(1 / 2) - b3 * v + du[3] = vsw^2 - p^(5 / 4) * vsw^(1 / 2) * (1 + tanh(d1 * (i - 1))) / 2 + end + u0 = Float64.(ATTRACTOR_DATA["WindmiReduced"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["WindmiReduced"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function MooreSpiegel end +originalcode(::typeof(MooreSpiegel)) = """ +class MooreSpiegel(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, eps): + xdot = y + ydot = a * z + zdot = -z + eps * y - y * x ** 2 - b * x + return xdot, ydot, zdot +""" +@doc make_docstring(MooreSpiegel) MooreSpiegel +function MooreSpiegel() + function rhs(du, u, p, t) + x, y, z = u + a, b, eps = p + du[1] = y + du[2] = a * z + du[3] = -z + eps * y - y * x^2 - b * x + end + u0 = Float64.(ATTRACTOR_DATA["MooreSpiegel"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["MooreSpiegel"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function CoevolvingPredatorPrey end +originalcode(::typeof(CoevolvingPredatorPrey)) = """ +class CoevolvingPredatorPrey(DynSys): + @staticjit + def _rhs(x, y, alpha, t, a1, a2, a3, b1, b2, d1, d2, delta, k1, k2, k4, vv): + xdot = x * ( + -((a3 * y) / (1 + b2 * x)) + + (a1 * alpha * (1 - k1 * x * (-alpha + alpha * delta))) / (1 + b1 * alpha) + - d1 + * ( + 1 + - k2 * (-(alpha ** 2) + (alpha * delta) ** 2) + + k4 * (-(alpha ** 4) + (alpha * delta) ** 4) + ) + ) + ydot = (-d2 + (a2 * x) / (1 + b2 * x)) * y + alphadot = vv * ( + -((a1 * k1 * x * alpha * delta) / (1 + b1 * alpha)) + - d1 * (-2 * k2 * alpha * delta ** 2 + 4 * k4 * alpha ** 3 * delta ** 4) + ) + return xdot, ydot, alphadot +""" +@doc make_docstring(CoevolvingPredatorPrey) CoevolvingPredatorPrey +function CoevolvingPredatorPrey() + function rhs(du, u, p, t) + x, y, alpha = u + a1, a2, a3, b1, b2, d1, d2, delta, k1, k2, k4, vv = p + du[1] = x * ( + -((a3 * y) / (1 + b2 * x)) + + (a1 * alpha * (1 - k1 * x * (-alpha + alpha * delta))) / (1 + b1 * alpha) + - d1 + * ( + 1 + - k2 * (-alpha^2 + (alpha * delta)^2) + + k4 * (-alpha^4 + (alpha * delta)^4) + ) + ) + du[2] = (-d2 + (a2 * x) / (1 + b2 * x)) * y + du[3] = vv * ( + -((a1 * k1 * x * alpha * delta) / (1 + b1 * alpha)) + - d1 * (-2 * k2 * alpha * delta^2 + 4 * k4 * alpha^3 * delta^4) + ) + end + u0 = Float64.(ATTRACTOR_DATA["CoevolvingPredatorPrey"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["CoevolvingPredatorPrey"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function KawczynskiStrizhak end +originalcode(::typeof(KawczynskiStrizhak)) = """ +class KawczynskiStrizhak(DynSys): + @staticjit + def _rhs(x, y, z, t, beta, gamma, kappa, mu): + xdot = gamma * y - gamma * x ** 3 + 3 * mu * gamma * x + ydot = -2 * mu * x - y - z + beta + zdot = kappa * x - kappa * z + return xdot, ydot, zdot +""" +@doc make_docstring(KawczynskiStrizhak) KawczynskiStrizhak +function KawczynskiStrizhak() + function rhs(du, u, p, t) + x, y, z = u + beta, gamma, kappa, mu = p + du[1] = gamma * y - gamma * x^3 + 3 * mu * gamma * x + du[2] = -2 * mu * x - y - z + beta + du[3] = kappa * x - kappa * z + end + u0 = Float64.(ATTRACTOR_DATA["KawczynskiStrizhak"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["KawczynskiStrizhak"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function BelousovZhabotinsky end +originalcode(::typeof(BelousovZhabotinsky)) = """ +class BelousovZhabotinsky(DynSys): + @staticjit + def _rhs( + x, + z, + v, + t, + c1, + c10, + c11, + c12, + c13, + c2, + c3, + c4, + c5, + c6, + c7, + c8, + c9, + ci, + kf, + t0, + y0, + yb1, + yb2, + yb3, + z0, + ): + ybar = (1 / y0) * yb1 * z * v / (yb2 * x + yb3 + kf) + if x < 0.0: + x = 0 + rf = (ci - z0 * z) * np.sqrt(x) + xdot = c1 * x * ybar + c2 * ybar + c3 * x ** 2 + c4 * rf + c5 * x * z - kf * x + zdot = (c6 / z0) * rf + c7 * x * z + c8 * z * v + c9 * z - kf * z + vdot = c10 * x * ybar + c11 * ybar + c12 * x ** 2 + c13 * z * v - kf * v + return xdot * t0, zdot * t0, vdot * t0 +""" +@doc make_docstring(BelousovZhabotinsky) BelousovZhabotinsky +function BelousovZhabotinsky() + function rhs(du, u, p, t) + x, z, v = u + c1, c10, c11, c12, c13, c2, c3, c4, c5, c6, c7, c8, c9, ci, kf, t0, y0, yb1, yb2, yb3, z0 = p + ybar = (1 / y0) * yb1 * z * v / (yb2 * x + yb3 + kf) + if x < 0.0 + x = 0 + end + rf = (ci - z0 * z) * sqrt(x) + du[1] = c1 * x * ybar + c2 * ybar + c3 * x^2 + c4 * rf + c5 * x * z - kf * x + du[2] = (c6 / z0) * rf + c7 * x * z + c8 * z * v + c9 * z - kf * z + du[3] = c10 * x * ybar + c11 * ybar + c12 * x^2 + c13 * z * v - kf * v + end + u0 = Float64.(ATTRACTOR_DATA["BelousovZhabotinsky"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["BelousovZhabotinsky"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function IsothermalChemical end +originalcode(::typeof(IsothermalChemical)) = """ +class IsothermalChemical(DynSys): + @staticmethod + def _rhs(alpha, beta, gamma, t, delta, kappa, mu, sigma): + alphadot = mu * (kappa + gamma) - alpha * beta ** 2 - alpha + betadot = (alpha * beta ** 2 + alpha - beta) / sigma + gammadot = (beta - gamma) / delta + return alphadot, betadot, gammadot +""" +@doc make_docstring(IsothermalChemical) IsothermalChemical +function IsothermalChemical() + function rhs(du, u, p, t) + alpha, beta, gamma = u + delta, kappa, mu, sigma = p + du[1] = mu * (kappa + gamma) - alpha * beta^2 - alpha + du[2] = (alpha * beta^2 + alpha - beta) / sigma + du[3] = (beta - gamma) / delta + end + u0 = Float64.(ATTRACTOR_DATA["IsothermalChemical"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["IsothermalChemical"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + + +function VallisElNino end +originalcode(::typeof(VallisElNino)) = """ +class VallisElNino(DynSys): + @staticmethod + def _rhs(x, y, z, t, b, c, p): + xdot = b * y - c * x - c * p + ydot = -y + x * z + zdot = -z - x * y + 1 + return xdot, ydot, zdot +""" +@doc make_docstring(VallisElNino) VallisElNino +function VallisElNino() + function rhs(du, u, p, t) + x, y, z = u + b, c, p = p + du[1] = b * y - c * x - c * p + du[2] = -y + x * z + du[3] = -z - x * y + 1 + end + u0 = Float64.(ATTRACTOR_DATA["VallisElNino"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["VallisElNino"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function RabinovichFabrikant end +originalcode(::typeof(RabinovichFabrikant)) = """ +class RabinovichFabrikant(DynSys): + @staticjit + def _rhs(x, y, z, t, a, g): + xdot = y * z - y + y * x ** 2 + g * x + ydot = 3 * x * z + x - x ** 3 + g * y + zdot = -2 * a * z - 2 * x * y * z + return (xdot, ydot, zdot) +""" +@doc make_docstring(RabinovichFabrikant) RabinovichFabrikant +function RabinovichFabrikant() + function rhs(du, u, p, t) + x, y, z = u + a, g = p + du[1] = y * z - y + y * x^2 + g * x + du[2] = 3 * x * z + x - x^3 + g * y + du[3] = -2 * a * z - 2 * x * y * z + end + u0 = Float64.(ATTRACTOR_DATA["RabinovichFabrikant"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["RabinovichFabrikant"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function NoseHoover end +originalcode(::typeof(NoseHoover)) = """ +class NoseHoover(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = y + ydot = -x + y * z + zdot = a - y ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(NoseHoover) NoseHoover +function NoseHoover() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = y + du[2] = -x + y * z + du[3] = a - y^2 + end + u0 = Float64.(ATTRACTOR_DATA["NoseHoover"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["NoseHoover"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function Dadras end +originalcode(::typeof(Dadras)) = """ +class Dadras(DynSys): + @staticjit + def _rhs(x, y, z, t, c, e, o, p, r): + xdot = y - p * x + o * y * z + ydot = r * y - x * z + z + zdot = c * x * y - e * z + return xdot, ydot, zdot +""" +@doc make_docstring(Dadras) Dadras +function Dadras() + function rhs(du, u, p, t) + x, y, z = u + c, e, o, p, r = p + du[1] = y - p * x + o * y * z + du[2] = r * y - x * z + z + du[3] = c * x * y - e * z + end + u0 = Float64.(ATTRACTOR_DATA["Dadras"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Dadras"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function RikitakeDynamo end +originalcode(::typeof(RikitakeDynamo)) = """ +class RikitakeDynamo(DynSys): + @staticjit + def _rhs(x, y, z, t, a, mu): + xdot = -mu * x + y * z + ydot = -mu * y - a * x + x * z + zdot = 1 - x * y + return xdot, ydot, zdot +""" +@doc make_docstring(RikitakeDynamo) RikitakeDynamo +function RikitakeDynamo() + function rhs(du, u, p, t) + x, y, z = u + a, mu = p + du[1] = -mu * x + y * z + du[2] = -mu * y - a * x + x * z + du[3] = 1 - x * y + end + u0 = Float64.(ATTRACTOR_DATA["RikitakeDynamo"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["RikitakeDynamo"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function NuclearQuadrupole end +originalcode(::typeof(NuclearQuadrupole)) = """ +class NuclearQuadrupole(DynSys): + @staticjit + def _rhs(q1, q2, p1, p2, t, a, b, d): + q1dot = a * p1 + q2dot = a * p2 + p1dot = - a * q1 + 3 / np.sqrt(2) * b * q1 ** 2 - 3 / np.sqrt(2) * b * q2 ** 2 - d * q1 ** 3 - d * q1 * q2 ** 2 + p2dot = -a * q2 - 3 * np.sqrt(2) * b * q1 * q2 - d * q2 * q1 ** 2 - d * q2 ** 3 + return q1dot, q2dot, p1dot, p2dot +""" +@doc make_docstring(NuclearQuadrupole) NuclearQuadrupole +function NuclearQuadrupole() + function rhs(du, u, p, t) + q1, q2, p1, p2 = u + a, b, d = p + du[1] = a * p1 + du[2] = a * p2 + du[3] = - a * q1 + 3 / sqrt(2) * b * q1^2 - 3 / sqrt(2) * b * q2^2 - d * q1^3 - d * q1 * q2^2 + du[4] = -a * q2 - 3 * sqrt(2) * b * q1 * q2 - d * q2 * q1^2 - d * q2^3 + end + u0 = Float64.(ATTRACTOR_DATA["NuclearQuadrupole"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["NuclearQuadrupole"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function PehlivanWei end +originalcode(::typeof(PehlivanWei)) = """ +class PehlivanWei(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = y - y * z + ydot = y + y * z - 2 * x + zdot = 2 - x * y - y ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(PehlivanWei) PehlivanWei +function PehlivanWei() + function rhs(du, u, p, t) + x, y, z = u + du[1] = y - y * z + du[2] = y + y * z - 2 * x + du[3] = 2 - x * y - y^2 + end + u0 = Float64.(ATTRACTOR_DATA["PehlivanWei"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["PehlivanWei"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true) + return prob +end + +function SprottTorus end +originalcode(::typeof(SprottTorus)) = """ +class SprottTorus(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = y + 2 * x * y + x * z + ydot = 1 - 2 * x ** 2 + y * z + zdot = x - x ** 2 - y ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(SprottTorus) SprottTorus +function SprottTorus() + function rhs(du, u, p, t) + x, y, z = u + du[1] = y + 2 * x * y + x * z + du[2] = 1 - 2 * x^2 + y * z + du[3] = x - x^2 - y^2 + end + u0 = Float64.(ATTRACTOR_DATA["SprottTorus"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottTorus"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true, sparse=true) + return prob +end + +function SprottJerk end +originalcode(::typeof(SprottJerk)) = """ +class SprottJerk(DynSys): + @staticjit + def _rhs(x, y, z, t, mu): + xdot = y + ydot = z + zdot = -x + y ** 2 - mu * z + return xdot, ydot, zdot +""" +@doc make_docstring(SprottJerk) SprottJerk +function SprottJerk() + function rhs(du, u, p, t) + x, y, z = u + mu = p + du[1] = y + du[2] = z + du[3] = -x + y^2 - mu * z + end + u0 = Float64.(ATTRACTOR_DATA["SprottJerk"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottJerk"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true, sparse=true) + return prob +end + + +# ## Not chaotic +# # class JerkCircuit(DynSys): +# # def rhs(self, X, t): +# # x, y, z = X +# # xdot = y +# # ydot = z +# # zdot = -z - x - self.eps*(np.exp(y/self.y0) - 1) +# # return (xdot, ydot, zdot) + +function SprottA end +originalcode(::typeof(SprottA)) = """ +class SprottA(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = y + ydot = -x + y * z + zdot = 1 - y ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(SprottA) SprottA +function SprottA() + function rhs(du, u, p, t) + x, y, z = u + du[1] = y + du[2] = -x + y * z + du[3] = 1 - y^2 + end + u0 = Float64.(ATTRACTOR_DATA["SprottA"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottA"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true, sparse=true) + return prob +end + +function SprottB end +originalcode(::typeof(SprottB)) = """ +class SprottB(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = y * z + ydot = x - y + zdot = 1 - x * y + return xdot, ydot, zdot +""" +@doc make_docstring(SprottB) SprottB +function SprottB() + function rhs(du, u, p, t) + x, y, z = u + du[1] = y * z + du[2] = x - y + du[3] = 1 - x * y + end + u0 = Float64.(ATTRACTOR_DATA["SprottB"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottB"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true, sparse=true) + return prob +end + +function SprottC end +originalcode(::typeof(SprottC)) = """ +class SprottC(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = y * z + ydot = x - y + zdot = 1 - x ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(SprottC) SprottC +function SprottC() + function rhs(du, u, p, t) + x, y, z = u + du[1] = y * z + du[2] = x - y + du[3] = 1 - x^2 + end + u0 = Float64.(ATTRACTOR_DATA["SprottC"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottC"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p, jac=true, sparse=true) + return prob +end + +function SprottD end +originalcode(::typeof(SprottD)) = """ +class SprottD(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = -y + ydot = x + z + zdot = x * z + 3 * y ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(SprottD) SprottD +function SprottD() + function rhs(du, u, p, t) + x, y, z = u + du[1] = -y + du[2] = x + z + du[3] = x * z + 3 * y^2 + end + u0 = Float64.(ATTRACTOR_DATA["SprottD"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottD"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function SprottE end +originalcode(::typeof(SprottE)) = """ +class SprottE(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = y * z + ydot = x ** 2 - y + zdot = 1 - 4 * x + return xdot, ydot, zdot +""" +@doc make_docstring(SprottE) SprottE +function SprottE() + function rhs(du, u, p, t) + x, y, z = u + du[1] = y * z + du[2] = x^2 - y + du[3] = 1 - 4 * x + end + u0 = Float64.(ATTRACTOR_DATA["SprottE"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottE"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function SprottF end +originalcode(::typeof(SprottF)) = """ +class SprottF(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = y + z + ydot = -x + a * y + zdot = x ** 2 - z + return xdot, ydot, zdot +""" +@doc make_docstring(SprottF) SprottF +function SprottF() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = y + z + du[2] = -x + a * y + du[3] = x^2 - z + end + u0 = Float64.(ATTRACTOR_DATA["SprottF"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottF"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function SprottG end +originalcode(::typeof(SprottG)) = """ +class SprottG(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = a * x + z + ydot = x * z - y + zdot = -x + y + return xdot, ydot, zdot +""" +@doc make_docstring(SprottG) SprottG +function SprottG() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = a * x + z + du[2] = x * z - y + du[3] = -x + y + end + u0 = Float64.(ATTRACTOR_DATA["SprottG"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottG"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function SprottH end +originalcode(::typeof(SprottH)) = """ +class SprottH(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = -y + z ** 2 + ydot = x + a * y + zdot = x - z + return xdot, ydot, zdot +""" +@doc make_docstring(SprottH) SprottH +function SprottH() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = -y + z^2 + du[2] = x + a * y + du[3] = x - z + end + u0 = Float64.(ATTRACTOR_DATA["SprottH"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottH"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function SprottI end +originalcode(::typeof(SprottI)) = """ +class SprottI(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = -a * y + ydot = x + z + zdot = x + y ** 2 - z + return xdot, ydot, zdot +""" +@doc make_docstring(SprottI) SprottI +function SprottI() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = -a * y + du[2] = x + z + du[3] = x + y^2 - z + end + u0 = Float64.(ATTRACTOR_DATA["SprottI"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottI"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function SprottJ end +originalcode(::typeof(SprottJ)) = """ +class SprottJ(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = 2 * z + ydot = -2 * y + z + zdot = -x + y + y ** 2 + return (xdot, ydot, zdot) +""" +@doc make_docstring(SprottJ) SprottJ +function SprottJ() + function rhs(du, u, p, t) + x, y, z = u + du[1] = 2 * z + du[2] = -2 * y + z + du[3] = -x + y + y^2 + end + u0 = Float64.(ATTRACTOR_DATA["SprottJ"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottJ"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function SprottK end +originalcode(::typeof(SprottK)) = """ +class SprottK(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = x * y - z + ydot = x - y + zdot = x + a * z + return xdot, ydot, zdot +""" +@doc make_docstring(SprottK) SprottK +function SprottK() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = x * y - z + du[2] = x - y + du[3] = x + a * z + end + u0 = Float64.(ATTRACTOR_DATA["SprottK"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottK"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottL end +originalcode(::typeof(SprottL)) = """ +class SprottL(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = y + b * z + ydot = a * x ** 2 - y + zdot = 1 - x + return xdot, ydot, zdot +""" +@doc make_docstring(SprottL) SprottL +function SprottL() + function rhs(du, u, p, t) + x, y, z = u + a, b = p + du[1] = y + b * z + du[2] = a * x^2 - y + du[3] = 1 - x + end + u0 = Float64.(ATTRACTOR_DATA["SprottL"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottL"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottM end +originalcode(::typeof(SprottM)) = """ +class SprottM(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = -z + ydot = -x ** 2 - y + zdot = a + a * x + y + return xdot, ydot, zdot +""" +@doc make_docstring(SprottM) SprottM +function SprottM() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = -z + du[2] = -x^2 - y + du[3] = a + a * x + y + end + u0 = Float64.(ATTRACTOR_DATA["SprottM"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottM"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottN end +originalcode(::typeof(SprottN)) = """ +class SprottN(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = -2 * y + ydot = x + z ** 2 + zdot = 1 + y - 2 * z + return xdot, ydot, zdot +""" +@doc make_docstring(SprottN) SprottN +function SprottN() + function rhs(du, u, p, t) + x, y, z = u + du[1] = -2 * y + du[2] = x + z^2 + du[3] = 1 + y - 2 * z + end + u0 = Float64.(ATTRACTOR_DATA["SprottN"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottN"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottO end +originalcode(::typeof(SprottO)) = """ +class SprottO(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = y + ydot = x - z + zdot = x + x * z + a * y + return xdot, ydot, zdot +""" +@doc make_docstring(SprottO) SprottO +function SprottO() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = y + du[2] = x - z + du[3] = x + x * z + a * y + end + u0 = Float64.(ATTRACTOR_DATA["SprottO"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottO"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottP end +originalcode(::typeof(SprottP)) = """ +class SprottP(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = a * y + z + ydot = -x + y ** 2 + zdot = x + y + return xdot, ydot, zdot +""" +@doc make_docstring(SprottP) SprottP +function SprottP() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = a * y + z + du[2] = -x + y^2 + du[3] = x + y + end + u0 = Float64.(ATTRACTOR_DATA["SprottP"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottP"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottQ end +originalcode(::typeof(SprottQ)) = """ +class SprottQ(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = -z + ydot = x - y + zdot = a * x + y ** 2 + b * z + return (xdot, ydot, zdot) +""" +@doc make_docstring(SprottQ) SprottQ +function SprottQ() + function rhs(du, u, p, t) + x, y, z = u + a, b = p + du[1] = -z + du[2] = x - y + du[3] = a * x + y^2 + b * z + end + u0 = Float64.(ATTRACTOR_DATA["SprottQ"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottQ"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottR end +originalcode(::typeof(SprottR)) = """ +class SprottR(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = a - y + ydot = b + z + zdot = x * y - z + return xdot, ydot, zdot +""" +@doc make_docstring(SprottR) SprottR +function SprottR() + function rhs(du, u, p, t) + x, y, z = u + a, b = p + du[1] = a - y + du[2] = b + z + du[3] = x * y - z + end + u0 = Float64.(ATTRACTOR_DATA["SprottR"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottR"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottS end +originalcode(::typeof(SprottS)) = """ +class SprottS(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = -x - 4 * y + ydot = x + z ** 2 + zdot = 1 + x + return xdot, ydot, zdot +""" +@doc make_docstring(SprottS) SprottS +function SprottS() + function rhs(du, u, p, t) + x, y, z = u + du[1] = -x - 4 * y + du[2] = x + z^2 + du[3] = 1 + x + end + u0 = Float64.(ATTRACTOR_DATA["SprottS"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottS"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SprottMore end +originalcode(::typeof(SprottMore)) = """ +class SprottMore(DynSys): + @staticjit + def _rhs(x, y, z, t): + xdot = y + ydot = -x - np.sign(z) * y + zdot = y ** 2 - np.exp(-(x ** 2)) + return xdot, ydot, zdot +""" +@doc make_docstring(SprottMore) SprottMore +function SprottMore() + function rhs(du, u, p, t) + x, y, z = u + du[1] = y + du[2] = -x - sign(z) * y + du[3] = y^2 - exp(-(x^2)) + end + u0 = Float64.(ATTRACTOR_DATA["SprottMore"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SprottMore"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function Arneodo end +originalcode(::typeof(Arneodo)) = """ +class Arneodo(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d): + xdot = y + ydot = z + zdot = -a * x - b * y - c * z + d * x ** 3 + return xdot, ydot, zdot +""" +@doc make_docstring(Arneodo) Arneodo +function Arneodo() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d = p + du[1] = y + du[2] = z + du[3] = -a * x - b * y - c * z + d * x^3 + end + u0 = Float64.(ATTRACTOR_DATA["Arneodo"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Arneodo"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +# class Coullet(Arneodo): +# pass +function Coullet end +originalcode(::typeof(Coullet)) = """ +class Rucklidge(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = -a * x + b * y - y * z + ydot = x + zdot = -z + y ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(Coullet) Coullet +function Rucklidge() + function rhs(du, u, p, t) + x, y, z = u + a, b = p + du[1] = -a * x + b * y - y * z + du[2] = x + du[3] = -z + y^2 + end + u0 = Float64.(ATTRACTOR_DATA["Rucklidge"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Rucklidge"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function Sakarya end +originalcode(::typeof(Sakarya)) = """ +class Sakarya(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, h, p, q, r, s): + xdot = a * x + h * y + s * y * z + ydot = -b * y - p * x + q * x * z + zdot = c * z - r * x * y + return xdot, ydot, zdot +""" +@doc make_docstring(Sakarya) Sakarya +function Sakarya() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, h, p, q, r, s = p + du[1] = a * x + h * y + s * y * z + du[2] = -b * y - p * x + q * x * z + du[3] = c * z - r * x * y + end + u0 = Float64.(ATTRACTOR_DATA["Sakarya"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Sakarya"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +# class LiuChen(Sakarya): +# pass + +function LiuChen end +originalcode(::typeof(LiuChen)) = """ +class RayleighBenard(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, r): + xdot = a * y - a * x + ydot = r * y - x * z + zdot = x * y - b * z + return xdot, ydot, zdot +""" +@doc make_docstring(LiuChen) LiuChen +function RayleighBenard() + function rhs(du, u, p, t) + x, y, z = u + a, b, r = p + du[1] = a * y - a * x + du[2] = r * y - x * z + du[3] = x * y - b * z + end + u0 = Float64.(ATTRACTOR_DATA["RayleighBenard"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["RayleighBenard"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function Finance end +originalcode(::typeof(Finance)) = """ +class Finance(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = (1 / b - a) * x + z + x * y + ydot = -b * y - x ** 2 + zdot = -x - c * z + return xdot, ydot, zdot +""" +@doc make_docstring(Finance) Finance +function Finance() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = (1 / b - a) * x + z + x * y + du[2] = -b * y - x^2 + du[3] = -x - c * z + end + u0 = Float64.(ATTRACTOR_DATA["Finance"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Finance"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,jac=true,sparse=true) + return prob +end + +function Bouali2 end +originalcode(::typeof(Bouali2)) = """ +class Bouali2(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, bb, c, g, m, y0): + xdot = a * y0 * x - a * x * y - b * z + ydot = -g * y + g * y * x ** 2 + zdot = -1.5 * m * x + m * bb * x * z - c * z + return xdot, ydot, zdot +""" +@doc make_docstring(Bouali2) Bouali2 +function Bouali2() + function rhs(du, u, p, t) + x, y, z = u + a, b, bb, c, g, m, y0 = p + du[1] = a * y0 * x - a * x * y - b * z + du[2] = -g * y + g * y * x^2 + du[3] = -1.5 * m * x + m * bb * x * z - c * z + end + u0 = Float64.(ATTRACTOR_DATA["Bouali2"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Bouali2"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,jac=true,sparse=true) + return prob +end + + +# class Bouali(Bouali2): +# pass + +function LuChenCheng end +originalcode(::typeof(LuChenCheng)) = """ +class LuChenCheng(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = -(a * b) / (a + b) * x - y * z + c + ydot = a * y + x * z + zdot = b * z + x * y + return xdot, ydot, zdot +""" +@doc make_docstring(LuChenCheng) LuChenCheng +function LuChenCheng() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = -(a * b) / (a + b) * x - y * z + c + du[2] = a * y + x * z + du[3] = b * z + x * y + end + u0 = Float64.(ATTRACTOR_DATA["LuChenCheng"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["LuChenCheng"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,jac=true,sparse=true) + return prob +end + +function LuChen end +originalcode(::typeof(LuChen)) = """ +class LuChen(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = a * y - a * x + ydot = -x * z + c * y + zdot = x * y - b * z + return xdot, ydot, zdot +""" +@doc make_docstring(LuChen) LuChen +function LuChen() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = a * y - a * x + du[2] = -x * z + c * y + du[3] = x * y - b * z + end + u0 = Float64.(ATTRACTOR_DATA["LuChen"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["LuChen"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,jac=true,sparse=true) + return prob +end + +function QiChen end +originalcode(::typeof(QiChen)) = """ +class QiChen(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = a * y - a * x + y * z + ydot = c * x + y - x * z + zdot = x * y - b * z + return xdot, ydot, zdot +""" +@doc make_docstring(QiChen) QiChen +function QiChen() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = a * y - a * x + y * z + du[2] = c * x + y - x * z + du[3] = x * y - b * z + end + u0 = Float64.(ATTRACTOR_DATA["QiChen"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["QiChen"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,jac=true,sparse=true) + return prob +end + +function ZhouChen end +originalcode(::typeof(ZhouChen)) = """ +class ZhouChen(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d, e): + xdot = a * x + b * y + y * z + ydot = c * y - x * z + d * y * z + zdot = e * z - x * y + return xdot, ydot, zdot +""" +@doc make_docstring(ZhouChen) ZhouChen +function ZhouChen() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d, e = p + du[1] = a * x + b * y + y * z + du[2] = c * y - x * z + d * y * z + du[3] = e * z - x * y + end + u0 = Float64.(ATTRACTOR_DATA["ZhouChen"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ZhouChen"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, jac=true, sparse=true) + return prob +end + +function BurkeShaw end +originalcode(::typeof(BurkeShaw)) = """ +class BurkeShaw(DynSys): + @staticjit + def _rhs(x, y, z, t, e, n): + xdot = -n * x - n * y + ydot = y - n * x * z + zdot = n * x * y + e + return xdot, ydot, zdot +""" +@doc make_docstring(BurkeShaw) BurkeShaw +function BurkeShaw() + function rhs(du, u, p, t) + x, y, z = u + e, n = p + du[1] = -n * x - n * y + du[2] = y - n * x * z + du[3] = n * x * y + e + end + u0 = Float64.(ATTRACTOR_DATA["BurkeShaw"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["BurkeShaw"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, jac=true, sparse=true) + return prob +end + +function Chen end +originalcode(::typeof(Chen)) = """ +class Chen(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = a * y - a * x + ydot = (c - a) * x - x * z + c * y + zdot = x * y - b * z + return xdot, ydot, zdot +""" +@doc make_docstring(Chen) Chen +function Chen() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = a * y - a * x + du[2] = (c - a) * x - x * z + c * y + du[3] = x * y - b * z + end + u0 = Float64.(ATTRACTOR_DATA["Chen"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Chen"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, jac=true, sparse=true) + return prob +end + +function ChenLee end +originalcode(::typeof(ChenLee)) = """ +class ChenLee(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = a * x - y * z + ydot = b * y + x * z + zdot = c * z + 0.3333333333333333333333333 * x * y + return xdot, ydot, zdot +""" +@doc make_docstring(ChenLee) ChenLee +function ChenLee() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = a * x - y * z + du[2] = b * y + x * z + du[3] = c * z + 0.3333333333333333333333333 * x * y + end + u0 = Float64.(ATTRACTOR_DATA["ChenLee"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ChenLee"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, jac=true, sparse=true) + return prob +end + +function WangSun end +originalcode(::typeof(WangSun)) = """ +class WangSun(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, d, e, f, q): + xdot = a * x + q * y * z + ydot = b * x + d * y - x * z + zdot = e * z + f * x * y + return xdot, ydot, zdot +""" +@doc make_docstring(WangSun) WangSun +function WangSun() + function rhs(du, u, p, t) + x, y, z = u + a, b, d, e, f, q = p + du[1] = a * x + q * y * z + du[2] = b * x + d * y - x * z + du[3] = e * z + f * x * y + end + u0 = Float64.(ATTRACTOR_DATA["WangSun"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["WangSun"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, jac=true, sparse=true) + return prob +end + +function YuWang end +originalcode(::typeof(YuWang)) = """ +class YuWang(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d): + xdot = a * (y - x) + ydot = b * x - c * x * z + zdot = np.exp(x * y) - d * z + return xdot, ydot, zdot +""" +@doc make_docstring(YuWang) YuWang +function YuWang() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d = p + du[1] = a * (y - x) + du[2] = b * x - c * x * z + du[3] = exp(x * y) - d * z + end + u0 = Float64.(ATTRACTOR_DATA["YuWang"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["YuWang"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, jac=true, sparse=true) + return prob +end + +function YuWang2 end +originalcode(::typeof(YuWang2)) = """ +class YuWang2(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d): + xdot = a * (y - x) + ydot = b * x - c * x * z + zdot = np.cosh(x * y) - d * z + return xdot, ydot, zdot +""" +@doc make_docstring(YuWang2) YuWang2 +function YuWang2() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d = p + du[1] = a * (y - x) + du[2] = b * x - c * x * z + du[3] = cosh(x * y) - d * z + end + u0 = Float64.(ATTRACTOR_DATA["YuWang2"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["YuWang2"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, jac=true, sparse=true) + return prob +end + +function SanUmSrisuchinwong end +originalcode(::typeof(SanUmSrisuchinwong)) = """ +class SanUmSrisuchinwong(DynSys): + @staticjit + def _rhs(x, y, z, t, a): + xdot = y - x + ydot = -z * np.tanh(x) + zdot = -a + x * y + np.abs(y) + return xdot, ydot, zdot +""" +@doc make_docstring(SanUmSrisuchinwong) SanUmSrisuchinwong +function SanUmSrisuchinwong() + function rhs(du, u, p, t) + x, y, z = u + a = p + du[1] = y - x + du[2] = -z * tanh(x) + du[3] = -a + x * y + abs(y) + end + u0 = Float64.(ATTRACTOR_DATA["SanUmSrisuchinwong"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SanUmSrisuchinwong"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function DequanLi end +originalcode(::typeof(DequanLi)) = """ +class DequanLi(DynSys): + @staticjit + def _rhs(x, y, z, t, a, c, d, eps, f, k): + xdot = a * y - a * x + d * x * z + ydot = k * x + f * y - x * z + zdot = c * z + x * y - eps * x ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(DequanLi) DequanLi +function DequanLi() + function rhs(du, u, p, t) + x, y, z = u + a, c, d, eps, f, k = p + du[1] = a * y - a * x + d * x * z + du[2] = k * x + f * y - x * z + du[3] = c * z + x * y - eps * x^2 + end + u0 = Float64.(ATTRACTOR_DATA["DequanLi"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["DequanLi"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + + +# class PanXuZhou(DequanLi): +# pass + + +# class Tsucs2(DequanLi): +# pass + +function ArnoldWeb end +originalcode(::typeof(ArnoldWeb)) = """ +class ArnoldWeb(DynSys): + @staticjit + def _rhs(p1, p2, x1, x2, z, t, mu, w): + denom = 4 + np.cos(z) + np.cos(x1) + np.cos(x2) + p1dot = -mu * np.sin(x1) / denom ** 2 + p2dot = -mu * np.sin(x2) / denom ** 2 + x1dot = p1 + x2dot = p2 + zdot = w + return p1dot, p2dot, x1dot, x2dot, zdot + + @staticjit + def _postprocessing(p1, p2, x1, x2, z): + return p1, p2, np.sin(x1), np.sin(x2), np.cos(z) +""" +@doc make_docstring(ArnoldWeb) ArnoldWeb +function ArnoldWeb() + function rhs(du, u, p, t) + p1, p2, x1, x2, z = u + mu, w = p + denom = 4 + cos(z) + cos(x1) + cos(x2) + du[1] = -mu * sin(x1) / denom^2 + du[2] = -mu * sin(x2) / denom^2 + du[3] = p1 + du[4] = p2 + du[5] = w + end + u0 = Float64.(ATTRACTOR_DATA["ArnoldWeb"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ArnoldWeb"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function NewtonLiepnik end +originalcode(::typeof(NewtonLiepnik)) = """ +class NewtonLiepnik(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = -a * x + y + 10 * y * z + ydot = -x - 0.4 * y + 5 * x * z + zdot = b * z - 5 * x * y + return xdot, ydot, zdot +""" +@doc make_docstring(NewtonLiepnik) NewtonLiepnik +function NewtonLiepnik() + function rhs(du, u, p, t) + x, y, z = u + a, b = p + du[1] = -a * x + y + 10 * y * z + du[2] = -x - 0.4 * y + 5 * x * z + du[3] = b * z - 5 * x * y + end + u0 = Float64.(ATTRACTOR_DATA["NewtonLiepnik"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["NewtonLiepnik"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function HyperRossler end +originalcode(::typeof(HyperRossler)) = """ +class HyperRossler(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d): + xdot = -y - z + ydot = x + a * y + w + zdot = b + x * z + wdot = -c * z + d * w + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperRossler) HyperRossler +function HyperRossler() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = -y - z + du[2] = x + a * y + w + du[3] = b + x * z + du[4] = -c * z + d * w + end + u0 = Float64.(ATTRACTOR_DATA["HyperRossler"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperRossler"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function HyperLorenz end +originalcode(::typeof(HyperLorenz)) = """ +class HyperLorenz(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d): + xdot = a * y - a * x + w + ydot = -x * z + c * x - y + zdot = -b * z + x * y + wdot = d * w - x * z + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperLorenz) HyperLorenz +function HyperLorenz() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + w + du[2] = -x * z + c * x - y + du[3] = -b * z + x * y + du[4] = d * w - x * z + end + u0 = Float64.(ATTRACTOR_DATA["HyperLorenz"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperLorenz"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function HyperCai end +originalcode(::typeof(HyperCai)) = """ +class HyperCai(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d, e): + xdot = a * y - a * x + ydot = b * x + c * y - x * z + w + zdot = -d * z + y ** 2 + wdot = -e * x + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperCai) HyperCai +function HyperCai() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d, e = p + du[1] = a * y - a * x + du[2] = b * x + c * y - x * z + w + du[3] = -d * z + y^2 + du[4] = -e * x + end + u0 = Float64.(ATTRACTOR_DATA["HyperCai"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperCai"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function HyperBao end +originalcode(::typeof(HyperBao)) = """ +class HyperBao(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d, e): + xdot = a * y - a * x + w + ydot = c * y - x * z + zdot = x * y - b * z + wdot = e * x + d * y * z + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperBao) HyperBao +function HyperBao() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d, e = p + du[1] = a * y - a * x + w + du[2] = c * y - x * z + du[3] = x * y - b * z + du[4] = e * x + d * y * z + end + u0 = Float64.(ATTRACTOR_DATA["HyperBao"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperBao"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function HyperJha end +originalcode(::typeof(HyperJha)) = """ +class HyperJha(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d): + xdot = a * y - a * x + w + ydot = -x * z + b * x - y + zdot = x * y - c * z + wdot = -x * z + d * w + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperJha) HyperJha +function HyperJha() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + w + du[2] = -x * z + b * x - y + du[3] = x * y - c * z + du[4] = -x * z + d * w + end + u0 = Float64.(ATTRACTOR_DATA["HyperJha"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperJha"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function HyperQi end +originalcode(::typeof(HyperQi)) = """ +class HyperQi(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d, e, f): + xdot = a * y - a * x + y * z + ydot = b * x + b * y - x * z + zdot = -c * z - e * w + x * y + wdot = -d * w + f * z + x * y + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperQi) HyperQi +function HyperQi() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d, e, f = p + du[1] = a * y - a * x + y * z + du[2] = b * x + b * y - x * z + du[3] = -c * z - e * w + x * y + du[4] = -d * w + f * z + x * y + end + u0 = Float64.(ATTRACTOR_DATA["HyperQi"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperQi"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function Qi end +originalcode(::typeof(Qi)) = """ +class Qi(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d): + xdot = a * y - a * x + y * z * w + ydot = b * x + b * y - x * z * w + zdot = -c * z + x * y * w + wdot = -d * w + x * y * z + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(Qi) Qi +function Qi() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + y * z * w + du[2] = b * x + b * y - x * z * w + du[3] = -c * z + x * y * w + du[4] = -d * w + x * y * z + end + u0 = Float64.(ATTRACTOR_DATA["Qi"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Qi"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function LorenzStenflo end +originalcode(::typeof(LorenzStenflo)) = """ +class LorenzStenflo(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a, b, c, d): + xdot = a * y - a * x + d * w + ydot = c * x - x * z - y + zdot = x * y - b * z + wdot = -x - a * w + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(LorenzStenflo) LorenzStenflo +function LorenzStenflo() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + d * w + du[2] = c * x - x * z - y + du[3] = x * y - b * z + du[4] = -x - a * w + end + u0 = Float64.(ATTRACTOR_DATA["LorenzStenflo"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["LorenzStenflo"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function HyperYangChen end +originalcode(::typeof(HyperYangChen)) = """ +class HyperYangChen(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a=30, b=3, c=35, d=8): + xdot = a * y - a * x + ydot = c * x - x * z + w + zdot = -b * z + x * y + wdot = -d * x + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperYangChen) HyperYangChen +function HyperYangChen() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + du[2] = c * x - x * z + w + du[3] = -b * z + x * y + du[4] = -d * x + end + u0 = Float64.(ATTRACTOR_DATA["HyperYangChen"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperYangChen"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function HyperYan end +originalcode(::typeof(HyperYan)) = """ +class HyperYan(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a=37, b=3, c=26, d=38): + xdot = a * y - a * x + ydot = (c - a) * x - x * z + c * y + zdot = -b * z + x * y - y * z + x * z - w + wdot = -d * w + y * z - x * z + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperYan) HyperYan +function HyperYan() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + du[2] = (c - a) * x - x * z + c * y + du[3] = -b * z + x * y - y * z + x * z - w + du[4] = -d * w + y * z - x * z + end + u0 = Float64.(ATTRACTOR_DATA["HyperYan"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperYan"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function HyperXu end +originalcode(::typeof(HyperXu)) = """ +class HyperXu(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a=10, b=40, c=2.5, d=2, e=16): + xdot = a * y - a * x + w + ydot = b * x + e * x * z + zdot = -c * z - x * y + wdot = x * z - d * y + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperXu) HyperXu +function HyperXu() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d, e = p + du[1] = a * y - a * x + w + du[2] = b * x + e * x * z + du[3] = -c * z - x * y + du[4] = x * z - d * y + end + u0 = Float64.(ATTRACTOR_DATA["HyperXu"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperXu"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function HyperWang end +originalcode(::typeof(HyperWang)) = """ +class HyperWang(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a=10, b=40, c=2.5, d=10.6, e=4): + xdot = a * y - a * x + ydot = -x * z + b * x + w + zdot = -c * z + e * x ** 2 + wdot = -d * x + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperWang) HyperWang +function HyperWang() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d, e = p + du[1] = a * y - a * x + du[2] = -x * z + b * x + w + du[3] = -c * z + e * x^2 + du[4] = -d * x + end + u0 = Float64.(ATTRACTOR_DATA["HyperWang"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperWang"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan) + return prob +end + +function HyperPang end +originalcode(::typeof(HyperPang)) = """ +class HyperPang(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a=36, b=3, c=20, d=2): + xdot = a * y - a * x + ydot = -x * z + c * y + w + zdot = x * y - b * z + wdot = -d * x - d * y + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperPang) HyperPang +function HyperPang() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + du[2] = -x * z + c * y + w + du[3] = x * y - b * z + du[4] = -d * x - d * y + end + u0 = Float64.(ATTRACTOR_DATA["HyperPang"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperPang"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function HyperLu end +originalcode(::typeof(HyperLu)) = """ +class HyperLu(DynSys): + @staticjit + def _rhs(x, y, z, w, t, a=36, b=3, c=20, d=1.3): + xdot = a * y - a * x + w + ydot = -x * z + c * y + zdot = x * y - b * z + wdot = d * w + x * z + return xdot, ydot, zdot, wdot +""" +@doc make_docstring(HyperLu) HyperLu +function HyperLu() + function rhs(du, u, p, t) + x, y, z, w = u + a, b, c, d = p + du[1] = a * y - a * x + w + du[2] = -x * z + c * y + du[3] = x * y - b * z + du[4] = d * w + x * z + end + u0 = Float64.(ATTRACTOR_DATA["HyperLu"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HyperLu"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function SaltonSea end +originalcode(::typeof(SaltonSea)) = """ +class SaltonSea(DynSys): + @staticjit + def _rhs(x, y, z, t, a, d, k, lam, m, mu, r, th): + xdot = r * x * (1 - (x + y) / k) - lam * x * y + ydot = lam * x * y - m * y * z / (y + a) - mu * y + zdot = th * y * z / (y + a) - d * z + return xdot, ydot, zdot +""" +@doc make_docstring(SaltonSea) SaltonSea +function SaltonSea() + function rhs(du, u, p, t) + x, y, z = u + a, d, k, lam, m, mu, r, th = p + du[1] = r * x * (1 - (x + y) / k) - lam * x * y + du[2] = lam * x * y - m * y * z / (y + a) - mu * y + du[3] = th * y * z / (y + a) - d * z + end + u0 = Float64.(ATTRACTOR_DATA["SaltonSea"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["SaltonSea"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan) + return prob +end + +function ExcitableCell end +originalcode(::typeof(ExcitableCell)) = """ +class ExcitableCell(DynSys): + def rhs(self, X, t): + v, n, c = X + + alpham = 0.1 * (25 + v) / (1 - np.exp(-0.1 * v - 2.5)) + betam = 4 * np.exp(-(v + 50) / 18) + minf = alpham / (alpham + betam) + + alphah = 0.07 * np.exp(-0.05 * v - 2.5) + betah = 1 / (1 + np.exp(-0.1 * v - 2)) + hinf = alphah / (alphah + betah) + + alphan = 0.01 * (20 + v) / (1 - np.exp(-0.1 * v - 2)) + betan = 0.125 * np.exp(-(v + 30) / 80) + ninf = alphan / (alphan + betan) + tau = 1 / (230 * (alphan + betan)) + + ca = c / (1 + c) + + vdot = ( + self.gi * minf ** 3 * hinf * (self.vi - v) + + self.gkv * n ** 4 * (self.vk - v) + + self.gkc * ca * (self.vk - v) + + self.gl * (self.vl - v) + ) + ndot = (ninf - n) / tau + cdot = self.rho * (minf ** 3 * hinf * (self.vc - v) - self.kc * c) + return vdot, ndot, cdot +""" +@doc make_docstring(ExcitableCell) ExcitableCell +function ExcitableCell() + function rhs(du, u, p, t) + v, n, c = u + gi, gkv, gkc, gl, rho, kc, vi, vk, vc, vl = p + alpham = 0.1 * (25 + v) / (1 - exp(-0.1 * v - 2.5)) + betam = 4 * exp(-(v + 50) / 18) + minf = alpham / (alpham + betam) + + alphah = 0.07 * exp(-0.05 * v - 2.5) + betah = 1 / (1 + exp(-0.1 * v - 2)) + hinf = alphah / (alphah + betah) + + alphan = 0.01 * (20 + v) / (1 - exp(-0.1 * v - 2)) + betan = 0.125 * exp(-(v + 30) / 80) + ninf = alphan / (alphan + betan) + tau = 1 / (230 * (alphan + betan)) + + ca = c / (1 + c) + + du[1] = gi * minf^3 * hinf * (vi - v) + gkv * n^4 * (vk - v) + gkc * ca * (vk - v) + gl * (vl - v) + du[2] = (ninf - n) / tau + du[3] = rho * (minf^3 * hinf * (vc - v) - kc * c) + end + u0 = Float64.(ATTRACTOR_DATA["ExcitableCell"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ExcitableCell"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function CaTwoPlus end +originalcode(::typeof(CaTwoPlus)) = """ +class CaTwoPlus(DynSys): + def rhs(self, X, t): + z, y, a = X + Vin = self.V0 + self.V1 * self.beta + V2 = self.Vm2 * (z ** 2) / (self.K2 ** 2 + z ** 2) + V3 = ( + (self.Vm3 * (z ** self.m) / (self.Kz ** self.m + z ** self.m)) + * (y ** 2 / (self.Ky ** 2 + y ** 2)) + * (a ** 4 / (self.Ka ** 4 + a ** 4)) + ) + V5 = ( + self.Vm5 + * (a ** self.p / (self.K5 ** self.p + a ** self.p)) + * (z ** self.n / (self.Kd ** self.n + z ** self.n)) + ) + zdot = Vin - V2 + V3 + self.kf * y - self.k * z + ydot = V2 - V3 - self.kf * y + adot = self.beta * self.V4 - V5 - self.eps * a + return (zdot, ydot, adot) +""" +@doc make_docstring(CaTwoPlus) CaTwoPlus +function CaTwoPlus() + function rhs(du, u, p, t) + z, y, a = u + V0, V1, Vm2, Vm3, Vm5, V4, K2, Kz, Ky, Ka, K5, Kd, kf, k, beta, m, n, p, eps = p + Vin = V0 + V1 * beta + V2 = Vm2 * (z^2) / (K2^2 + z^2) + V3 = (Vm3 * (z^m) / (Kz^m + z^m)) * (y^2 / (Ky^2 + y^2)) * (a^4 / (Ka^4 + a^4)) + V5 = Vm5 * (a^p / (K5^p + a^p)) * (z^n / (Kd^n + z^n)) + du[1] = Vin - V2 + V3 + kf * y - k * z + du[2] = V2 - V3 - kf * y + du[3] = beta * V4 - V5 - eps * a + end + u0 = Float64.(ATTRACTOR_DATA["CaTwoPlus"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["CaTwoPlus"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function CellCycle end +originalcode(::typeof(CellCycle)) = """ +class CellCycle(DynSys): + def rhs(self, X, t): + c1, m1, x1, c2, m2, x2 = X + Vm1, Um1 = 2 * [self.Vm1] + vi1, vi2 = 2 * [self.vi] + H1, H2, H3, H4 = 4 * [self.K] + K1, K2, K3, K4 = 4 * [self.K] + V2, U2 = 2 * [self.V2] + Vm3, Um3 = 2 * [self.Vm3] + V4, U4 = 2 * [self.V4] + Kc1, Kc2 = 2 * [self.Kc] + vd1, vd2 = 2 * [self.vd] + Kd1, Kd2 = 2 * [self.Kd1] + kd1, kd2 = 2 * [self.kd1] + Kim1, Kim2 = 2 * [self.Kim] + V1 = Vm1 * c1 / (Kc1 + c1) + U1 = Um1 * c2 / (Kc2 + c2) + V3 = m1 * Vm3 + U3 = m2 * Um3 + c1dot = vi1 * Kim1 / (Kim1 + m2) - vd1 * x1 * c1 / (Kd1 + c1) - kd1 * c1 + c2dot = vi2 * Kim2 / (Kim2 + m1) - vd2 * x2 * c2 / (Kd2 + c2) - kd2 * c2 + m1dot = V1 * (1 - m1) / (K1 + (1 - m1)) - V2 * m1 / (K2 + m1) + m2dot = U1 * (1 - m2) / (H1 + (1 - m2)) - U2 * m2 / (H2 + m2) + x1dot = V3 * (1 - x1) / (K3 + (1 - x1)) - V4 * x1 / (K4 + x1) + x2dot = U3 * (1 - x2) / (H3 + (1 - x2)) - U4 * x2 / (H4 + x2) + return c1dot, m1dot, x1dot, c2dot, m2dot, x2dot +""" +@doc make_docstring(CellCycle) CellCycle +function CellCycle() + function rhs(du, u, p, t) + c1, m1, x1, c2, m2, x2 = u + Vm1, Um1, vi1, vi2, H1, H2, H3, H4, K1, K2, K3, K4, V2, U2, Vm3, Um3, V4, U4, Kc1, Kc2, vd1, vd2, Kd1, Kd2, kd1, kd2, Kim1, Kim2 = p + V1 = Vm1 * c1 / (Kc1 + c1) + U1 = Um1 * c2 / (Kc2 + c2) + V3 = m1 * Vm3 + U3 = m2 * Um3 + du[1] = vi1 * Kim1 / (Kim1 + m2) - vd1 * x1 * c1 / (Kd1 + c1) - kd1 * c1 + du[2] = vi2 * Kim2 / (Kim2 + m1) - vd2 * x2 * c2 / (Kd2 + c2) - kd2 * c2 + du[3] = V1 * (1 - m1) / (K1 + (1 - m1)) - V2 * m1 / (K2 + m1) + du[4] = U1 * (1 - m2) / (H1 + (1 - m2)) - U2 * m2 / (H2 + m2) + du[5] = V3 * (1 - x1) / (K3 + (1 - x1)) - V4 * x1 / (K4 + x1) + du[6] = U3 * (1 - x2) / (H3 + (1 - x2)) - U4 * x2 / (H4 + x2) + end + u0 = Float64.(ATTRACTOR_DATA["CellCycle"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["CellCycle"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function CircadianRhythm end +originalcode(::typeof(CircadianRhythm)) = """ +class CircadianRhythm(DynSys): + @staticjit + def _rhs( + m, + fc, + fs, + fn, + th, + t, + Ki, + k, + k1, + k2, + kd, + kdn, + km, + ks, + n, + vd, + vdn, + vm, + vmax, + vmin, + v, + ): + vs = 2.5 * ((0.5 + 0.5 * np.cos(th)) + vmin) * (vmax - vmin) + mdot = vs * (Ki ** n) / (Ki ** n + fn ** n) - vm * m / (km + m) + fcdot = ks * m - k1 * fc + k2 * fn - k * fc + fsdot = k * fc - vd * fs / (kd + fs) + fndot = k1 * fc - k2 * fn - vdn * fn / (kdn + fn) + thdot = 2 * np.pi / 24 + return mdot, fcdot, fsdot, fndot, thdot + + @staticjit + def _postprocessing(m, fc, fs, fn, th): + return m, fc, fs, fn, np.cos(th) +""" +@doc make_docstring(CircadianRhythm) CircadianRhythm +function CircadianRhythm() + function rhs(du, u, p, t) + m, fc, fs, fn, th = u + Ki, k, k1, k2, kd, kdn, km, ks, n, vd, vdn, vm, vmax, vmin = p + vs = 2.5 * ((0.5 + 0.5 * cos(th)) + vmin) * (vmax - vmin) + du[1] = vs * (Ki^n) / (Ki^n + fn^n) - vm * m / (km + m) + du[2] = ks * m - k1 * fc + k2 * fn - k * fc + du[3] = k * fc - vd * fs / (kd + fs) + du[4] = k1 * fc - k2 * fn - vdn * fn / (kdn + fn) + du[5] = 2 * pi / 24 + end + u0 = Float64.(ATTRACTOR_DATA["CircadianRhythm"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["CircadianRhythm"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function FluidTrampoline end +originalcode(::typeof(FluidTrampoline)) = """ +class FluidTrampoline(DynSys): + @staticmethod + def _rhs(x, y, th, t, gamma, psi, w): + xdot = y + ydot = -1 - np.heaviside(-x, 0) * (x + psi * y * np.abs(y)) + gamma * np.cos(th) + thdot = w + return (xdot, ydot, thdot) + + @staticjit + def _postprocessing(x, y, th): + return x, y, np.cos(th) +""" +@doc make_docstring(FluidTrampoline) FluidTrampoline +function FluidTrampoline() + function rhs(du, u, p, t) + x, y, th = u + gamma, psi, w = p + du[1] = y + du[2] = -1 - (x < 0) * (x + psi * y * abs(y)) + gamma * cos(th) + du[3] = w + end + u0 = Float64.(ATTRACTOR_DATA["FluidTrampoline"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["FluidTrampoline"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function Aizawa end +originalcode(::typeof(Aizawa)) = """ +class Aizawa(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d, e, f): + xdot = x * z - b * x - d * y + ydot = d * x + y * z - b * y + zdot = c + a * z - 0.333333333333333333 * z ** 3 - x ** 2 - y ** 2 - e * z * x ** 2 - e * z * y ** 2 + f * z * x ** 3 + return xdot, ydot, zdot +""" +@doc make_docstring(Aizawa) Aizawa +function Aizawa() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d, e, f = p + du[1] = x * z - b * x - d * y + du[2] = d * x + y * z - b * y + du[3] = c + a * z - 1/3 * z^3 - x^2 - y^2 - e * z * x^2 - e * z * y^2 + f * z * x^3 + end + u0 = Float64.(ATTRACTOR_DATA["Aizawa"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Aizawa"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function AnishchenkoAstakhov end +originalcode(::typeof(AnishchenkoAstakhov)) = """ +class AnishchenkoAstakhov(DynSys): + def rhs(self, X, t): + x, y, z = X + mu, eta = self.mu, self.eta + xdot = mu * x + y - x * z + ydot = -x + zdot = -eta * z + eta * np.heaviside(x, 0) * x ** 2 + return (xdot, ydot, zdot) +""" +@doc make_docstring(AnishchenkoAstakhov) AnishchenkoAstakhov +function AnishchenkoAstakhov() + function rhs(du, u, p, t) + x, y, z = u + mu, eta = p + du[1] = mu * x + y - x * z + du[2] = -x + du[3] = -eta * z + eta * (x > 0) * x^2 + end + u0 = Float64.(ATTRACTOR_DATA["AnishchenkoAstakhov"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["AnishchenkoAstakhov"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function ShimizuMorioka end +originalcode(::typeof(ShimizuMorioka)) = """ +class ShimizuMorioka(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b): + xdot = y + ydot = x - a * y - x * z + zdot = -b * z + x ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(ShimizuMorioka) ShimizuMorioka +function ShimizuMorioka() + function rhs(du, u, p, t) + x, y, z = u + a, b = p + du[1] = y + du[2] = x - a * y - x * z + du[3] = -b * z + x^2 + end + u0 = Float64.(ATTRACTOR_DATA["ShimizuMorioka"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ShimizuMorioka"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function GenesioTesi end +originalcode(::typeof(GenesioTesi)) = """ +class GenesioTesi(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c): + xdot = y + ydot = z + zdot = -c * x - b * y - a * z + x ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(GenesioTesi) GenesioTesi +function GenesioTesi() + function rhs(du, u, p, t) + x, y, z = u + a, b, c = p + du[1] = y + du[2] = z + du[3] = -c * x - b * y - a * z + x^2 + end + u0 = Float64.(ATTRACTOR_DATA["GenesioTesi"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["GenesioTesi"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function AtmosphericRegime end +originalcode(::typeof(AtmosphericRegime)) = """ +class AtmosphericRegime(DynSys): + @staticjit + def _rhs( + x, y, z, t, alpha, beta, mu1, mu2, omega, sigma + ): + xdot = mu1 * x + sigma * x * y + ydot = mu2 * y + omega * z + alpha * y * z + beta * z ** 2 - sigma * x ** 2 + zdot = mu2 * z - omega * y - alpha * y ** 2 - beta * y * z + return xdot, ydot, zdot +""" +@doc make_docstring(AtmosphericRegime) AtmosphericRegime +function AtmosphericRegime() + function rhs(du, u, p, t) + x, y, z = u + alpha, beta, mu1, mu2, omega, sigma = p + du[1] = mu1 * x + sigma * x * y + du[2] = mu2 * y + omega * z + alpha * y * z + beta * z^2 - sigma * x^2 + du[3] = mu2 * z - omega * y - alpha * y^2 - beta * y * z + end + u0 = Float64.(ATTRACTOR_DATA["AtmosphericRegime"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["AtmosphericRegime"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Hadley end +originalcode(::typeof(Hadley)) = """ +class Hadley(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, f, g): + xdot = -y ** 2 - z ** 2 - a * x + a * f + ydot = x * y - b * x * z - y + g + zdot = b * x * y + x * z - z + return xdot, ydot, zdot +""" +@doc make_docstring(Hadley) Hadley +function Hadley() + function rhs(du, u, p, t) + x, y, z = u + a, b, f, g = p + du[1] = -y^2 - z^2 - a * x + a * f + du[2] = x * y - b * x * z - y + g + du[3] = b * x * y + x * z - z + end + u0 = Float64.(ATTRACTOR_DATA["Hadley"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Hadley"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function ForcedVanDerPol end +originalcode(::typeof(ForcedVanDerPol)) = """ +class ForcedVanDerPol(DynSys): + @staticjit + def _rhs(x, y, z, t, a, mu, w): + ydot = mu * (1 - x ** 2) * y - x + a * np.sin(z) + xdot = y + zdot = w + return xdot, ydot, zdot + + @staticjit + def _postprocessing(x, y, z): + return x, y, np.sin(z) +""" +@doc make_docstring(ForcedVanDerPol) ForcedVanDerPol +function ForcedVanDerPol() + function rhs(du, u, p, t) + x, y, z = u + a, mu, w = p + du[1] = mu * (1 - x^2) * y - x + a * sin(z) + du[2] = y + du[3] = w + end + u0 = Float64.(ATTRACTOR_DATA["ForcedVanDerPol"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ForcedVanDerPol"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function ForcedFitzHughNagumo end +originalcode(::typeof(ForcedFitzHughNagumo)) = """ +class ForcedFitzHughNagumo(DynSys): + @staticjit + def _rhs(v, w, z, t, a, b, curr, f, gamma, omega): + vdot = v - v ** 3 / 3 - w + curr + f * np.sin(z) + wdot = gamma * (v + a - b * w) + zdot = omega + return vdot, wdot, zdot + + @staticjit + def _postprocessing(x, y, z): + return x, y, np.sin(z) +""" +@doc make_docstring(ForcedFitzHughNagumo) ForcedFitzHughNagumo +function ForcedFitzHughNagumo() + function rhs(du, u, p, t) + v, w, z = u + a, b, curr, f, gamma, omega = p + du[1] = v - v^3 / 3 - w + curr + f * sin(z) + du[2] = gamma * (v + a - b * w) + du[3] = omega + end + u0 = Float64.(ATTRACTOR_DATA["ForcedFitzHughNagumo"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ForcedFitzHughNagumo"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function HindmarshRose end +originalcode(::typeof(HindmarshRose)) = """ +class HindmarshRose(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d, s, tx, tz): + xdot = -x + 1 / tx * y - a / tx * x ** 3 + b / tx * x ** 2 + 1 / tx * z + ydot = -a * x ** 3 - (d - b) * x ** 2 + z + zdot = -s / tz * x - 1 / tz * z + c / tz + return xdot, ydot, zdot +""" +@doc make_docstring(HindmarshRose) HindmarshRose +function HindmarshRose() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d, s, tx, tz = p + du[1] = -x + 1 / tx * y - a / tx * x^3 + b / tx * x^2 + 1 / tx * z + du[2] = -a * x^3 - (d - b) * x^2 + z + du[3] = -s / tz * x - 1 / tz * z + c / tz + end + u0 = Float64.(ATTRACTOR_DATA["HindmarshRose"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HindmarshRose"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Colpitts end +originalcode(::typeof(Colpitts)) = """ +class Colpitts(DynSys): + def rhs(self, X, t): + x, y, z = X + u = z - (self.e - 1) + fz = -u * (1 - np.heaviside(u, 0)) + xdot = y - self.a * fz + ydot = self.c - x - self.b * y - z + zdot = y - self.d * z + return (xdot, ydot, zdot) +""" +@doc make_docstring(Colpitts) Colpitts +function Colpitts() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d, e = p + u = z - (e - 1) + fz = -u * (1 - (u > 0)) + du[1] = y - a * fz + du[2] = c - x - b * y - z + du[3] = y - d * z + end + u0 = Float64.(ATTRACTOR_DATA["Colpitts"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Colpitts"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Laser end +originalcode(::typeof(Laser)) = """ +class Laser(DynSys): + @staticjit + def _rhs(x, y, z, t, a, b, c, d, h, k): + xdot = a * y - a * x + b * y * z ** 2 + ydot = c * x + d * x * z ** 2 + zdot = h * z + k * x ** 2 + return xdot, ydot, zdot +""" +@doc make_docstring(Laser) Laser +function Laser() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d, h, k = p + du[1] = a * y - a * x + b * y * z^2 + du[2] = c * x + d * x * z^2 + du[3] = h * z + k * x^2 + end + u0 = Float64.(ATTRACTOR_DATA["Laser"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Laser"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function Blasius end +originalcode(::typeof(Blasius)) = """ +class Blasius(DynSys): + @staticjit + def _rhs(x, y, z, t, a, alpha1, alpha2, b, c, k1, k2, zs): + xdot = a * x - alpha1 * x * y / (1 + k1 * x) + ydot = -b * y + alpha1 * x * y / (1 + k1 * x) - alpha2 * y * z / (1 + k2 * y) + zdot = -c * (z - zs) + alpha2 * y * z / (1 + k2 * y) + return xdot, ydot, zdot +""" +@doc make_docstring(Blasius) Blasius +function Blasius() + function rhs(du, u, p, t) + x, y, z = u + a, alpha1, alpha2, b, c, k1, k2, zs = p + du[1] = a * x - alpha1 * x * y / (1 + k1 * x) + du[2] = -b * y + alpha1 * x * y / (1 + k1 * x) - alpha2 * y * z / (1 + k2 * y) + du[3] = -c * (z - zs) + alpha2 * y * z / (1 + k2 * y) + end + u0 = Float64.(ATTRACTOR_DATA["Blasius"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Blasius"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function TurchinHanski end +originalcode(::typeof(TurchinHanski)) = """ +class TurchinHanski(DynSys): + @staticjit + def _rhs(n, p, z, t, a, d, e, g, h, r, s): + ndot = ( + r * (1 - e * np.sin(z)) * n + - r * (n ** 2) + - g * (n ** 2) / (n ** 2 + h ** 2) + - a * n * p / (n + d) + ) + pdot = s * (1 - e * np.sin(z)) * p - s * (p ** 2) / n + zdot = 2 * np.pi + return ndot, pdot, zdot + + @staticjit + def _postprocessing(x, y, z): + return x, y, np.sin(z) +""" +@doc make_docstring(TurchinHanski) TurchinHanski +function TurchinHanski() + function rhs(du, u, p, t) + n, p, z = u + a, d, e, g, h, r, s = p + du[1] = r * (1 - e * sin(z)) * n - r * n^2 - g * n^2 / (n^2 + h^2) - a * n * p / (n + d) + du[2] = s * (1 - e * sin(z)) * p - s * p^2 / n + du[3] = 2 * pi + end + u0 = Float64.(ATTRACTOR_DATA["TurchinHanski"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["TurchinHanski"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p) + return prob +end + +function StickSlipOscillator end +originalcode(::typeof(StickSlipOscillator)) = """ +class StickSlipOscillator(DynSys): + def _t(self, v): + return self.t0 * np.sign(v) - self.alpha * v + self.beta * v ** 3 + + @staticjit + def _rhs(x, v, th, t, a, alpha, b, beta, eps, gamma, t0, vs, w): + tq = t0 * np.sign(v - vs) - alpha * v + beta * (v - vs) ** 3 + xdot = v + vdot = eps * (gamma * np.cos(th) - tq) + a * x - b * x ** 3 + thdot = w + return xdot, vdot, thdot + + @staticjit + def _postprocessing(x, v, th): + return x, v, np.cos(th) +""" +@doc make_docstring(StickSlipOscillator) StickSlipOscillator +function StickSlipOscillator() + function rhs(du, u, p, t) + x, v, th = u + a, alpha, b, beta, eps, gamma, t0, vs, w = p + tq = t0 * sign(v - vs) - alpha * v + beta * (v - vs)^3 + du[1] = v + du[2] = eps * (gamma * cos(th) - tq) + a * x - b * x^3 + du[3] = w + end + u0 = Float64.(ATTRACTOR_DATA["StickSlipOscillator"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["StickSlipOscillator"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p,) + return prob +end + +function HastingsPowell end +originalcode(::typeof(HastingsPowell)) = """ +class HastingsPowell(DynSys): + @staticjit + def _rhs(x, y, z, t, a1, a2, b1, b2, d1, d2): + xdot = x * (1 - x) - y * a1 * x / (1 + b1 * x) + ydot = y * a1 * x / (1 + b1 * x) - z * a2 * y / (1 + b2 * y) - d1 * y + zdot = z * a2 * y / (1 + b2 * y) - d2 * z + return xdot, ydot, zdot +""" +@doc make_docstring(HastingsPowell) HastingsPowell +function HastingsPowell() + function rhs(du, u, p, t) + x, y, z = u + a1, a2, b1, b2, d1, d2 = p + du[1] = x * (1 - x) - y * a1 * x / (1 + b1 * x) + du[2] = y * a1 * x / (1 + b1 * x) - z * a2 * y / (1 + b2 * y) - d1 * y + du[3] = z * a2 * y / (1 + b2 * y) - d2 * z + end + u0 = Float64.(ATTRACTOR_DATA["HastingsPowell"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["HastingsPowell"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p,) + return prob +end + +function CellularNeuralNetwork end +originalcode(::typeof(CellularNeuralNetwork)) = """ +class CellularNeuralNetwork(DynSys): + @staticjit + def f(x): + return 0.5 * (np.abs(x + 1) - np.abs(x - 1)) + + def rhs(self, X, t): + x, y, z = X + xdot = -x + self.d * self.f(x) - self.b * self.f(y) - self.b * self.f(z) + ydot = -y - self.b * self.f(x) + self.c * self.f(y) - self.a * self.f(z) + zdot = -z - self.b * self.f(x) + self.a * self.f(y) + self.f(z) + return (xdot, ydot, zdot) +""" +@doc make_docstring(CellularNeuralNetwork) CellularNeuralNetwork +function CellularNeuralNetwork() + function rhs(du, u, p, t) + x, y, z = u + a, b, c, d = p + du[1] = -x + d * f(x) - b * f(y) - b * f(z) + du[2] = -y - b * f(x) + c * f(y) - a * f(z) + du[3] = -z - b * f(x) + a * f(y) + f(z) + end + u0 = Float64.(ATTRACTOR_DATA["CellularNeuralNetwork"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["CellularNeuralNetwork"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f, u0, tspan, p,) + return prob +end + +function BeerRNN end +originalcode(::typeof(BeerRNN)) = """ +class BeerRNN(DynSys): + @staticjit + def _sig(x): + return 1.0 / (1.0 + np.exp(-x)) + + def rhs(self, X, t): + Xdot = (-X + np.matmul(self.w, self._sig(X + self.theta))) / self.tau + return Xdot +""" +@doc make_docstring(BeerRNN) BeerRNN +function BeerRNN() + function rhs(du, u, p, t) + w, theta, tau = p + du .= (-u + w * sig.(u + theta)) / tau + end + u0 = Float64.(ATTRACTOR_DATA["BeerRNN"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["BeerRNN"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function Torus end +originalcode(::typeof(Torus)) = """ +class Torus(DynSys): + @staticjit + def _rhs(x, y, z, t, a, n, r): + xdot = (-a * n * np.sin(n * t)) * np.cos(t) - (r + a * np.cos(n * t)) * np.sin( + t + ) + ydot = (-a * n * np.sin(n * t)) * np.sin(t) + (r + a * np.cos(n * t)) * np.cos( + t + ) + zdot = a * n * np.cos(n * t) + return xdot, ydot, zdot +""" +@doc make_docstring(Torus) Torus +function Torus() + function rhs(du, u, p, t) + a, n, r = p + du[1] = (-a * n * sin(n * t)) * cos(t) - (r + a * cos(n * t)) * sin(t) + du[2] = (-a * n * sin(n * t)) * sin(t) + (r + a * cos(n * t)) * cos(t) + du[3] = a * n * cos(n * t) + end + u0 = Float64.(ATTRACTOR_DATA["Torus"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Torus"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + + +# class CaTwoPlusQuasiperiodic(CaTwoPlus): +# pass + +function Hopfield end +originalcode(::typeof(Hopfield)) = """ +class Hopfield(DynSys): + def f(self, x): + return (1 + np.tanh(x)) / 2 + + def rhs(self, X, t): + Xdot = -X / self.tau + self.f(self.eps * np.matmul(self.k, X)) - self.beta + return Xdot +""" +@doc make_docstring(Hopfield) Hopfield +function Hopfield() + function rhs(du, u, p, t) + k, tau, eps, beta = p + du .= -u / tau + f.(eps * k * u) - beta + end + u0 = Float64.(ATTRACTOR_DATA["Hopfield"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["Hopfield"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function MacArthur end +originalcode(::typeof(MacArthur)) = """ +class MacArthur(DynSys): + def growth_rate(self, rr): + u0 = rr / (self.k.T + rr) + u = self.r * u0.T + return np.min(u.T, axis=1) + + def rhs(self, X, t): + nn, rr = X[:5], X[5:] + mu = self.growth_rate(rr) + nndot = nn * (mu - self.m) + rrdot = self.d * (self.s - rr) - np.matmul(self.c, (mu * nn)) + return np.hstack([nndot, rrdot]) +""" +@doc make_docstring(MacArthur) MacArthur +function MacArthur() + function rhs(du, u, p, t) + m, r, k, d, s, c = p + nn, rr = u[1:5], u[6:10] + u0 = rr ./ (k .+ rr) + mu = r .* u0 + du[1:5] .= nn .* (mu .- m) + du[6:10] .= d .* (s .- rr) .- c * (mu .* nn) + end + u0 = Float64.(ATTRACTOR_DATA["MacArthur"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["MacArthur"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + +function ItikBanksTumor end +originalcode(::typeof(ItikBanksTumor)) = """ +class ItikBanksTumor(DynSys): + @staticjit + def _rhs(x, y, z, t, a12, a13, a21, a31, d3, k3, r2, r3): + xdot = x * (1 - x) - a12 * x * y - a13 * x * z + ydot = r2 * y * (1 - y) - a21 * x * y + zdot = r3 * x * z / (x + k3) - a31 * x * z - d3 * z + return xdot, ydot, zdot +""" +@doc make_docstring(ItikBanksTumor) ItikBanksTumor +function ItikBanksTumor() + function rhs(du, u, p, t) + a12, a13, a21, a31, d3, k3, r2, r3 = p + x, y, z = u + du[1] = x * (1 - x) - a12 * x * y - a13 * x * z + du[2] = r2 * y * (1 - y) - a21 * x * y + du[3] = r3 * x * z / (x + k3) - a31 * x * z - d3 * z + end + u0 = Float64.(ATTRACTOR_DATA["ItikBanksTumor"]["initial_conditions"]) + p = dict_to_componentarray(ATTRACTOR_DATA["ItikBanksTumor"]["parameters"]) + tspan = (0.0, 1.0) + f = ODEFunction(rhs) + prob = ODEProblem(f,u0,tspan,p) + return prob +end + + +# ## Doesn't match described dynamics +# # class CosmologyFriedmann(DynSys): +# # @staticjit +# # def _rhs(x, y, z, t, a, b, c, d, p): +# # xdot = y +# # ydot = -a * y**2 / x - b * x - c * x**3 + d * p * x +# # zdot = 3 * (y / x) * (p + z) +# # return xdot, ydot, zdot + + +# ## Doesn't match described dynamics +# # class MixMasterUniverse(DynSys): +# # def rhs(self, X, t): +# # a, b, g, adot_, bdot_, gdot_ = X +# # adot = adot_ +# # bdot = bdot_ +# # gdot = gdot_ +# # addot = (np.exp(2*b) - np.exp(2*g))**2 - np.exp(4*a) +# # bddot = (np.exp(2*g) - np.exp(2*a))**2 - np.exp(4*b) +# # gddot = (np.exp(2*a) - np.exp(2*b))**2 - np.exp(4*g) +# # return (adot, bdot, gdot, addot, bddot, gddot) + +# ## Doesn't match described dynamics +# # class Universe(DynSys): +# # def rhs(self, X, t): +# # #Xdot = X * np.matmul(self.a, 1 - X) +# # Xdot = self.r * X * (1 - np.matmul(self.a, X)) +# # return Xdot + +# # class SeasonalSEIR: +# # """ +# # This is extremely unstable for some reason +# # Olsen, Schaffer. Science 1990 + +# # eq = SeasonalSEIR() +# # tpts = np.linspace(0, 1000, 100000) +# # ic = (.579, .02, .001, 1e-6) +# # sol = integrate_dyn(eq, ic, tpts) + +# # plt.plot(sol[0], sol[2], '.k', markersize=.1) + +# # """ +# # def __init__(self): +# # pass + +# # def __call__(self, X, t): +# # (s, e, i, th) = X + +# # ## measles +# # m = 0.02 +# # a = 35.84 +# # g = 100 +# # b0 = 1800 +# # b1 = 0.28 + +# # # ## chickenpox +# # # m = 0.02 +# # # a = 36 +# # # g = 34.3 +# # # b0 = 537 +# # # b1 = 0.3 + +# # b = b0*(1 + b1*np.cos(th)) +# # sdot = m*(1 - s) - b*s*i +# # edot = b*s*i - (m + a)*e +# # idot = a*e - (m + g)*i +# # thdot = 2*np.pi +# # return (sdot, edot, idot, thdot) + +# # class SeasonalSEIR: +# # """ +# # Seasonally forced SEIR model +# # Zhang, Q., Liu, C., & Zhang, X. (2012). Analysis and Control of an SEIR Epidemic System with Nonlinear Transmission Rate. Lecture Notes in Control and Information Sciences, 203–225. doi:10.1007/978-1-4471-2303-3_14 +# # """ +# # def __init__(self, b=0.02, beta0=1800, alpha=35.84, gamma=100.0, beta1=0.28): +# # self.b, self.beta0, self.alpha, self.gamma, self.beta1 = b, beta0, alpha, gamma, beta1 +# # def __call__(self, X, t): +# # """ +# # The dynamical equation for the system +# # - X : tuple corresponding to the three coordinates +# # - t : float (the current time) +# # alpha is a +# # b is mu +# # """ +# # s, e, i, th = X +# # beta = self.beta0*(1 + self.beta1*np.cos(th)) # seasonal forcing +# # sdot = self.b - self.b*s - beta*s*i +# # edot = beta*s*i - (self.alpha + self.b)*e +# # idot = self.alpha*e - (self.gamma + self.b)*i +# # thdot = 2*np.pi +# # return (sdot, edot, idot, thdot) + +# # class SeasonalSEIR: +# # """ +# # Seasonally forced SEIR model +# # Zhang, Q., Liu, C., & Zhang, X. (2012). Analysis and Control of an SEIR Epidemic System with Nonlinear Transmission Rate. Lecture Notes in Control and Information Sciences, 203–225. doi:10.1007/978-1-4471-2303-3_14 +# # """ +# # def __init__(self, b=0.02, beta0=1800, alpha=35.84, gamma=100.0, beta1=0.28): +# # self.b, self.beta0, self.alpha, self.gamma, self.beta1 = b, beta0, alpha, gamma, beta1 +# # def __call__(self, X, t): +# # """ +# # The dynamical equation for the system +# # - X : tuple corresponding to the three coordinates +# # - t : float (the current time) +# # alpha is a +# # b is mu +# # """ +# # s, e, i, th = X +# # beta = self.beta0*(1 + self.beta1*np.cos(th)) # seasonal forcing +# # sdot = self.b - self.b*s - beta*s*i +# # edot = beta*s*i - (self.alpha + self.b)*e +# # idot = self.alpha*e - (self.gamma + self.b)*i +# # thdot = 2*np.pi +# # return (sdot, edot, idot, thdot) + +# # class SeasonalSEIR: +# # """ +# # Seasonally forced SEIR model +# # """ +# # def __init__(self, mu=0.02, b0=1800, a=35.84, g=100.0, d=0.28): +# # self.mu, self.b0, self.a, self.g, self.d = mu, b0, a, g, d +# # def __call__(self, X, t): +# # """ +# # The dynamical equation for the system +# # - X : tuple corresponding to the three coordinates +# # - t : float (the current time) +# # alpha is a +# # b is mu +# # """ +# # s, e, i, th = X +# # b = self.b0*(1 + self.d*np.cos(th)) # seasonal forcing +# # sdot = self.mu - self.mu*s - b*s*i +# # edot = b*s*i - (self.mu + self.a)*e +# # idot = self.a*e - (self.mu + self.g)*i +# # # edot = 0 +# # # idot = 0 +# # thdot = 2*np.pi + +# # return (sdot, edot, idot, thdot) + +# # class SeasonalSEIR: +# # """ +# # Seasonally forced SEIR model +# # Bifurcation analysis of periodic SEIR and SIR epidemic models +# # """ +# # def __init__(self, mu=0.02, b0=1884.95*5, a=35.842, g=100.0, d=0.255): +# # self.mu, self.b0, self.a, self.g, self.d = mu, b0, a, g, d +# # def __call__(self, X, t): +# # """ +# # The dynamical equation for the system +# # - X : tuple corresponding to the three coordinates +# # - t : float (the current time) +# # """ +# # s, e, i, th = X +# # b = self.b0*(1 + self.d*np.cos(th)) # seasonal forcing +# # sdot = self.mu - self.mu*s - b*s*i +# # edot = b*s*i - (self.mu + self.a)*e +# # idot = self.a*e - (self.mu + self.g)*i +# # thdot = 2*np.pi +# # return (sdot, edot, idot, thdot) + + +# # class SeasonalSIR: +# # """ +# # Seasonally forced SEIR model +# # """ +# # def __init__(self, mu=0.02, b0=1884.95, a=35.842, g=100, d=0.255): +# # self.mu, self.b0, self.a, self.g, self.d = mu, b0, a, g, d +# # def __call__(self, X, t): +# # """ +# # The dynamical equation for the system +# # - X : tuple corresponding to the three coordinates +# # - t : float (the current time) +# # """ +# # s, i, th = X +# # b = self.b0*(1 + self.d*np.sin(th)) # seasonal forcing +# # sdot = self.mu - self.mu*s - b*s*i +# # idot = b*s*i - (self.mu + self.g)*i +# # thdot = 2*np.pi +# # return (sdot, idot, thdot) + + +# # class Robinson: +# # """ +# # C Robinson 1989 Nonlinearity +# # Was unable to find published parameters for which this has a stable attractor, +# # it may only be transient +# # """ +# # def __init__(self, a=0.71, b=1.8587, v=1.0, gamma=0.7061, delta=0.1): +# # self.a, self.b, self.v, self.gamma, self.delta = a, b, v, gamma, delta +# # def __call__(self, X, t): +# # """ +# # The dynamical equation for the system +# # - X : tuple corresponding to the three coordinates +# # - t : float (the current time) +# # """ +# # x, y, z = X +# # xdot = y +# # ydot = x - 2*x**3 - self.a*y + (self.b*x**2)*y - self.v*y*z +# # zdot = -self.gamma*z + self.delta*x**2 +# # return (xdot, ydot, zdot) + +# # Sato: Cardiac model analogous to HH +# # https://www.sciencedirect.com/science/article/pii/S1007570416300016 +# # hundreds of equations + + +# # class HodgkinHuxley: +# # def __init__(self, i=7.92197): +# # self.i = i + +# # def phi(self, x): +# # return x/(np.exp(x) - 1) + +# # def __call__(self, X, t): +# # """ +# # The dynamical equation for the system +# # - X : tuple corresponding to the three coordinates +# # - t : float (the current time) +# # """ +# # v, m, n, h = X +# # i = self.i +# # vdot = i - (120*m**3*h*(v + 115) + 36*n**4*(v - 12) + 0.3*(v + 10.599)) +# # mdot = (1 - m)*self.phi((v + 25)/10) - m*(4*np.exp(v/18)) +# # ndot = (1 - n)*0.1*self.phi((v + 10)/10) - n*0.125*np.exp(v/80) +# # hdot = (1 - h)*0.07*np.exp(v/20) - h/(1 + np.exp((v + 30)/10)) +# # return (vdot, mdot, ndot, hdot) + +# ############################## +# ## +# ## Quasiperiodic systems +# ## +# ############################## + +# # class SymmetricKuramoto(DynSys): +# # def coupling(self, x, n=4): +# # k = 1 + np.arange(n) +# # return np.sum(self.a[:, None, None] * np.cos(k[:, None, None]*x[None, ...] - self.eta[:, None, None]), axis=0) +# # def rhs(self, X, t): +# # phase_diff = X[:, None] - X[None, :] +# # Xdot = self.w + np.mean(self.coupling(phase_diff), axis=0) ## need to apply coupling element-wise +# # return Xdot + +# # "SymmetricKuramoto": { +# # "initial_conditions": [ +# # 0.1, +# # 0.01, +# # 0.01, +# # 0.01 +# # ], +# # "dt": 0.01, +# # "parameters": { +# # "w" : 0.0, +# # "a": [-2, -2, -1, -0.88], +# # "eta": [0.1104, -0.1104, 0.669, 0.669] +# # }, +# # "citation": "Bick, Christian, et al. Chaos in symmetric phase oscillator networks. Physical review letters 107.24 (2011): 244101.", +# # "period": 7737.7 +# # } + +# # class InterfacialFlight: +# # """ +# # """ +# # def __init__(self): +# # pass +# # def __call__(self, X, t): +# # x, y, z = X +# # rclaw = 57 #um +# # m = 2.2 +# # cl = 1.55 +# # ly = 73 + +# # l0 = 137*1e6 # convert from uN/mg into um/s^2 +# # f = 116 +# # r = 0.15 +# # phi0 = np.pi/2 + +# # cdleg = 3 +# # rhow = 1e-9 # water density in mg/um^3 + +# # sigma = 72800 # water surface tension mg/s^2 + +# # kinv = 2709 # um +# # hclaw = rclaw*np.log(2*kinv/rclaw) + +# # sech = lambda pp : 1 / np.cosh(pp) + +# # phi_arg = 2*np.pi*f*t + phi0 +# # sin_term = np.sin(phi_arg) +# # hsin_term = np.heaviside(sin_term, 0) +# # zdot = (l0/m)*np.cos(phi_arg)*(hsin_term + r*(1 - hsin_term)) +# # zdot += -(8*np.pi*sigma*rclaw/m)*sech((x - hclaw)/rclaw)*np.sign(x) +# # zdot += -(2*rhow*cdleg*np.pi*rclaw**2/m)*y*np.sign(y) + +# # xdot = 1 +# # ydot = x +# # return (xdot, ydot, zdot) + +# ## Not chaotic +# # class Robinson(DynSys): +# # @staticjit +# # def _rhs(x, y, z, t, a, b, c, d, v): +# # xdot = y +# # ydot = x - 2 * x**3 - a * y + b * x**2 * y - v * y * z +# # zdot = -c * z + d * x**2 +# # return (xdot, ydot, zdot) diff --git a/src/chaotic_attractors.json b/src/chaotic_attractors.json new file mode 100644 index 0000000..df7c833 --- /dev/null +++ b/src/chaotic_attractors.json @@ -0,0 +1,4821 @@ +{ + "Comment": "This file is copied from https://github.com/williamgilpin/dysts/blob/master/dysts/data/chaotic_attractors.json. All credit goes to William Gilpin.", + "Aizawa": { + "bifurcation_parameter": null, + "citation": "Aizawa, Yoji, and Tatsuya Uezu (1982). Topological Aspects in Chaos and in 2 k-Period Doubling Cascade. Progress of Theoretical Physics 67.3 (1982): 982-985. See also Langford (1984). Numerical studies of torus bifurcations. Numerical Methods for Bifurcation Problems. Birkhauser, Basel, 1984. 285-295.", + "correlation_dimension": 1.8926529653780282, + "delay": false, + "description": "A torus-like attractor related to the forced Lorenz system.", + "dt": 0.0009043, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.78450179, + -0.62887672, + -0.17620268 + ], + "kaplan_yorke_dimension": 2.3501297618370773, + "lyapunov_spectrum_estimated": [ + 0.08947878317195473, + 0.020305496211675024, + -0.3090729926541944 + ], + "maximum_lyapunov_estimated": 0.13489555530106362, + "multiscale_entropy": 0.514512246123007, + "nonautonomous": false, + "parameters": { + "a": 0.95, + "b": 0.7, + "c": 0.6, + "d": 3.5, + "e": 0.25, + "f": 0.1 + }, + "period": 2.5837, + "pesin_entropy": 0.10978427938362978, + "unbounded_indices": [] + }, + "AnishchenkoAstakhov": { + "bifurcation_parameter": null, + "citation": "Anishchenko, et al. Nonlinear dynamics of chaotic and stochastic systems: tutorial and modern developments. 2007.", + "correlation_dimension": 1.934087922565906, + "delay": false, + "description": "Stochastic resonance in forced oscillators.", + "dt": 0.0007768, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 3.6225814, + 3.3226339, + 1.9973142 + ], + "kaplan_yorke_dimension": 2.0916403758729327, + "lyapunov_spectrum_estimated": [ + 0.039777554890210017, + 0.0008785544495802295, + -0.44025308728606666 + ], + "maximum_lyapunov_estimated": 0.10107726791527546, + "multiscale_entropy": 0.7612343892027325, + "nonautonomous": false, + "parameters": { + "eta": 0.5, + "mu": 1.2 + }, + "period": 6.814, + "pesin_entropy": 0.040715925817307534, + "unbounded_indices": [] + }, + "Arneodo": { + "bifurcation_parameter": null, + "citation": "Arneodo, A., Coullet, P. & Tresser, C. Occurence of strange attractors in three-dimensional Volterra equations. Physics Letters A 79, 259--263 (1980)", + "correlation_dimension": 1.9333366595280337, + "delay": false, + "description": "A modified Lotka-Volterra ecosystem, also known as the ACT attractor.", + "dt": 0.001215, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -2.7515698, + 0.19079818, + 3.4703629 + ], + "kaplan_yorke_dimension": 2.198607392233255, + "lyapunov_spectrum_estimated": [ + 0.24285661379003065, + -0.0006168721448237418, + -1.2169777901647385 + ], + "maximum_lyapunov_estimated": 0.23737468667051287, + "multiscale_entropy": 0.7388404221540498, + "nonautonomous": false, + "parameters": { + "a": -5.5, + "b": 4.5, + "c": 1.0, + "d": -1.0 + }, + "period": 3.1641, + "pesin_entropy": 0.2428749592514372, + "unbounded_indices": [] + }, + "ArnoldBeltramiChildress": { + "bifurcation_parameter": null, + "citation": "V. I. Arnold, Journal of Applied Mathematics and Mechanics 30, 223 (1966).", + "correlation_dimension": 1.9304327374472745, + "delay": false, + "description": "An exact solution of Euler's equation for inviscid flow in 3D. Often referred to as the ABC flow.", + "dt": 0.007127, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 147.91266, + -1762.805, + -647.37622 + ], + "kaplan_yorke_dimension": 2.612281260580053, + "lyapunov_spectrum_estimated": [ + 1.47222087191395, + -0.01824039630029517, + -2.378562986862767 + ], + "maximum_lyapunov_estimated": 0.3667300080060703, + "multiscale_entropy": 1.2759526834024162, + "nonautonomous": false, + "parameters": { + "a": 1.73205, + "b": 1.41421, + "c": 1 + }, + "period": 2.8508, + "pesin_entropy": 1.47222087191395, + "unbounded_indices": [ + 0, + 1, + 2 + ] + }, + "ArnoldWeb": { + "bifurcation_parameter": null, + "citation": "Froeschle, C., Guzzo, M. & Legga, E (2000). Graphical evolution of the Arnold web: From order to chaos. Science 289.", + "correlation_dimension": 2.271925873318733, + "delay": false, + "description": "A quasi-integrable system that transitions to Chirikov diffusive dynamics when perturbed.", + "dt": 0.003497, + "embedding_dimension": 5, + "hamiltonian": true, + "initial_conditions": [ + 0.10469507, + 0.0892929984, + 11025.3686, + 6055.32273, + 0.1 + ], + "kaplan_yorke_dimension": 22.554733912627043, + "lyapunov_spectrum_estimated": [ + 0.06266308160064184, + 0.0032177165561558833, + 0.0011281526899086728, + -0.00233619507966634, + -0.0039196281630406 + ], + "maximum_lyapunov_estimated": 0.06514413995171335, + "multiscale_entropy": 0.620621428966386, + "nonautonomous": true, + "parameters": { + "mu": 0.01, + "w": 1 + }, + "period": 67.25, + "pesin_entropy": 0.06706808893310089, + "unbounded_indices": [ + 2, + 3, + 4 + ] + }, + "AtmosphericRegime": { + "bifurcation_parameter": null, + "citation": "Tuwankotta (2006). Chaos in a coupled oscillators system with widely spaced frequencies and energy-preserving non-linearity", + "correlation_dimension": 1.0906156314277713, + "delay": false, + "description": "A model of regime transition in atmospheric flows. Contains widely-separated timescales due a quadratic term, which itself arises from a conservation law.", + "dt": 0.01773980357826076, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.026544189906947246, + 0.20580772677536016, + 0.43758119702219506 + ], + "kaplan_yorke_dimension": 2.1859596374283137, + "lyapunov_spectrum_estimated": null, + "maximum_lyapunov_estimated": 0.010543274932274862, + "multiscale_entropy": 0.4278776303819699, + "nonautonomous": false, + "parameters": { + "alpha": -2.0, + "beta": -5.0, + "mu1": 0.05, + "mu2": -0.01, + "omega": 3.0, + "sigma": 1.1 + }, + "period": 89.59496756697331, + "pesin_entropy": 0.3055574134566322, + "unbounded_indices": [] + }, + "BeerRNN": { + "bifurcation_parameter": null, + "citation": "Beer, R. D. (1995). On the dynamics of small continuous-time recurrent neural networks. Adapt. Behav., 3(4), 4692013509.", + "correlation_dimension": 1.4274264497038096, + "delay": false, + "description": "A two-neuron minimal model nervous system.", + "dt": 0.007263, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.5014532, + 2.3742845, + 0.65819415 + ], + "kaplan_yorke_dimension": 2.0303797735862443, + "lyapunov_spectrum_estimated": [ + 0.016274571192515633, + -0.00011803510272572572, + -0.5318869010933206 + ], + "maximum_lyapunov_estimated": 0.038767800131815223, + "multiscale_entropy": 0.5244807630539362, + "nonautonomous": false, + "parameters": { + "tau": [ + 1.0, + 2.5, + 1.0 + ], + "theta": [ + -4.108, + -2.787, + -1.114 + ], + "w": [ + [ + 5.422, + -0.018, + 2.75 + ], + [ + -0.24, + 4.59, + 1.21 + ], + [ + 0.535, + -2.25, + 3.885 + ] + ] + }, + "period": 181.58, + "pesin_entropy": 0.01647451962951782, + "unbounded_indices": [] + }, + "BelousovZhabotinsky": { + "bifurcation_parameter": null, + "citation": "Gyorgyi and Field (1992). A three-variable model of deterministic chaos in the Belousov-Zhabotinsky reaction. Nature.", + "correlation_dimension": 0.8599643745060099, + "delay": false, + "description": "A reduced-order model of the BZ reaction that exhibits period doubling. The bifurcation parameter for controlling the onset of chaos is kf. The system undergoes regular cycling when kf=3e-4, and chaotic oscillations when kf=3.5e-4", + "dt": 3.834e-07, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.023491701, + 0.61703254, + 0.84669066 + ], + "kaplan_yorke_dimension": 2.0206505961796535, + "lyapunov_spectrum_estimated": [ + 114.64513768787073, + -0.4669861532822692, + -5529.048679334775 + ], + "maximum_lyapunov_estimated": 132.08766434104578, + "multiscale_entropy": 0.8764191281600929, + "nonautonomous": false, + "parameters": { + "c1": -8.03474, + "c10": 0.0223915, + "c11": 7.53559e-05, + "c12": 8.07384e-06, + "c13": -0.000499825, + "c2": 0.05408, + "c3": -0.0115886, + "c4": 832.587, + "c5": -0.029155, + "c6": 0.00321617, + "c7": -0.01352, + "c8": -0.0831709, + "c9": -0.0199985, + "ci": 0.000833, + "kf": 0.00035, + "t0": 2308.62, + "y0": 7.72571e-06, + "yb1": 6.92813e-07, + "yb2": 2.00869, + "yb3": 0.01352, + "z0": 8.33e-06 + }, + "period": 0.018257, + "pesin_entropy": 114.64513768787073, + "unbounded_indices": [] + }, + "BickleyJet": { + "bifurcation_parameter": null, + "citation": "Hadjighasem, Karrasch, Teramoto, Haller (2016). A Spectral Clustering Approach to Lagrangian Vortex Detection Phys Rev E.", + "correlation_dimension": 2.0025138386006334, + "delay": false, + "description": "A zonal jet passing between two counter rotating vortices. A steady Hamiltonian with a time-dependent perturbation.", + "dt": 100.0, + "embedding_dimension": 3, + "hamiltonian": true, + "initial_conditions": [ + -0.4, + 0.3, + 0.0 + ], + "kaplan_yorke_dimension": 4.066710025133773, + "lyapunov_spectrum_estimated": [ + 1.9651794377408363e-07, + 2.5409880958463764e-09, + -9.631983584415862e-08 + ], + "maximum_lyapunov_estimated": 3.0318672544949706e-06, + "multiscale_entropy": 0.733566708397195, + "nonautonomous": false, + "parameters": { + "ell": 1.77, + "eps": [ + 0.0075, + 0.15, + 0.3 + ], + "k": [ + 0.313922, + 0.627845, + 0.941767 + ], + "omega": 1, + "sigma": [ + 9.05854e-06, + 1.28453e-05, + 2.88863e-05 + ], + "u": 6.266e-05 + }, + "period": 87826.57, + "pesin_entropy": 1.99059498764899e-07, + "unbounded_indices": [ + 1, + 2 + ] + }, + "Blasius": { + "bifurcation_parameter": null, + "citation": "Blasius, Huppert, Stone. Nature 1999", + "correlation_dimension": 1.6871652299106432, + "delay": false, + "description": " A chaotic food web composed of interacting predators,, consumers, and vegetation.", + "dt": 0.0014, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 4.031713, + 5.1113788, + 0.016508812 + ], + "kaplan_yorke_dimension": 2.016657959617314, + "lyapunov_spectrum_estimated": [ + 0.04712755400915782, + 0.001803137034352918, + -2.9362739640325555 + ], + "maximum_lyapunov_estimated": 0.12597339364128174, + "multiscale_entropy": 0.5917316835585642, + "nonautonomous": false, + "parameters": { + "a": 1, + "alpha1": 0.2, + "alpha2": 1, + "b": 1, + "c": 10, + "k1": 0.05, + "k2": 0, + "zs": 0.006 + }, + "period": 6.6038, + "pesin_entropy": 0.04893069104351076, + "unbounded_indices": [] + }, + "BlinkingRotlet": { + "bifurcation_parameter": null, + "citation": "Meleshko & Aref. A blinking rotlet model for chaotic advection. Physics of Fluids 1996. See also Tallapragada and Sudarsanam PRE 2019", + "correlation_dimension": 2.0693373122119807, + "delay": false, + "description": "The location of the mixer is chosen so that there is a stagnation point at its symmetric complement. Solution is given in polar coordinates (r, theta).", + "dt": 0.0002834, + "embedding_dimension": 3, + "hamiltonian": true, + "initial_conditions": [ + -0.08541919, + -0.05204435, + 0.0 + ], + "kaplan_yorke_dimension": 2.910902586026695, + "lyapunov_spectrum_estimated": [ + 5.609358269449125, + 0.007963961496808246, + -6.16801583110239 + ], + "maximum_lyapunov_estimated": 2.120338159738003, + "multiscale_entropy": 1.2895030395332947, + "nonautonomous": true, + "parameters": { + "a": 1.0, + "b": 0.5298833894399929, + "bc": 1, + "sigma": -1.0, + "tau": 3 + }, + "period": 2.9520625, + "pesin_entropy": 5.617567417119514, + "unbounded_indices": [ + 0, + 1, + 2 + ] + }, + "BlinkingVortex": { + "bifurcation_parameter": null, + "citation": "Aref (1984). Stirring by chaotic advection. J. Fluid Mechanics.", + "correlation_dimension": 2.212155663068541, + "delay": false, + "description": "A classic minimal chaotic mixing flow. Solution is given in polar coordinates (r, theta)", + "dt": 0.0001541, + "embedding_dimension": 3, + "hamiltonian": true, + "initial_conditions": [ + -0.08541919, + -0.05204435, + 0.0 + ], + "kaplan_yorke_dimension": 2.8911482753116986, + "lyapunov_spectrum_estimated": [ + 4.877365151111008, + -0.0016245138226140734, + -5.476774413564737 + ], + "maximum_lyapunov_estimated": 2.863016777441748, + "multiscale_entropy": 1.1011364489263011, + "nonautonomous": true, + "parameters": { + "a": 1.0, + "b": 0.5, + "bc": 0, + "sigma": -1.0, + "tau": 3 + }, + "period": 2.7616666666666667, + "pesin_entropy": 4.877593783333199, + "unbounded_indices": [ + 0, + 1, + 2 + ] + }, + "Bouali": { + "bifurcation_parameter": null, + "citation": "Bouali (1999). Feedback loop in extended Van der Pols equation applied to an economic model of cycles. International Journal of Bifurkation and Chaos, Vol. 9, No. 4", + "correlation_dimension": 1.7283783962483246, + "delay": false, + "description": "Economic cycles with fluctuating demand. Related to the DequanLi attractor", + "dt": 0.000444, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.38673159, + 3.0544196, + -0.0067836194 + ], + "kaplan_yorke_dimension": 2.224727237508172, + "lyapunov_spectrum_estimated": [ + 0.04911273564448129, + 0.0006869653413631164, + -0.22171821407820913 + ], + "maximum_lyapunov_estimated": 0.06012563518102038, + "multiscale_entropy": 0.7505556173926505, + "nonautonomous": false, + "parameters": { + "a": 1.0, + "b": -0.3, + "bb": 1.0, + "c": 0.05, + "g": 1.0, + "m": 1, + "y0": 4.0 + }, + "period": 3.0411, + "pesin_entropy": 0.049816045406570614, + "unbounded_indices": [] + }, + "Bouali2": { + "bifurcation_parameter": null, + "citation": "Bouali (1999). Feedback loop in extended Van der Pols equation applied to an economic model of cycles. International Journal of Bifurkation and Chaos, Vol. 9, No. 4", + "correlation_dimension": 1.925056080468132, + "delay": false, + "description": "A modified economic cycle model.", + "dt": 0.0004124, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.79392257, + 1.3617589, + -0.030578888 + ], + "kaplan_yorke_dimension": 16.471858210544983, + "lyapunov_spectrum_estimated": [ + 0.020389225004628773, + 0.0033455417942589724, + -0.009602768742817189 + ], + "maximum_lyapunov_estimated": 0.07681730213975516, + "multiscale_entropy": 0.4520009826326611, + "nonautonomous": false, + "parameters": { + "a": 3.0, + "b": 2.2, + "bb": 0, + "c": 0, + "g": 1.0, + "m": -0.0026667, + "y0": 1.0 + }, + "period": 2.6779, + "pesin_entropy": 0.02439941982137089, + "unbounded_indices": [] + }, + "BurkeShaw": { + "bifurcation_parameter": null, + "citation": "Shaw (1981). Zeitschrift fur Naturforschung.", + "correlation_dimension": 2.0538157998881426, + "delay": false, + "description": "A scroll-like attractor with unique symmetry along the z axis.", + "dt": 0.0001175, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.79153188, + 0.65244479, + 0.22517831 + ], + "kaplan_yorke_dimension": 2.2113447891991065, + "lyapunov_spectrum_estimated": [ + 2.3453555864112117, + 0.027056468824027846, + -11.225316054517004 + ], + "maximum_lyapunov_estimated": 2.324596351534631, + "multiscale_entropy": 0.906432166797223, + "nonautonomous": false, + "parameters": { + "e": 13, + "n": 10 + }, + "period": 0.78333, + "pesin_entropy": 2.37241205523524, + "unbounded_indices": [] + }, + "CaTwoPlus": { + "bifurcation_parameter": null, + "citation": "Houart, Dupont, Goldbeter. Bull Math Biol 1999.", + "correlation_dimension": 1.2267327876216785, + "delay": false, + "description": "Intracellular calcium ion oscillations.", + "dt": 0.0001531, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.26162904, + 1.0055612, + 0.14407867 + ], + "kaplan_yorke_dimension": 2.0647813731079956, + "lyapunov_spectrum_estimated": [ + 0.5788123099350391, + 0.022652249040266133, + -9.284523260554844 + ], + "maximum_lyapunov_estimated": 0.5802865327706731, + "multiscale_entropy": 0.5770296569860646, + "nonautonomous": false, + "parameters": { + "K2": 0.1, + "K5": 0.3194, + "Ka": 0.1, + "Kd": 1, + "Ky": 0.3, + "Kz": 0.6, + "V0": 2, + "V1": 2, + "V4": 3, + "Vm2": 6, + "Vm3": 30, + "Vm5": 50, + "beta": 0.65, + "eps": 13, + "k": 10, + "kf": 1, + "m": 2, + "n": 4, + "p": 1 + }, + "period": 1.343, + "pesin_entropy": 0.6014645592138562, + "unbounded_indices": [] + }, + "CaTwoPlusQuasiperiodic": { + "bifurcation_parameter": null, + "citation": "Houart, Dupont, Goldbeter. Bull Math Biol 1999.", + "correlation_dimension": 1.8508709631136986, + "delay": false, + "description": "Intracellular calcium ion oscillations with quasiperiodic parameter values. The original paper also includes parameters for a limit cycle", + "dt": 7.48e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.26321067, + 0.87886607, + 0.3148781 + ], + "kaplan_yorke_dimension": 4.547800407390443, + "lyapunov_spectrum_estimated": [ + 0.1620868046117494, + -0.02225809783295617, + -0.054895455267669285 + ], + "maximum_lyapunov_estimated": 0.48083152954373326, + "multiscale_entropy": 0.8512706770213926, + "nonautonomous": false, + "parameters": { + "K2": 0.1, + "K5": 0.3, + "Ka": 0.2, + "Kd": 0.5, + "Ky": 0.2, + "Kz": 0.5, + "V0": 2, + "V1": 2, + "V4": 5, + "Vm2": 6, + "Vm3": 20, + "Vm5": 30, + "beta": 0.51, + "eps": 0.1, + "k": 10, + "kf": 1, + "m": 2, + "n": 4, + "p": 2 + }, + "period": 0.65614, + "pesin_entropy": 0.16210233717161812, + "unbounded_indices": [] + }, + "CellCycle": { + "bifurcation_parameter": null, + "citation": "Romond, Rustici, Gonze, Goldbeter. 1999.", + "correlation_dimension": 1.7558665560565607, + "delay": false, + "description": "A simplified model of the cell cycle. The parameter `Kim` controls the bifurcations.", + "dt": 0.04217, + "embedding_dimension": 6, + "hamiltonian": false, + "initial_conditions": [ + 0.71565329, + 0.9489355, + 0.98910371, + 0.72138631, + 0.94987035, + 0.98912572 + ], + "kaplan_yorke_dimension": 2.020810681242375, + "lyapunov_spectrum_estimated": [ + 0.00469985418122158, + -0.0003567612310661562, + -0.20915644240415007, + -0.43394905365820846, + -2.850536314608979, + -6.767614340964144 + ], + "maximum_lyapunov_estimated": 0.010172128409635746, + "multiscale_entropy": 1.021736994304444, + "nonautonomous": false, + "parameters": { + "K": 0.01, + "Kc": 0.5, + "Kd1": 0.02, + "Kim": 0.65, + "V2": 0.15, + "V4": 0.05, + "Vm1": 0.3, + "Vm3": 0.1, + "kd1": 0.001, + "vd": 0.025, + "vi": 0.05 + }, + "period": 204.71, + "pesin_entropy": 0.004765100518900255, + "unbounded_indices": [] + }, + "CellularNeuralNetwork": { + "bifurcation_parameter": null, + "citation": "Arena, Caponetto, Fortuna, and Porto., Int J Bifurcat Chaos. 1998: 1527-1539.", + "correlation_dimension": 1.7777777253372764, + "delay": false, + "description": "Cellular neural network dynamics.", + "dt": 0.0007232, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.26574016, + -0.36754928, + -0.073094132 + ], + "kaplan_yorke_dimension": 2.167668286708633, + "lyapunov_spectrum_estimated": [ + 0.09799656528996928, + 0.0036354952626342415, + -0.6061495728157424 + ], + "maximum_lyapunov_estimated": 2.3258468977096562, + "multiscale_entropy": 1.2414841874061011, + "nonautonomous": false, + "parameters": { + "a": 4.4, + "b": 3.21, + "c": 1.1, + "d": 1.24 + }, + "period": 3.2, + "pesin_entropy": 0.1016320623247746, + "unbounded_indices": [] + }, + "Chen": { + "bifurcation_parameter": null, + "citation": "Chen (1997). Proc. First Int. Conf. Control of Oscillations and Chaos.", + "correlation_dimension": 2.080398064710209, + "delay": false, + "description": "A system based on feedback anti-control in engineering.", + "dt": 0.0001209, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 3.2689697, + 5.2990458, + 19.435349 + ], + "kaplan_yorke_dimension": 2.168621926035506, + "lyapunov_spectrum_estimated": [ + 2.0471208808332557, + -0.05031354288886987, + -11.841816202859391 + ], + "maximum_lyapunov_estimated": 2.005961349488129, + "multiscale_entropy": 0.7604529380690989, + "nonautonomous": false, + "parameters": { + "a": 35, + "b": 3, + "c": 28 + }, + "period": 0.58689, + "pesin_entropy": 2.047313967129477, + "unbounded_indices": [] + }, + "ChenLee": { + "bifurcation_parameter": null, + "citation": "Chen HK, Lee CI (2004). Anti-control of chaos in rigid body motion. Chaos, Solitons & Fractals", + "correlation_dimension": 1.2279387897055603, + "delay": false, + "description": "A rigid body with feedback anti-control.", + "dt": 0.0001963, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.17177112, + 0.10360479, + 6.2553878 + ], + "kaplan_yorke_dimension": 2.0300416878282137, + "lyapunov_spectrum_estimated": [ + 0.16460631102343384, + 0.00018225769802326938, + -5.485329903201408 + ], + "maximum_lyapunov_estimated": 0.16363115430160305, + "multiscale_entropy": 0.6224325755254609, + "nonautonomous": false, + "parameters": { + "a": 5, + "b": -10, + "c": -0.38 + }, + "period": 2.8043, + "pesin_entropy": 0.16478856872146466, + "unbounded_indices": [] + }, + "Chua": { + "bifurcation_parameter": null, + "citation": "Chua, L. O. (1969) Introduction to Nonlinear Network Theory, McGraw-Hill, New York.", + "correlation_dimension": 1.7987707234207353, + "delay": false, + "description": "An electronic circuit with a diode providing negative resistance.", + "dt": 0.006605, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.1262351, + -0.11386474, + -0.78324421 + ], + "kaplan_yorke_dimension": 2.10727056025829, + "lyapunov_spectrum_estimated": [ + 0.4605474829443073, + 0.0022048281168492866, + -4.319076735248446 + ], + "maximum_lyapunov_estimated": 1.2301163591725595, + "multiscale_entropy": 1.2693527097629784, + "nonautonomous": false, + "parameters": { + "alpha": 15.6, + "beta": 28.0, + "m0": -1.142857, + "m1": -0.71429 + }, + "period": 1.4235, + "pesin_entropy": 0.4645707969482971, + "unbounded_indices": [] + }, + "CircadianRhythm": { + "bifurcation_parameter": null, + "citation": " Leloup, Gonze, Goldbeter. 1999. Gonze, Leloup, Goldbeter. 2000", + "correlation_dimension": 1.6328881174569194, + "delay": false, + "description": "The Drosophila circadian rhythm under periodic light/dark forcing.", + "dt": 0.001728, + "embedding_dimension": 5, + "hamiltonian": false, + "initial_conditions": [ + 1.5401187, + 5.3707921, + 41.054266, + 11.619073, + 2004.0233 + ], + "kaplan_yorke_dimension": 2.640554412377753, + "lyapunov_spectrum_estimated": [ + 0.09298369588063138, + 0.00046501992305171574, + -0.14586025062784352, + -0.3598453092044599, + -1.091393481159416 + ], + "maximum_lyapunov_estimated": 0.006263277393890506, + "multiscale_entropy": 0.7054585345031309, + "nonautonomous": true, + "parameters": { + "Ki": 1, + "k": 0.5, + "k1": 0.3, + "k2": 0.15, + "kd": 1.4, + "kdn": 0.4, + "km": 0.4, + "ks": 1, + "n": 4, + "vd": 6, + "vdn": 1.5, + "vm": 0.7, + "vmax": 4.7, + "vmin": 1.0, + "vs": 6 + }, + "period": 27.0, + "pesin_entropy": 0.09372724379002938, + "unbounded_indices": [ + 4 + ] + }, + "CoevolvingPredatorPrey": { + "bifurcation_parameter": null, + "citation": "Gilpin & Feldman (2017). PLOS Comp Biol", + "correlation_dimension": 1.453444520919468, + "delay": false, + "description": "A system of predator-prey equations with co-evolving prey.", + "dt": 0.008103, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.10946017, + 0.46664421, + 0.66580212 + ], + "kaplan_yorke_dimension": 2.0026539580881706, + "lyapunov_spectrum_estimated": [ + 0.0034879428860592264, + 0.0017391810332012293, + -1.9676998121970224 + ], + "maximum_lyapunov_estimated": 0.00732698039035783, + "multiscale_entropy": 1.006450625395487, + "nonautonomous": false, + "parameters": { + "a1": 2.5, + "a2": 0.05, + "a3": 0.4, + "b1": 6.0, + "b2": 1.333, + "d1": 0.16, + "d2": 0.004, + "delta": 1, + "k1": 6.0, + "k2": 9.0, + "k4": 9.0, + "vv": 0.33333 + }, + "period": 122.77, + "pesin_entropy": 0.005379136261058156, + "unbounded_indices": [] + }, + "Colpitts": { + "bifurcation_parameter": null, + "citation": "Kennedy (2007). IEEE Trans Circuits & Systems. 1994: 771-774. Li, Zhou, Yang. Chaos, Solitons, & Fractals.", + "correlation_dimension": 1.7352885770533426, + "delay": false, + "description": "An electrical circuit used as a signal generator.", + "dt": 0.0004609, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 8.9389043, + 0.64637337, + 8.7869304 + ], + "kaplan_yorke_dimension": 2.134959031654127, + "lyapunov_spectrum_estimated": [ + 0.13750285290669104, + -0.0021021241106901328, + -1.0014048629576902 + ], + "maximum_lyapunov_estimated": 0.3736008151161584, + "multiscale_entropy": 0.7266290517682168, + "nonautonomous": false, + "parameters": { + "a": 30, + "b": 0.8, + "c": 20, + "d": 0.08, + "e": 10 + }, + "period": 4.2676, + "pesin_entropy": 0.1390751886208436, + "unbounded_indices": [] + }, + "Coullet": { + "bifurcation_parameter": null, + "citation": "Arneodo, A., Coullet, P. & Tresser, C. Occurence of strange attractors in three-dimensional volterra equations. Physics Letters A 79, 259--263 (1980)", + "correlation_dimension": 2.0922372256742787, + "delay": false, + "description": "A variant of the Arneodo attractor", + "dt": 0.002295, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.34539837958549907, + 0.4284701181998099, + 0.086983698175975 + ], + "kaplan_yorke_dimension": 2.252992250313846, + "lyapunov_spectrum_estimated": [ + 0.14890693833273877, + -6.504894715051528e-05, + -0.5873658566804084 + ], + "maximum_lyapunov_estimated": 0.13718762024831516, + "multiscale_entropy": 0.9055084400125268, + "nonautonomous": false, + "parameters": { + "a": -0.8, + "b": 1.1, + "c": 0.45, + "d": -1.0 + }, + "period": 5.7663, + "pesin_entropy": 0.14919849957322842, + "unbounded_indices": [] + }, + "Dadras": { + "bifurcation_parameter": null, + "citation": "S Dadras, HR Momeni (2009). A novel three-dimensional autonomous chaotic system generating two, three and four-scroll attractors. Physics Letters A.", + "correlation_dimension": 1.605056083622306, + "delay": false, + "description": "An electronic circuit capable of producing multiple attractors under bifurcations.", + "dt": 0.0001447, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.0284085, + -3.5348655, + -0.72081646 + ], + "kaplan_yorke_dimension": 2.0430103150081735, + "lyapunov_spectrum_estimated": [ + 0.47344233096408, + 0.0064562720284210215, + -11.157725546142514 + ], + "maximum_lyapunov_estimated": 0.40591521049520063, + "multiscale_entropy": 0.8537980405426894, + "nonautonomous": false, + "parameters": { + "c": 2.0, + "e": 9.0, + "o": 2.7, + "p": 3.0, + "r": 1.7 + }, + "period": 3.2886, + "pesin_entropy": 0.4798988304624064, + "unbounded_indices": [] + }, + "DequanLi": { + "bifurcation_parameter": null, + "citation": "Li, Phys Lett A. 2008: 387-393.", + "correlation_dimension": 1.9326161168463631, + "delay": false, + "description": "Related to the Three Scroll unified attractor TSUCS-2", + "dt": 2.598e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -11.395722, + -104.12614, + 202.46173 + ], + "kaplan_yorke_dimension": 2.6848604732863537, + "lyapunov_spectrum_estimated": [ + 1.8601963396884453, + 0.09866428540326228, + -2.867185439620747 + ], + "maximum_lyapunov_estimated": 0.739747976641268, + "multiscale_entropy": 0.8319369667525882, + "nonautonomous": false, + "parameters": { + "a": 40, + "c": 1.833, + "d": 0.16, + "eps": 0.65, + "f": 20, + "k": 55 + }, + "period": 0.083806, + "pesin_entropy": 1.9588606250917073, + "unbounded_indices": [] + }, + "DoubleGyre": { + "bifurcation_parameter": null, + "citation": "Shadden, Lekien, Marsden (2005). Definition and properties of Lagrangian coherent structures from finite-time Lyapunov exponents in two-dimensional aperiodic flows. Physica D.", + "correlation_dimension": 2.3304138196892192, + "delay": false, + "description": "A time-dependent fluid flow exhibiting Lagrangian coherent structures", + "dt": 0.002944, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.5327241, + 0.99802126, + 3879.3323 + ], + "kaplan_yorke_dimension": 2.881525629972418, + "lyapunov_spectrum_estimated": [ + 0.06285936079346421, + -0.0036702088073069326, + -0.06633987533400756 + ], + "maximum_lyapunov_estimated": 0.12185254082886439, + "multiscale_entropy": 0.66519273658672, + "nonautonomous": true, + "parameters": { + "alpha": 0.1, + "eps": 0.1, + "omega": 0.62832 + }, + "period": 13.953, + "pesin_entropy": 0.06285936079346421, + "unbounded_indices": [ + 2 + ] + }, + "DoublePendulum": { + "bifurcation_parameter": null, + "citation": "See, for example: Marion (2013). Classical dynamics of particles and systems.", + "correlation_dimension": 2.6609798545500714, + "delay": false, + "description": "Two coupled rigid pendula without damping.", + "dt": 0.0007725, + "embedding_dimension": 4, + "hamiltonian": true, + "initial_conditions": [ + -44.334542, + 223.53554, + -1.2249799, + 2.535486 + ], + "kaplan_yorke_dimension": 3.810221473882809, + "lyapunov_spectrum_estimated": [ + 8.464443924343541, + 0.46411672696182493, + -0.17345525567611142, + -10.805817517613212 + ], + "maximum_lyapunov_estimated": 3.985298067514186, + "multiscale_entropy": 0.5591104791210428, + "nonautonomous": false, + "parameters": { + "d": 1.0, + "m": 1.0 + }, + "period": 4.0234, + "pesin_entropy": 8.928560651305366, + "unbounded_indices": [ + 0, + 1 + ] + }, + "Duffing": { + "bifurcation_parameter": "gamma", + "citation": "Duffing, G. (1918), Forced oscillations with variable natural frequency and their technical relevance, Heft 41/42, Braunschweig: Vieweg.", + "correlation_dimension": 2.019134182605584, + "delay": false, + "description": "A monochromatically-forced rigid pendulum, with the nonlinearity approximated as cubic.", + "dt": 0.001773, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.1635382, + -0.5092374, + 0.0 + ], + "kaplan_yorke_dimension": 2.561219319140712, + "lyapunov_spectrum_estimated": [ + 0.09952054532941002, + 0.0003077550037828977, + -0.17595301607629793 + ], + "maximum_lyapunov_estimated": 0.14026545752865122, + "multiscale_entropy": 0.8686568999981737, + "nonautonomous": true, + "parameters": { + "alpha": 1.0, + "beta": -1.0, + "delta": 0.1, + "gamma": 0.35, + "omega": 1.4 + }, + "period": 7.4496, + "pesin_entropy": 0.10008657388524086, + "unbounded_indices": [ + 2 + ] + }, + "ExcitableCell": { + "bifurcation_parameter": null, + "citation": "Teresa Chay. Chaos In A Three-variable Model Of An Excitable Cell. Physica D 1985", + "correlation_dimension": 0.19124944684169679, + "delay": false, + "description": "A reduced-order variant of the Hodgkin-Huxley model. The parameter gkc controls the onset of chaos.", + "dt": 4.4224e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -44.57779976420271, + 0.13121643614884418, + 0.4658533583951385 + ], + "kaplan_yorke_dimension": 2.1287842177704674, + "lyapunov_spectrum_estimated": [ + 17.030315084501463, + -0.3267053778962445, + -129.70230355691595 + ], + "maximum_lyapunov_estimated": 0.7164303367057223, + "multiscale_entropy": 0.7807524009298388, + "nonautonomous": false, + "parameters": { + "gi": 1800, + "gkc": 11, + "gkv": 1700, + "gl": 7, + "kc": 0.183333, + "rho": 0.27, + "vc": 100, + "vi": 100, + "vk": -75, + "vl": -40, + "vm": -50, + "vn": -30 + }, + "period": 0.5528, + "pesin_entropy": 17.030315084501463, + "unbounded_indices": [] + }, + "Finance": { + "bifurcation_parameter": null, + "citation": "Guoliang Cai, Juanjuan Huang. International Journal of Nonlinear Science, Vol. 3 (2007)", + "correlation_dimension": 1.922279579804101, + "delay": false, + "description": "Stock fluctuations under varying investment demand and interest rates", + "dt": 0.0008706, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.51664739, + -3.9568707, + 0.0012893581 + ], + "kaplan_yorke_dimension": 2.172040321306389, + "lyapunov_spectrum_estimated": [ + 0.10708598383274774, + 0.0009835797228343356, + -0.6279525877233353 + ], + "maximum_lyapunov_estimated": 0.09354106442670211, + "multiscale_entropy": 0.7817861077722251, + "nonautonomous": false, + "parameters": { + "a": 0.001, + "b": 0.2, + "c": 1.1 + }, + "period": 9.8932, + "pesin_entropy": 0.1084488028544319, + "unbounded_indices": [] + }, + "FluidTrampoline": { + "bifurcation_parameter": null, + "citation": "Gilet, Bush. The fluid trampoline: droplets bouncing on a soap film. JFM 2009.", + "correlation_dimension": 2.18441887672186, + "delay": false, + "description": "A droplet bouncing on a horizontal soap film.", + "dt": 0.002073, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.65820064, + -2.8807787, + 0.1 + ], + "kaplan_yorke_dimension": 2.8462636972682116, + "lyapunov_spectrum_estimated": [ + 0.08081301489037329, + -0.0011783910877478326, + -0.09403052188090477 + ], + "maximum_lyapunov_estimated": 0.22311237411461174, + "multiscale_entropy": 0.796312585554829, + "nonautonomous": true, + "parameters": { + "gamma": 1.82, + "psi": 0.01019, + "w": 1.21 + }, + "period": 7.7351, + "pesin_entropy": 0.08094585172323163, + "unbounded_indices": [ + 2 + ] + }, + "ForcedBrusselator": { + "bifurcation_parameter": null, + "citation": "I. Prigogine, From Being to Becoming: Time and Complexity in the Physical Sciences, New York: W.H. Freeman and Company, 1980.", + "correlation_dimension": 1.616157126800283, + "delay": false, + "description": "An autocatalytic chemical system.", + "dt": 0.001939, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.40635464, + 1.8192295, + 6381.6484 + ], + "kaplan_yorke_dimension": 1.190019824057157, + "lyapunov_spectrum_estimated": [ + 0.0028307087627546254, + -0.014898681909916936, + -0.23304448314240073 + ], + "maximum_lyapunov_estimated": 0.015326007974604663, + "multiscale_entropy": 0.47299463051887286, + "nonautonomous": true, + "parameters": { + "a": 0.4, + "b": 1.2, + "f": 0.05, + "w": 0.81 + }, + "period": 20.411, + "pesin_entropy": 0.0028307087627546254, + "unbounded_indices": [ + 2 + ] + }, + "ForcedFitzHughNagumo": { + "bifurcation_parameter": null, + "citation": "FitzHugh, Richard (1961). Impulses and Physiological States in Theoretical Models of Nerve Membrane. Biophysical Journal. 1 (6).", + "correlation_dimension": 1.6159744662497548, + "delay": false, + "description": "A driven neuron model sustaining both quiesent and oscillating states.", + "dt": 0.002005, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.2155252, + -0.046470891, + 0.0 + ], + "kaplan_yorke_dimension": 1.5705852319395741, + "lyapunov_spectrum_estimated": [ + 0.0006271045837994497, + -0.0017541532237019502, + -0.9544351506941636 + ], + "maximum_lyapunov_estimated": 0.007561278655908403, + "multiscale_entropy": 0.946734422406113, + "nonautonomous": true, + "parameters": { + "a": 0.7, + "b": 0.8, + "curr": 0.965, + "f": 0.4008225, + "gamma": 0.08, + "omega": 0.043650793650793655 + }, + "period": 42.12235294117647, + "pesin_entropy": 0.000828176101772673, + "unbounded_indices": [ + 2 + ] + }, + "ForcedVanDerPol": { + "bifurcation_parameter": null, + "citation": "B. van der Pol (1920). A theory of the amplitude of free and forced triode vibrations. Radio Review 1.", + "correlation_dimension": 1.3243672479645296, + "delay": false, + "description": "An electronic circuit containing a triode.", + "dt": 0.0003544, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.520504, + 0.19640249, + 687.39073 + ], + "kaplan_yorke_dimension": 2.012828649055009, + "lyapunov_spectrum_estimated": [ + 0.2651824388815116, + -0.0008450617218488057, + -20.60632249066986 + ], + "maximum_lyapunov_estimated": 0.0035097622587646343, + "multiscale_entropy": 0.39443058905146283, + "nonautonomous": true, + "parameters": { + "a": 1.2, + "mu": 8.53, + "w": 0.63 + }, + "period": 14.476875, + "pesin_entropy": 0.26518243888151155, + "unbounded_indices": [ + 2 + ] + }, + "GenesioTesi": { + "bifurcation_parameter": null, + "citation": "Genesio, Tesi (1992). Harmonic balance methods for the analysis of chaotic dynamics in nonlinear systems. Automatica 28.3 (1992): 531-548.", + "correlation_dimension": 1.9474141853715994, + "delay": false, + "description": "A nonlinear control system with feedback.", + "dt": 0.002508, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.053772565, + -0.26162564, + 0.33501557 + ], + "kaplan_yorke_dimension": 2.1892507433089325, + "lyapunov_spectrum_estimated": [ + 0.09974381765927798, + 0.00038146676582121423, + -0.5282231255530121 + ], + "maximum_lyapunov_estimated": 0.10509061137519304, + "multiscale_entropy": 0.7003576241153363, + "nonautonomous": false, + "parameters": { + "a": 0.44, + "b": 1.1, + "c": 1 + }, + "period": 5.9431, + "pesin_entropy": 0.10027488648885732, + "unbounded_indices": [] + }, + "GuckenheimerHolmes": { + "bifurcation_parameter": null, + "citation": "Guckenheimer, John, and Philip Holmes (1983). Nonlinear oscillations, dynamical systems, and bifurcations of vector fields. Vol. 42. Springer Science & Business Media.", + "correlation_dimension": 2.072148151317943, + "delay": false, + "description": "A nonlinear oscillator.", + "dt": 0.012763, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.55582369, + 0.05181624, + 0.37766104 + ], + "kaplan_yorke_dimension": 2.3663164666051353, + "lyapunov_spectrum_estimated": [ + 0.34082003567895874, + -0.0032191807339425173, + -0.9216135618098852 + ], + "maximum_lyapunov_estimated": 0.7885729042404602, + "multiscale_entropy": 0.5385101182847213, + "nonautonomous": false, + "parameters": { + "a": 0.4, + "b": 20.25, + "c": 3, + "d": 1.6, + "e": 1.7, + "f": 0.44 + }, + "period": 0.3076923076923077, + "pesin_entropy": 0.3408200356941137, + "unbounded_indices": [] + }, + "Hadley": { + "bifurcation_parameter": null, + "citation": "G. Hadley (1735). On the cause of the general trade winds. Philosophical Transactions of the Royal Society, vol. 34, pp. 58--62.", + "correlation_dimension": 2.029661693798021, + "delay": false, + "description": "An atmospheric convective cell.", + "dt": 0.0007125, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.3664423, + 0.9309146, + 0.64283417 + ], + "kaplan_yorke_dimension": 2.7273838319442127, + "lyapunov_spectrum_estimated": [ + 0.31166133927315953, + -0.0010838827053467116, + -0.42739317979015523 + ], + "maximum_lyapunov_estimated": 0.2386587703845738, + "multiscale_entropy": 0.9351389987191853, + "nonautonomous": false, + "parameters": { + "a": 0.2, + "b": 4, + "f": 9, + "g": 1 + }, + "period": 1.4541, + "pesin_entropy": 0.3144504334934165, + "unbounded_indices": [] + }, + "Halvorsen": { + "bifurcation_parameter": null, + "citation": "Sprott, Julien C (2010). Elegant chaos: algebraically simple chaotic flows. World Scientific, 2010.", + "correlation_dimension": 1.8842400748281847, + "delay": false, + "description": "An algebraically-simple chaotic system with quadratic nonlinearity", + "dt": 0.0002144, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -8.6807408, + -2.4741399, + 0.070775762 + ], + "kaplan_yorke_dimension": 2.118235268907861, + "lyapunov_spectrum_estimated": [ + 0.586197150399321, + -0.031953945256851884, + -4.6876300977027565 + ], + "maximum_lyapunov_estimated": 0.6963711539102683, + "multiscale_entropy": 0.7527831765757674, + "nonautonomous": false, + "parameters": { + "a": 1.4, + "b": 4 + }, + "period": 1.4889, + "pesin_entropy": 0.586197150399321, + "unbounded_indices": [] + }, + "HastingsPowell": { + "bifurcation_parameter": null, + "citation": "Hastings, Powell. Ecology 1991", + "correlation_dimension": 1.0147969186008294, + "delay": false, + "description": "A three species food web.", + "dt": 0.006489, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.73207001, + 0.17549271, + 9.9014657 + ], + "kaplan_yorke_dimension": 2.027757892627057, + "lyapunov_spectrum_estimated": [ + 0.008585012825774563, + 0.005765040490702786, + -0.5169232002224432 + ], + "maximum_lyapunov_estimated": 0.012532796124563227, + "multiscale_entropy": 0.47829796264231095, + "nonautonomous": false, + "parameters": { + "a1": 5.0, + "a2": 0.1, + "b1": 3.0, + "b2": 2.0, + "d1": 0.4, + "d2": 0.01 + }, + "period": 135.19, + "pesin_entropy": 0.014350053316477346, + "unbounded_indices": [] + }, + "HenonHeiles": { + "bifurcation_parameter": null, + "citation": "Henon, M.; Heiles, C. (1964). The applicability of the third integral of motion: Some numerical experiments. The Astronomical Journal. 69: 73.", + "correlation_dimension": 1.483374075624846, + "delay": false, + "description": "A star's motion around the galactic center.", + "dt": 0.002548, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + -0.29707259, + -0.0031367513, + 0.42548865, + 0.071905482 + ], + "kaplan_yorke_dimension": 6.81141589838772, + "lyapunov_spectrum_estimated": [ + 0.026747154244887203, + 0.011500891097175434, + -1.4057113933414076e-05, + -0.011151041415888588 + ], + "maximum_lyapunov_estimated": 0.03551120315239528, + "multiscale_entropy": 0.7137794258156454, + "nonautonomous": false, + "parameters": { + "lam": 1 + }, + "period": 6.37, + "pesin_entropy": 0.03870865064107525, + "unbounded_indices": [] + }, + "HindmarshRose": { + "bifurcation_parameter": null, + "citation": "Marhl, Perc. Chaos, Solitons, Fractals 2005.", + "correlation_dimension": 1.646027113328854, + "delay": false, + "description": "A neuron model exhibiting spiking and bursting.", + "dt": 8.059e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.031111835, + -0.021557059, + 0.041475046 + ], + "kaplan_yorke_dimension": 2.0405369895957373, + "lyapunov_spectrum_estimated": [ + 0.2621464274609406, + 0.0017705383465481184, + -6.510663065519547 + ], + "maximum_lyapunov_estimated": 0.6535393283242747, + "multiscale_entropy": 0.8692605688019491, + "nonautonomous": false, + "parameters": { + "a": 0.49, + "b": 1.0, + "c": 0.0322, + "d": 1.0, + "s": 1.0, + "tx": 0.03, + "tz": 0.8 + }, + "period": 1.752, + "pesin_entropy": 0.2639169709155772, + "unbounded_indices": [] + }, + "Hopfield": { + "bifurcation_parameter": null, + "citation": "Lewis & Glass, Neur Comp (1992)", + "correlation_dimension": 1.988149295653683, + "delay": false, + "description": "A neural network with frustrated connectivity", + "dt": 0.00113, + "embedding_dimension": 6, + "hamiltonian": false, + "initial_conditions": [ + -0.67127393, + -0.2420173, + -0.055676628, + 0.34697948, + 0.45273118, + 0.78389688 + ], + "kaplan_yorke_dimension": 2.264479110541058, + "lyapunov_spectrum_estimated": [ + 0.07726437124258394, + -0.00018152933777384922, + -0.29083324580448194, + -0.36906925337474944, + -0.40604718386075256, + -1.4425404449511432 + ], + "maximum_lyapunov_estimated": 0.5684266951234997, + "multiscale_entropy": 0.9160145554679957, + "nonautonomous": false, + "parameters": { + "beta": 0.5, + "eps": 10, + "k": [ + [ + 0, + -1, + 0, + 0, + -1, + -1 + ], + [ + 0, + 0, + 0, + -1, + -1, + -1 + ], + [ + -1, + -1, + 0, + 0, + -1, + 0 + ], + [ + -1, + -1, + -1, + 0, + 0, + 0 + ], + [ + -1, + -1, + 0, + -1, + 0, + 0 + ], + [ + 0, + -1, + -1, + -1, + 0, + 0 + ] + ], + "tau": 2.5 + }, + "period": 10.865, + "pesin_entropy": 0.07748903749076723, + "unbounded_indices": [] + }, + "HyperBao": { + "bifurcation_parameter": null, + "citation": "Bao, Liu (2008). A hyperchaotic attractor coined from the chaotic Lu system. Chin. Physics Letters, Vol. 25, pp 2396-2399.", + "correlation_dimension": 1.9031345525981107, + "delay": false, + "description": "Hyperchaos in the Lu system.", + "dt": 0.00030068702800142903, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 9.271308063781017, + 9.752247178805291, + 23.919154915696105, + -16.69675939965203 + ], + "kaplan_yorke_dimension": 3.0460429607933572, + "lyapunov_spectrum_estimated": [ + 0.6959739496471207, + 0.2076688444499756, + 0.01646766869238271, + -19.983737503321315 + ], + "maximum_lyapunov_estimated": 0.7941925747845208, + "multiscale_entropy": 0.8910215561062699, + "nonautonomous": false, + "parameters": { + "a": 36, + "b": 3, + "c": 20, + "d": 0.1, + "e": 21 + }, + "period": 0.5831505997603473, + "pesin_entropy": 0.9201105075982862, + "unbounded_indices": [] + }, + "HyperCai": { + "bifurcation_parameter": null, + "citation": "Guoliang, Huang (2007). A New Finance Chaotic Attractor. International Journal of Nonlinear Science.", + "correlation_dimension": 2.3775113946995137, + "delay": false, + "description": "A hyperchaotic variant of the Finance system.", + "dt": 0.0003654032174278714, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + -10.691273602120157, + -15.541159376570342, + 18.388272900250726, + -14.904493939514888 + ], + "kaplan_yorke_dimension": 3.138030987910704, + "lyapunov_spectrum_estimated": [ + 1.634443623908957, + 0.12845528254618424, + -0.003328688360603957, + -12.747646341795276 + ], + "maximum_lyapunov_estimated": 1.6777584899044127, + "multiscale_entropy": 1.1155413734604414, + "nonautonomous": false, + "parameters": { + "a": 27.5, + "b": 3, + "c": 19.3, + "d": 2.9, + "e": 3.3 + }, + "period": 0.6113936187028436, + "pesin_entropy": 1.7628989064551457, + "unbounded_indices": [] + }, + "HyperJha": { + "bifurcation_parameter": null, + "citation": "J\u00fcrgen Meier (2003). Presentation of Attractors with Cinema.", + "correlation_dimension": 2.295404578145075, + "delay": false, + "description": "A hyperchaotic system.", + "dt": 0.0003746954441920209, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 13.76544888070825, + 20.203791990082554, + 32.08179795423583, + -51.189321449994914 + ], + "kaplan_yorke_dimension": 3.053181782412727, + "lyapunov_spectrum_estimated": [ + 0.3949499860671474, + 0.2920214751184925, + 0.005568431034995312, + -13.022125042186726 + ], + "maximum_lyapunov_estimated": 0.38695361636760767, + "multiscale_entropy": 0.8934166449122942, + "nonautonomous": false, + "parameters": { + "a": 10, + "b": 28, + "c": 2.667, + "d": 1.3 + }, + "period": 0.8564467295817622, + "pesin_entropy": 0.6925398922206352, + "unbounded_indices": [] + }, + "HyperLorenz": { + "bifurcation_parameter": null, + "citation": "J\u00fcrgen Meier (2003). Presentation of Attractors with Cinema.", + "correlation_dimension": 2.3256965997358985, + "delay": false, + "description": "A hyperchaotic variant of the Lorenz attractor.", + "dt": 0.00028984341439371934, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + -9.186073735061425, + -0.6744570634419695, + 16.440536886214517, + -145.0243848950473 + ], + "kaplan_yorke_dimension": 3.044709906668086, + "lyapunov_spectrum_estimated": [ + 0.2925643599949083, + 0.24691553258701357, + 0.04704434899468292, + -13.118440302968889 + ], + "maximum_lyapunov_estimated": 0.3288809596909799, + "multiscale_entropy": 0.8026458791332332, + "nonautonomous": false, + "parameters": { + "a": 10, + "b": 2.667, + "c": 28, + "d": 1.1 + }, + "period": 1.277546730110058, + "pesin_entropy": 0.5865242415766048, + "unbounded_indices": [] + }, + "HyperLu": { + "bifurcation_parameter": null, + "citation": "Chen, A., Lu, J., Lü, J., & Yu, S. (2006). Generating hyperchaotic Lü attractor via state feedback control. Physica A: Statistical Mechanics and its Applications, 364, 103-110.", + "correlation_dimension": 2.343735648584751, + "delay": false, + "description": "A hyperchaotic variant of the Lu attractor.", + "dt": 0.000315613385769233, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 8.11348619, + 10.55664382, + 18.44590719, + -28.38151717 + ], + "kaplan_yorke_dimension": 3.0822889656900583, + "lyapunov_spectrum_estimated": [ + 1.0855770127041702, + 0.4753850931706396, + 0.02849951886859947, + -19.313823203887658 + ], + "maximum_lyapunov_estimated": 1.042961263138283, + "multiscale_entropy": 1.0455788608813867, + "nonautonomous": false, + "parameters": { + "a": 36, + "b": 3, + "c": 20, + "d": 1.3 + }, + "period": 0.7162856981996777, + "pesin_entropy": 1.5894616248138722, + "unbounded_indices": [] + }, + "HyperPang": { + "bifurcation_parameter": null, + "citation": "Pang, S., & Liu, Y. (2011). A new hyperchaotic system from the Lü system and its control. Journal of Computational and Applied Mathematics, 235(8), 2775-2789.", + "correlation_dimension": 2.409444534598458, + "delay": false, + "description": "A hyperchaotic system.", + "dt": 0.0003291356000406641, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 8.40863585, + 4.67210241, + 27.91032548, + -1.26300886 + ], + "kaplan_yorke_dimension": 3.08902125132107, + "lyapunov_spectrum_estimated": [ + 1.586932998381499, + 0.28444192185263556, + -0.0011541322141891326, + -21.007696151519628 + ], + "maximum_lyapunov_estimated": 1.4465315511406867, + "multiscale_entropy": 0.9172158388570456, + "nonautonomous": false, + "parameters": { + "a": 36, + "b": 3, + "c": 20, + "d": 2 + }, + "period": 0.8439374360017028, + "pesin_entropy": 1.871913394885623, + "unbounded_indices": [] + }, + "HyperQi": { + "bifurcation_parameter": null, + "citation": "G. Qi, M. A. van Wyk, B. J. van Wyk, and G. Chen, (2008). On a new hyperchaotic system. Physics Letters A.", + "correlation_dimension": 2.0678487037707702, + "delay": false, + "description": "A hyperchaotic variant of the Qi system.", + "dt": 2.4164213125677487e-05, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 11.250900857894639, + -3.647077762541555, + 50.16987924937642, + -168.2485185683687 + ], + "kaplan_yorke_dimension": 3.2816770286126777, + "lyapunov_spectrum_estimated": [ + 13.908799876284396, + 2.8519979827853357, + -0.04957904444451209, + -59.32758839771818 + ], + "maximum_lyapunov_estimated": 12.787249321134263, + "multiscale_entropy": 0.9988440965886223, + "nonautonomous": false, + "parameters": { + "a": 50, + "b": 24, + "c": 13, + "d": 8, + "e": 33, + "f": 30 + }, + "period": 0.06186038560173437, + "pesin_entropy": 16.760797859069733, + "unbounded_indices": [] + }, + "HyperRossler": { + "bifurcation_parameter": null, + "citation": "Rossler, O. E. (1979). An equation for hyperchaos.", + "correlation_dimension": 1.8918979971680174, + "delay": false, + "description": "A hyperchaotic variant of the Rossler system.", + "dt": 0.000732209408095841, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + -93.667697, + 15.5078, + 0.032086964, + 43.792796 + ], + "kaplan_yorke_dimension": 2.916384112225743, + "lyapunov_spectrum_estimated": [ + 0.27859233648384435, + -7.749198930652314e-05, + -0.3014660985555502, + -70.26609894565237 + ], + "maximum_lyapunov_estimated": 0.1718849632568779, + "multiscale_entropy": 0.9144754695112332, + "nonautonomous": false, + "parameters": { + "a": 0.25, + "b": 3.0, + "c": 0.5, + "d": 0.05 + }, + "period": 1.1157476694793766, + "pesin_entropy": 0.2789695684743801, + "unbounded_indices": [] + }, + "HyperWang": { + "bifurcation_parameter": null, + "citation": "Wang, Z., Sun, Y., van Wyk, B. J., Qi, G. & van Wyk, M. A (2009). A 3-D four-wing attractor and its analysis. Brazilian J. Phys. 39.", + "correlation_dimension": 2.384028593490252, + "delay": false, + "description": "A hyperchaotic variant of the Wang system.", + "dt": 0.0003402798297977575, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 0.16824907, + 0.16854103, + 37.04033781, + -15.29027381 + ], + "kaplan_yorke_dimension": 3.105321722354005, + "lyapunov_spectrum_estimated": [ + 1.2224015619377895, + 0.25827623672371736, + -0.0075512136517132625, + -13.986919236227278 + ], + "maximum_lyapunov_estimated": 1.2930140887300063, + "multiscale_entropy": 0.9969261837212393, + "nonautonomous": false, + "parameters": { + "a": 10, + "b": 40, + "c": 2.5, + "d": 10.6, + "e": 4 + }, + "period": 0.6481520567576332, + "pesin_entropy": 1.480677798661507, + "unbounded_indices": [] + }, + "HyperXu": { + "bifurcation_parameter": null, + "citation": "Letellier & Rossler (2007). Hyperchaos. Scholarpedia 2.8 (2007): 1936.", + "correlation_dimension": 2.305709840802521, + "delay": false, + "description": "A hyperchaotic system.", + "dt": 0.0004584361211286094, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 0.68944486, + -0.60254126, + -0.5814657, + 0.26629277 + ], + "kaplan_yorke_dimension": 3.0909471864561056, + "lyapunov_spectrum_estimated": [ + 1.0420068843753962, + 0.20717763316365526, + -0.0033988115975040426, + -13.697896294059921 + ], + "maximum_lyapunov_estimated": 0.9819830018599975, + "multiscale_entropy": 0.9312323303231519, + "nonautonomous": false, + "parameters": { + "a": 10, + "b": 40, + "c": 2.5, + "d": 2, + "e": 16 + }, + "period": 1.1328151255687646, + "pesin_entropy": 1.2491913312241498, + "unbounded_indices": [] + }, + "HyperYan": { + "bifurcation_parameter": null, + "citation": "J\u00fcrgen Meier (2003). Presentation of Attractors with Cinema.", + "correlation_dimension": 1.7169092247689766, + "delay": false, + "description": "A hyperchaotic system.", + "dt": 0.00011572652857280079, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + -6.576620730899293, + -4.617145437320736, + 17.796515255115004, + 0.8072357311545831 + ], + "kaplan_yorke_dimension": 2.0711118082329567, + "lyapunov_spectrum_estimated": [ + 0.9120352761173002, + 0.15303345953001665, + -14.977382134147613, + -39.36365990052555 + ], + "maximum_lyapunov_estimated": 1.3945968455812914, + "multiscale_entropy": 0.8166157518949907, + "nonautonomous": false, + "parameters": { + "a": 37, + "b": 3, + "c": 26, + "d": 38 + }, + "period": 0.9127028626966961, + "pesin_entropy": 1.0650687356473167, + "unbounded_indices": [] + }, + "HyperYangChen": { + "bifurcation_parameter": null, + "citation": "J\u00fcrgen Meier (2003). Presentation of Attractors with Cinema.", + "correlation_dimension": 2.4394788306107964, + "delay": false, + "description": "A hyperchaotic system.", + "dt": 0.00036508114507867846, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 3.534464234888686, + 4.82852516302869, + 25.04917588890622, + 17.118520274514353 + ], + "kaplan_yorke_dimension": 3.026605264361547, + "lyapunov_spectrum_estimated": [ + 0.5742688696462735, + 0.327365255173604, + 0.023510192276255986, + -34.77284163099938 + ], + "maximum_lyapunov_estimated": 0.42042732521941667, + "multiscale_entropy": 0.9730322217427024, + "nonautonomous": false, + "parameters": { + "a": 30, + "b": 3, + "c": 35, + "d": 8 + }, + "period": 0.9127028626966961, + "pesin_entropy": 0.9255171125652686, + "unbounded_indices": [] + }, + "IkedaDelay": { + "bifurcation_parameter": null, + "citation": "K. Ikeda and K. Matsumoto (1987). High-dimensional chaotic behavior in systems with time-delayed feedback, Physica D, 29 (1-2), 223-235", + "correlation_dimension": 1.2140433047733024, + "delay": true, + "description": "A passive optical resonator system. A standard delay dimension of three is used.", + "dt": 0.0006215, + "embedding_dimension": 10, + "hamiltonian": false, + "initial_conditions": [ + 0.94144317, + 3.79262024, + 3.17466302, + -3.87959208, + 2.05198674, + 0.95755518, + 1.45382405, + 3.04462032, + -1.70340258, + 1.00350536 + ], + "kaplan_yorke_dimension": 8.284295212220359, + "lyapunov_spectrum_estimated": [ + 0.7139744431963619, + 0.03258370277261943, + -0.06766062243103049, + -0.07744565521894307, + -0.09054735418410836, + -0.10900317234818346, + -0.13696057562417352, + -0.18439894250590672, + -0.2833034824174493, + -0.6392438255039592 + ], + "maximum_lyapunov_estimated": 0.448298365567425, + "nonautonomous": false, + "parameters": { + "c": 1.0, + "mu": -20, + "tau": 2.0, + "x0": 0.0 + }, + "period": 1.486528, + "pesin_entropy": 0.7465581459689814, + "unbounded_indices": [] + }, + "InteriorSquirmer": { + "bifurcation_parameter": null, + "citation": "Blake, J. R. Self propulsion due to oscillations on the surface of a cylinder at low Reynolds number. AMS Bulletin 1971.", + "correlation_dimension": 2.4915316423406364, + "delay": false, + "description": "Boundary-driven flow of a viscous fluid within a cylinder. Any slip boundary condition can be used, as long as it is parametrized by its Fourier coefficients.", + "dt": 0.0034587087840134245, + "embedding_dimension": 3, + "hamiltonian": true, + "initial_conditions": [ + 0.1, + 0.1, + 0.1 + ], + "kaplan_yorke_dimension": 3.244868718449604, + "lyapunov_spectrum_estimated": [ + 0.84473454954854, + 0.06626639436139446, + -0.7318095377786615 + ], + "maximum_lyapunov_estimated": 0.84473454954854, + "multiscale_entropy": 0.8772895630687737, + "nonautonomous": true, + "parameters": { + "a": [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + "g": [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + "n": 5, + "tau": 3 + }, + "period": 28.822573200111794, + "pesin_entropy": 0.9110009439099345, + "unbounded_indices": [ + 2 + ] + }, + "IsothermalChemical": { + "bifurcation_parameter": null, + "citation": "Petrov, Scott, Showalter. Mixed-mode oscillations in chemical systems. J Chem Phys 1992", + "correlation_dimension": 1.0903385466106001, + "delay": false, + "description": "An isothermal chemical system with mixed-mode oscillations", + "dt": 8.907e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.5141505602006595, + 0.9984288208727641, + 1.0061777118724 + ], + "kaplan_yorke_dimension": 2.0385823810364654, + "lyapunov_spectrum_estimated": [ + 0.3365871343421436, + -0.05136527222093221, + -7.392541736904205 + ], + "maximum_lyapunov_estimated": 0.450090505359164, + "multiscale_entropy": 0.6589422003608746, + "nonautonomous": false, + "parameters": { + "delta": 1.0, + "kappa": 2.5, + "mu": 0.29786, + "sigma": 0.013 + }, + "period": 0.7302799999999999, + "pesin_entropy": 0.3365871343421436, + "unbounded_indices": [] + }, + "ItikBanksTumor": { + "bifurcation_parameter": null, + "citation": "Itik, Banks. Int J Bifurcat Chaos 2010", + "correlation_dimension": 1.0127192656492157, + "delay": false, + "description": "A model of cancer cell populations.", + "dt": 0.002487, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.051730215, + 0.87071642, + 0.015926427 + ], + "kaplan_yorke_dimension": 2.0152772613355485, + "lyapunov_spectrum_estimated": [ + 0.022156938955395417, + -0.0135394920593605, + -0.5610833889492404 + ], + "maximum_lyapunov_estimated": 0.03621509684991421, + "multiscale_entropy": 0.5883298730506914, + "nonautonomous": false, + "parameters": { + "a12": 1, + "a13": 2.5, + "a21": 1.5, + "a31": 0.2, + "d3": 0.5, + "k3": 1, + "r2": 0.6, + "r3": 4.5 + }, + "period": 49.74, + "pesin_entropy": 0.022156938955395417, + "unbounded_indices": [] + }, + "JerkCircuit": { + "bifurcation_parameter": null, + "citation": "Sprott (2011). A new chaotic jerk circuit. IEEE Circ. Sys. 2011.", + "correlation_dimension": 1.836822800294913, + "delay": false, + "description": "An electronic circuit with nonlinearity provided by a diode.", + "dt": 0.000749, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.300882, + 0.065382947, + 0.91801911 + ], + "kaplan_yorke_dimension": 2.5082428902531144, + "lyapunov_spectrum_estimated": [ + 0.394872929553187, + 0.1849026306096344, + -1.1407351759248092 + ], + "maximum_lyapunov_estimated": 0.2922722771543928, + "multiscale_entropy": 0.38139916676685187, + "nonautonomous": false, + "parameters": { + "eps": 1e-09, + "y0": 0.026 + }, + "period": 19.4546, + "pesin_entropy": 0.5797755601628214, + "unbounded_indices": [] + }, + "KawczynskiStrizhak": { + "bifurcation_parameter": null, + "citation": "P. E. Strizhak and A. L. Kawczynski, J. Phys. Chem. 99, 10830 (1995).", + "correlation_dimension": 0.49778489205270265, + "delay": false, + "description": "A chemical oscillator model describing mixed-modes in the BZ equations.", + "dt": 0.00959, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.160501, + 5.8636902, + -1.2031947 + ], + "kaplan_yorke_dimension": 1.4235221965773541, + "lyapunov_spectrum_estimated": [ + 0.025607519929323416, + -0.06145426210744069, + -0.31683393262481707 + ], + "maximum_lyapunov_estimated": 0.0757060839542753, + "multiscale_entropy": 0.5935098791328474, + "nonautonomous": false, + "parameters": { + "beta": -0.4, + "gamma": 0.49, + "kappa": 0.2, + "mu": 2.1 + }, + "period": 7.991666666666667, + "pesin_entropy": 0.02560751992932341, + "unbounded_indices": [] + }, + "Laser": { + "bifurcation_parameter": null, + "citation": "Abooee, Yaghini-Bonabi, Jahed-Motlagh (2013). Analysis and circuitry realization of a novel three-dimensional chaotic system. Comm Nonline Sci 2013", + "correlation_dimension": 1.7191054642322454, + "delay": false, + "description": "A semiconductor laser model", + "dt": 8.52e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -2.540801356216252, + -1.940570579119389, + -2.9680975444071955 + ], + "kaplan_yorke_dimension": 2.049321615812801, + "lyapunov_spectrum_estimated": [ + 0.7637435195473311, + 0.020943250302999646, + -15.909545615344538 + ], + "maximum_lyapunov_estimated": 0.6080602180196161, + "multiscale_entropy": 1.004437967414151, + "nonautonomous": false, + "parameters": { + "a": 10.0, + "b": 1.0, + "c": 5.0, + "d": -1.0, + "h": -5.0, + "k": -6.0 + }, + "period": 0.94667, + "pesin_entropy": 0.7848314215142518, + "unbounded_indices": [] + }, + "LidDrivenCavityFlow": { + "bifurcation_parameter": null, + "citation": "Grover et al. Chaos (2012). Topological chaos, braiding and bifurcation of almost-cyclic sets.", + "correlation_dimension": 2.4669485126996986, + "delay": false, + "description": "A two-dimensional flow alternately driven by translation of the left and right walls.", + "dt": 0.0005269919710144677, + "embedding_dimension": 3, + "hamiltonian": true, + "initial_conditions": [ + 3.966790341130254, + 0.18425981346720144, + 0.0 + ], + "kaplan_yorke_dimension": 2.9856669109882814, + "lyapunov_spectrum_estimated": [ + 1.00757312, + -0.00276829, + -1.01941623 + ], + "maximum_lyapunov_estimated": 2.172601412109087, + "multiscale_entropy": 0.7815824521381879, + "nonautonomous": true, + "parameters": { + "a": 6.0, + "b": 1.0, + "tau": 1.1, + "u1": 9.92786, + "u2": 8.34932 + }, + "period": 2.7333134945588955, + "pesin_entropy": 1.007573134065856, + "unbounded_indices": [ + 2 + ] + }, + "LiuChen": { + "bifurcation_parameter": null, + "citation": "Liu, Chen. Int J Bifurcat Chaos. 2004: 1395-1403.", + "correlation_dimension": 1.06018642946504, + "delay": false, + "description": "Derived from Sakarya.", + "dt": 0.0001483, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 4.6722764, + 5.2437205e-10, + -6.4444208e-10 + ], + "kaplan_yorke_dimension": 1.2188137323261288, + "lyapunov_spectrum_estimated": [ + 0.21332142584135133, + -0.9748996261500176, + -18.807059276226646 + ], + "maximum_lyapunov_estimated": 0.2457084451352168, + "multiscale_entropy": 0.7641473604711979, + "nonautonomous": false, + "parameters": { + "a": 0.4, + "b": 12.0, + "c": -5.0, + "h": 0.0, + "p": 0.0, + "q": -1.0, + "r": 1.0, + "s": 1.0 + }, + "period": 8.0164, + "pesin_entropy": 0.2133214258413513, + "unbounded_indices": [] + }, + "Lorenz": { + "bifurcation_parameter": null, + "citation": "Lorenz, Edward N (1963). Deterministic nonperiodic flow. Journal of the atmospheric sciences 20.2 (1963): 130-141.", + "correlation_dimension": 1.993931310517824, + "delay": false, + "description": "A minimal weather model based on atmospheric convection.", + "dt": 0.0001801, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -9.7869288, + -15.03852, + 20.533978 + ], + "kaplan_yorke_dimension": 2.075158758095728, + "lyapunov_spectrum_estimated": [ + 1.0910931847726466, + 0.02994120961308413, + -14.915552395875103 + ], + "maximum_lyapunov_estimated": 0.8917098035724058, + "multiscale_entropy": 1.1541457906835575, + "nonautonomous": false, + "parameters": { + "beta": 2.667, + "rho": 28, + "sigma": 10 + }, + "period": 1.5008, + "pesin_entropy": 1.121034394385731, + "unbounded_indices": [] + }, + "Lorenz84": { + "bifurcation_parameter": null, + "citation": "E. Lorenz (1984). Irregularity: a fundamental property of the atmosphere. Tellus A, vol. 36, no. 2, pp. 98--110, 1984.", + "correlation_dimension": 1.8667731027742769, + "delay": false, + "description": "Atmospheric circulation analogous to Hadley convection.", + "dt": 0.000363, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.926479236120359, + -0.13402110197257552, + -1.72146730664761 + ], + "kaplan_yorke_dimension": 2.4449761695022096, + "lyapunov_spectrum_estimated": [ + 1.0474807193950644, + -0.045398035352994866, + -2.251992293230755 + ], + "maximum_lyapunov_estimated": 0.46146683857936616, + "multiscale_entropy": 0.6685802317710752, + "nonautonomous": false, + "parameters": { + "a": 1.32, + "b": 7.91, + "f": 4.83, + "g": 4.194 + }, + "period": 6.2586, + "pesin_entropy": 1.0474807193950644, + "unbounded_indices": [] + }, + "Lorenz96": { + "bifurcation_parameter": null, + "citation": "Lorenz, Edward (1996). Predictability: A problem partly solved. Seminar on Predictability, Vol. I, ECMWF.", + "correlation_dimension": 2.2561447518650386, + "delay": false, + "description": "A climate model containing fluid-like advective nonlinearities, and multiscale coupling of fast and slow variables.", + "dt": 0.0001428, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + -2.46820633, + 0.09570264, + 1.59270902, + 10.21372147 + ], + "kaplan_yorke_dimension": 3.1698163415908196, + "lyapunov_spectrum_estimated": [ + 1.6247012663091516, + 0.17185232259745578, + -1.1936282999960617, + -3.550455057872212 + ], + "maximum_lyapunov_estimated": 1.3361667787286362, + "multiscale_entropy": 0.8046726640855828, + "nonautonomous": false, + "parameters": { + "f": 20.0 + }, + "period": 2.1969, + "pesin_entropy": 1.7965535889066073, + "unbounded_indices": [] + }, + "LorenzBounded": { + "bifurcation_parameter": null, + "citation": "Sprott & Xiong (2015). Chaos.", + "correlation_dimension": 1.9641115851657072, + "delay": false, + "description": "The Lorenz attractor in the presence of a confining potential.", + "dt": 0.0002606, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -13.284881, + -12.444334, + 34.188198 + ], + "kaplan_yorke_dimension": 2.0704391073439155, + "lyapunov_spectrum_estimated": [ + 0.8497533717540197, + 0.001413707285345669, + -12.120634680260636 + ], + "maximum_lyapunov_estimated": 0.7124135270827626, + "multiscale_entropy": 1.1983193915488475, + "nonautonomous": false, + "parameters": { + "beta": 2.667, + "r": 64, + "rho": 28, + "sigma": 10 + }, + "period": 1.3716, + "pesin_entropy": 0.8513198508911037, + "unbounded_indices": [] + }, + "LorenzCoupled": { + "bifurcation_parameter": null, + "citation": "Lorenz, Edward N. Deterministic nonperiodic flow. Journal of the atmospheric sciences 20.2 (1963): 130-141.", + "correlation_dimension": 2.3989498239642524, + "delay": false, + "description": "Two coupled Lorenz attractors.", + "dt": 0.0001799, + "embedding_dimension": 6, + "hamiltonian": false, + "initial_conditions": [ + 7.0921483, + 10.117408, + 25.708428, + 2.1689893, + 0.96121877, + 0.89550187 + ], + "kaplan_yorke_dimension": 3.0408069075490425, + "lyapunov_spectrum_estimated": [ + 1.2218762961515068, + 0.1222254715421154, + -1.265209618630438, + -1.9333037412103384, + -13.618111101381306, + -15.073328947851422 + ], + "maximum_lyapunov_estimated": 1.0284398414904556, + "multiscale_entropy": 1.1717493753138832, + "nonautonomous": false, + "parameters": { + "beta": 2.667, + "eps": 2.85, + "rho": 28, + "rho1": 35, + "rho2": 1.15, + "sigma": 10 + }, + "period": 1.6207, + "pesin_entropy": 1.3441017676936224, + "unbounded_indices": [] + }, + "LorenzStenflo": { + "bifurcation_parameter": null, + "citation": "Letellier & Rossler (2007). Hyperchaos. Scholarpedia 2.8 (2007): 1936.", + "correlation_dimension": 2.119146547661978, + "delay": false, + "description": "Atmospheric acoustic-gravity waves.", + "dt": 0.0006259, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 4.233438598886809, + 9.08970605484108, + 21.86662535600487, + -1.4080695182833802 + ], + "kaplan_yorke_dimension": 2.1738121741011174, + "lyapunov_spectrum_estimated": [ + 0.44944459925783387, + 0.026077542739630446, + -2.7358399678801906, + -3.4213273148340293 + ], + "maximum_lyapunov_estimated": 0.3807742646421621, + "multiscale_entropy": 1.0299236916146275, + "nonautonomous": false, + "parameters": { + "a": 2, + "b": 0.7, + "c": 26, + "d": 1.5 + }, + "period": 3.8877142857142855, + "pesin_entropy": 0.47552214199746434, + "unbounded_indices": [] + }, + "LuChen": { + "bifurcation_parameter": null, + "citation": "Lu, Chen. Int J Bifurcat Chaos. 2002: 659-661.", + "correlation_dimension": 1.372789971167648, + "delay": false, + "description": "A system that switches shapes between the Lorenz and Chen attractors as the parameter c is varied from 12.7 to 28.5. Also called the Chen Celikovsky attractor", + "dt": 0.0001216, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 10.956479, + 9.8813092, + 22.676714 + ], + "kaplan_yorke_dimension": 2.0358980309317456, + "lyapunov_spectrum_estimated": [ + 0.6651845739025707, + 0.1450338199952451, + -22.56999542505058 + ], + "maximum_lyapunov_estimated": 0.3266868574498627, + "multiscale_entropy": 0.4483903807918106, + "nonautonomous": false, + "parameters": { + "a": 36, + "b": 3, + "c": 18 + }, + "period": 2.3385, + "pesin_entropy": 0.8102183938978158, + "unbounded_indices": [] + }, + "LuChenCheng": { + "bifurcation_parameter": null, + "citation": "Lu, Chen, Cheng. Int J Bifurcat Chaos. 2004: 1507--1537.", + "correlation_dimension": 1.7225991312358646, + "delay": false, + "description": "A four scroll attractor that reduces to Lorenz-like dynamics under bifurcations.", + "dt": 0.0001108, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -5.5177615, + 2.4990595, + 10.461798 + ], + "kaplan_yorke_dimension": 2.0293036172873244, + "lyapunov_spectrum_estimated": [ + 0.35106210160478324, + -0.012414362698175424, + -11.556516575635818 + ], + "maximum_lyapunov_estimated": 0.2612775880231121, + "multiscale_entropy": 0.6029763775293518, + "nonautonomous": false, + "parameters": { + "a": -10, + "b": -4, + "c": 18.1 + }, + "period": 0.92333, + "pesin_entropy": 0.3510621518701211, + "unbounded_indices": [] + }, + "MacArthur": { + "bifurcation_parameter": null, + "citation": "MacArthur, R. 1969. Species packing, and what competition minimizes. PNAS 64:1369. Parameter values taken from a model of phytoplankton in Huisman & Weissing. Nature 1999.", + "correlation_dimension": 2.2702320395980986, + "delay": false, + "description": "Population abundances in a plankton community, based on MacArthur's consumer resource model. Growth rates are determined using Liebig's law of the maximum", + "dt": 0.004384, + "embedding_dimension": 10, + "hamiltonian": false, + "initial_conditions": [ + 9.4323333, + 18.838654, + 34.37572, + 15.08545, + 42.228427, + 0.17030505, + 0.10144427, + 0.3148045, + 0.21253581, + 0.22598604 + ], + "kaplan_yorke_dimension": 3.8961444775216614, + "lyapunov_spectrum_estimated": [ + 0.1934617869736995, + 0.004866584152339167, + -0.0431132227766039, + -0.17665092099562724, + -0.30357752906614904, + -0.30392441898183636, + -0.30474608910196055, + -0.3051840587615213, + -0.3058908399877519, + -17.37453227551654 + ], + "maximum_lyapunov_estimated": 0.2494638510848618, + "multiscale_entropy": 0.7844902548776685, + "nonautonomous": false, + "parameters": { + "c": [ + [ + 0.04, + 0.04, + 0.07, + 0.04, + 0.04 + ], + [ + 0.08, + 0.08, + 0.08, + 0.1, + 0.08 + ], + [ + 0.1, + 0.1, + 0.1, + 0.1, + 0.14 + ], + [ + 0.05, + 0.03, + 0.03, + 0.03, + 0.03 + ], + [ + 0.07, + 0.09, + 0.07, + 0.07, + 0.07 + ] + ], + "d": 0.25, + "k": [ + [ + 0.39, + 0.34, + 0.3, + 0.24, + 0.23 + ], + [ + 0.22, + 0.39, + 0.34, + 0.3, + 0.27 + ], + [ + 0.27, + 0.22, + 0.39, + 0.34, + 0.3 + ], + [ + 0.3, + 0.24, + 0.22, + 0.39, + 0.34 + ], + [ + 0.34, + 0.3, + 0.22, + 0.2, + 0.39 + ] + ], + "m": 0.25, + "r": 1, + "s": [ + 6, + 10, + 14, + 4, + 9 + ] + }, + "period": 43.406, + "pesin_entropy": 0.19832837112603868, + "unbounded_indices": [] + }, + "MackeyGlass": { + "bifurcation_parameter": null, + "citation": "Glass, L. and Mackey, M. C. (1979). Pathological physiological conditions resulting from instabilities in physiological control systems. Ann. NY. Acad. Sci.", + "correlation_dimension": 1.7750825878015626, + "delay": true, + "description": "A physiological circuit with time-delayed feedback. A standard delay dimension of three is used.", + "dt": 0.0011564772806684687, + "embedding_dimension": 10, + "hamiltonian": false, + "initial_conditions": [ + 0.83347846, + 1.04053938, + 1.25764979, + 0.38088098, + 0.92160075, + 1.14714708, + 0.80463944, + 0.86849516, + 1.16961728, + 0.76980123 + ], + "kaplan_yorke_dimension": 8.012917999650943, + "lyapunov_spectrum_estimated": [ + 0.21081023801544096, + 0.16332731438425996, + -0.03580777756738295, + -0.041336844485590406, + -0.04889078450243534, + -0.059836905162829496, + -0.07714200039885702, + -0.10872244658769878, + -0.18584871959889662, + -2.2412562118189827 + ], + "maximum_lyapunov_estimated": 0.07287527454565443, + "nonautonomous": false, + "parameters": { + "beta": 2, + "gamma": 1.0, + "n": 9.65, + "tau": 2.0 + }, + "period": 5.9612230962292045, + "pesin_entropy": 0.3741375523997009, + "unbounded_indices": [] + }, + "MooreSpiegel": { + "bifurcation_parameter": null, + "citation": "Moore, Spiegel. A Thermally Excited Nonlinear Oscillator, Ap. J., 143, 871 (1966)", + "correlation_dimension": 1.8466427700305443, + "delay": false, + "description": "A thermo-mechanical oscillator.", + "dt": 0.0001598, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -3.4733266, + 19.666962, + -3.8262485 + ], + "kaplan_yorke_dimension": 2.3217713120052443, + "lyapunov_spectrum_estimated": [ + 0.4074353399833356, + -0.022079955878999143, + -1.1975751283606624 + ], + "maximum_lyapunov_estimated": 0.6976623003008144, + "multiscale_entropy": 0.5401952179209213, + "nonautonomous": false, + "parameters": { + "a": 10, + "b": 4, + "eps": 9 + }, + "period": 1.2887, + "pesin_entropy": 0.4076334003995097, + "unbounded_indices": [] + }, + "MultiChua": { + "bifurcation_parameter": null, + "citation": "Mufcstak E. Yalcin, Johan A. K. Suykens, Joos Vandewalle. Cellular Neural Networks, Multi-Scroll Chaos And Synchronization. ", + "correlation_dimension": 1.7519423469999007, + "delay": false, + "description": "Multiple interacting Chua electronic circuits.", + "dt": 0.0007589, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -21.160123, + 1.0322356, + 27.405269 + ], + "kaplan_yorke_dimension": 2.0710214570482988, + "lyapunov_spectrum_estimated": [ + 0.2210571234274344, + -0.00140279701621115, + -3.10264254580399 + ], + "maximum_lyapunov_estimated": 1.462134784614238, + "multiscale_entropy": 0.8118881305702679, + "nonautonomous": false, + "parameters": { + "a": 9, + "b": 14.286, + "c": [ + 0, + 1.0, + 2.15, + 3.6, + 8.2, + 13.0 + ], + "m": [ + -0.14285714, + 0.28571429, + -0.57142857, + 0.28571429, + -0.57142857, + 0.28571429 + ] + }, + "period": 2.2586, + "pesin_entropy": 0.22151080996231726, + "unbounded_indices": [] + }, + "NewtonLiepnik": { + "bifurcation_parameter": null, + "citation": "Leipnik, R. B., and T. A. Newton (1981). Double strange attractors in rigid body motion with linear feedback control. Physics Letters A 86.2 (1981): 63-67.", + "correlation_dimension": 2.0051574625339903, + "delay": false, + "description": "Euler's equations for a rigid body, augmented with a linear feedback term.", + "dt": 0.0009871, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.29430753, + 0.10649486, + 0.29081125 + ], + "kaplan_yorke_dimension": 2.2206092778719664, + "lyapunov_spectrum_estimated": [ + 0.1723564207468104, + -0.00036976661148194504, + -0.7795789311467557 + ], + "maximum_lyapunov_estimated": 0.14945341784639976, + "multiscale_entropy": 0.6322918700854281, + "nonautonomous": false, + "parameters": { + "a": 0.4, + "b": 0.175 + }, + "period": 8.5095, + "pesin_entropy": 0.17242608410350868, + "unbounded_indices": [] + }, + "NoseHoover": { + "bifurcation_parameter": null, + "citation": "Nose, S (1985). A unified formulation of the constant temperature molecular-dynamics methods. Journal of Chemical Physics (1984). Hoover, William G. Canonical dynamics: Equilibrium phase-space distributions. Phys. Rev. A. Hoover, William G., Anthony JC Ladd, and Bill Moran (1982). High-strain-rate plastic flow studied via nonequilibrium molecular dynamics. Physical Review Letters.", + "correlation_dimension": 1.9624149541987226, + "delay": false, + "description": "Fixed temperature molecular dynamics for a strained flow under a reduced order model.", + "dt": 0.0009857, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.9758582, + 0.24647527, + 0.79024299 + ], + "kaplan_yorke_dimension": 6.213204677134776, + "lyapunov_spectrum_estimated": [ + 0.04757010871740569, + 0.0013844486958287268, + -0.011653762286922777 + ], + "maximum_lyapunov_estimated": 0.010464383779400952, + "multiscale_entropy": 0.5656074689683536, + "nonautonomous": false, + "parameters": { + "a": 1.5 + }, + "period": 5.8673, + "pesin_entropy": 0.04895455741323442, + "unbounded_indices": [] + }, + "NuclearQuadrupole": { + "bifurcation_parameter": null, + "citation": "Baran V. and Raduta A. A. (1998), International Journal of Modern Physics E", + "correlation_dimension": 2.0980551223412083, + "delay": false, + "description": "A quadrupole boson Hamiltonian that produces chaos via a resonance overlap mechanism", + "dt": 0.03277, + "embedding_dimension": 4, + "hamiltonian": true, + "initial_conditions": [ + -0.85591178, + 1.48078342, + -0.85075322, + 1.63576085 + ], + "kaplan_yorke_dimension": 4.280996083113027, + "lyapunov_spectrum_estimated": [ + 0.27858365099437626, + 0.06629535725881477, + -0.00449888101008936, + -0.2658004759134054 + ], + "maximum_lyapunov_estimated": 0.29554197767663787, + "multiscale_entropy": 0.8209529097052416, + "nonautonomous": false, + "parameters": { + "a": 1.0, + "b": 0.55, + "d": 0.4 + }, + "period": 6.023076923076923, + "pesin_entropy": 0.3448827969293456, + "unbounded_indices": [] + }, + "OscillatingFlow": { + "bifurcation_parameter": null, + "citation": "T. H. Solomon and J. P. Gollub, Phys. Rev. A 38, 6280 (1988).", + "correlation_dimension": 2.346659533315372, + "delay": false, + "description": "A model fluid flow that produces KAM tori. Original parameters have been rescaled by k", + "dt": 0.002672, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 3.14159265, + 1.04719755, + 0.4 + ], + "kaplan_yorke_dimension": 2.962629189215532, + "lyapunov_spectrum_estimated": [ + 0.4274159768365289, + -0.005029615144529367, + -0.43888500460322705 + ], + "maximum_lyapunov_estimated": 0.13470179997834794, + "multiscale_entropy": 0.6177682255070645, + "nonautonomous": true, + "parameters": { + "b": 0.48, + "k": 1.0, + "omega": 0.49, + "u": 0.72 + }, + "period": 23.857, + "pesin_entropy": 0.4274159768365288, + "unbounded_indices": [ + 0, + 1 + ] + }, + "PanXuZhou": { + "bifurcation_parameter": null, + "citation": "Zhou, Wuneng, et al. On dynamics analysis of a new chaotic attractor. Physics Letters A 372.36 (2008): 5773-5777..", + "correlation_dimension": 0.7715266839229182, + "delay": false, + "description": "A named attractor related to the DequanLi attractor", + "dt": 0.0007607, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -3.03805747, + -1.98052429, + 14.65665869 + ], + "kaplan_yorke_dimension": 2.0644468877116084, + "lyapunov_spectrum_estimated": [ + 0.8697394318152156, + 0.01603608355912526, + -13.744271396596757 + ], + "maximum_lyapunov_estimated": 0.6132378917107628, + "multiscale_entropy": 1.0993195372407014, + "nonautonomous": false, + "parameters": { + "a": 10, + "c": -2.6667, + "d": 0, + "eps": 0.0, + "f": 0, + "k": 16 + }, + "period": 1.7829, + "pesin_entropy": 0.885775515374341, + "unbounded_indices": [] + }, + "PehlivanWei": { + "bifurcation_parameter": null, + "citation": "Pehlivan, Ihsan, and Wei Zhouchao (2012). Analysis, nonlinear control, and chaos generator circuit of another strange chaotic system.", + "correlation_dimension": 1.7200323215068793, + "delay": false, + "description": "A system with quadratic nonlinearity, which undergoes Hopf bifurcations of codimension 1 and 2.", + "dt": 0.01299, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.21665608, + 0.86710502, + 0.50627859 + ], + "kaplan_yorke_dimension": 2.1563635563177295, + "lyapunov_spectrum_estimated": [ + 0.09512327528959069, + 0.0015323304198873254, + -0.6168618108533457 + ], + "maximum_lyapunov_estimated": 0.10415076085878888, + "multiscale_entropy": 0.6547493000137818, + "nonautonomous": false, + "parameters": {}, + "period": 3.7487330316742087, + "pesin_entropy": 0.09665562724246173, + "unbounded_indices": [] + }, + "PiecewiseCircuit": { + "bifurcation_parameter": null, + "citation": "A. Tamasevicius, G. Mykolaitis, S. Bumeliene, Electron. Lett. 42, 13 (2006)", + "correlation_dimension": 1.3715663776355644, + "delay": true, + "description": "A delay model that can be implemented as an electronic circuit. A standard delay dimension of three is used.", + "dt": 0.010386990384645287, + "embedding_dimension": 10, + "hamiltonian": false, + "initial_conditions": [ + -0.37155972, + -0.55024994, + -1.07760125, + -2.08210946, + -2.92172609, + 0.22026821, + 2.18909877, + 1.43553442, + 0.47734972, + 1.36510289 + ], + "kaplan_yorke_dimension": 9.098082330516, + "lyapunov_spectrum_estimated": [ + 0.014785562725300386, + 0.0, + -0.0009494552945453346, + -0.0010960656984337447, + -0.0012963705687896077, + -0.0015866293466630925, + -0.002045520992978931, + -0.0028829999154526267, + -0.004928520908431463, + -0.5553991058827761 + ], + "maximum_lyapunov_estimated": 0.036102233030474856, + "nonautonomous": false, + "parameters": { + "alpha": 1.0, + "beta": 1.0, + "c": 2.24, + "tau": 4.9 + }, + "period": 52.99484890125133, + "pesin_entropy": 0.014785562725300386, + "unbounded_indices": [] + }, + "Qi": { + "bifurcation_parameter": null, + "citation": "G. Qi, M. A. van Wyk, B. J. van Wyk, and G. Chen, (2008). On a new hyperchaotic system. Physics Letters A.", + "correlation_dimension": 1.8913519055600239, + "delay": false, + "description": "A hyperchaotic system with a wide power spectrum.", + "dt": 0.00069418, + "embedding_dimension": 4, + "hamiltonian": false, + "initial_conditions": [ + 0.2562042648386667, + 0.1956116640569919, + 7.259823760387948, + 1.3162558970131963 + ], + "kaplan_yorke_dimension": 2.498645226832379, + "lyapunov_spectrum_estimated": [ + 2.0360429519545677, + 0.1320125824983059, + -4.347891883424509, + -44.356041824978305 + ], + "maximum_lyapunov_estimated": 2.1916060472989556, + "multiscale_entropy": 0.8855652233700573, + "nonautonomous": false, + "parameters": { + "a": 45, + "b": 10, + "c": 1, + "d": 10 + }, + "period": 0.40820999999999996, + "pesin_entropy": 2.168055534452874, + "unbounded_indices": [] + }, + "QiChen": { + "bifurcation_parameter": null, + "citation": "Qi et al. Chaos, Solitons & Fractals 2008.", + "correlation_dimension": 1.830987290684598, + "delay": false, + "description": "A double-wing chaotic attractor that arises from two bistable attractors. The system has quadratic nonlinearity.", + "dt": 4.153e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 17.420882, + 5.5459627, + 78.89139 + ], + "kaplan_yorke_dimension": 2.0917466081236316, + "lyapunov_spectrum_estimated": [ + 3.8880075026301206, + 0.13379585631170307, + -43.8359895934497 + ], + "maximum_lyapunov_estimated": 4.0275703123027435, + "multiscale_entropy": 0.846453868214798, + "nonautonomous": false, + "parameters": { + "a": 38, + "b": 2.666, + "c": 80 + }, + "period": 0.39179, + "pesin_entropy": 4.021803358941824, + "unbounded_indices": [] + }, + "RabinovichFabrikant": { + "bifurcation_parameter": null, + "citation": "Rabinovich, Mikhail I.; Fabrikant, A. L. (1979). Stochastic Self-Modulation of Waves in Nonequilibrium Media. Sov. Phys. JETP.", + "correlation_dimension": 2.0781334886735414, + "delay": false, + "description": "A reduced-order model of propagating waves in monequilibrium media.", + "dt": 0.0005045, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.8207276, + 0.83440917, + 0.2078248 + ], + "kaplan_yorke_dimension": 2.36076141745315, + "lyapunov_spectrum_estimated": [ + 0.24233580922074083, + 1.7068504600119996e-05, + -0.6717710576786404 + ], + "maximum_lyapunov_estimated": 0.2541443669572464, + "multiscale_entropy": 0.9189339042839536, + "nonautonomous": false, + "parameters": { + "a": 1.1, + "g": 0.87 + }, + "period": 2.3356, + "pesin_entropy": 0.24239107527154555, + "unbounded_indices": [] + }, + "RayleighBenard": { + "bifurcation_parameter": null, + "citation": "Yanagita, Kaneko (1995). Rayleigh-B\u00e9nard convection patterns, chaos, spatiotemporal chaos and turbulence. Physica D: Nonlinear Phenomena 82.3 (1995): 288-313.", + "correlation_dimension": 1.9218207098924294, + "delay": false, + "description": "A reduced-order model of a convective cell.", + "dt": 0.0001122, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -15.660582, + -13.32018, + 26.879362 + ], + "kaplan_yorke_dimension": 2.1059475747031655, + "lyapunov_spectrum_estimated": [ + 1.7098267053321798, + 0.3076248958606731, + -19.04195798211122 + ], + "maximum_lyapunov_estimated": 1.8138795790741327, + "multiscale_entropy": 0.9190517908569512, + "nonautonomous": false, + "parameters": { + "a": 30, + "b": 5, + "r": 18 + }, + "period": 0.91967, + "pesin_entropy": 2.0174516011928527, + "unbounded_indices": [] + }, + "RikitakeDynamo": { + "bifurcation_parameter": null, + "citation": "Rikitake, T., Oscillations of a system of disk dynamos, Mathematical Proceedings of the Cambridge Philosophical Society, 1958.", + "correlation_dimension": 1.9056463792003642, + "delay": false, + "description": "Electric current and magnetic field of two coupled disk dynamos.", + "dt": 0.0007077, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.7791562791136255, + -0.6302244598741468, + 2.671200187214492 + ], + "kaplan_yorke_dimension": 2.0672834652602137, + "lyapunov_spectrum_estimated": [ + 0.14571192786308473, + 0.0007222098218782572, + -2.1743990404663296 + ], + "maximum_lyapunov_estimated": 0.1318127385277225, + "multiscale_entropy": 0.9664471212975273, + "nonautonomous": false, + "parameters": { + "a": 1.0, + "mu": 1.0 + }, + "period": 5.8975, + "pesin_entropy": 0.14655639292019562, + "unbounded_indices": [] + }, + "Rossler": { + "bifurcation_parameter": null, + "citation": "Rossler, O. E. (1976), An Equation for Continuous Chaos, Physics Letters, 57A (5): 3972013398,", + "correlation_dimension": 1.796820702938341, + "delay": false, + "description": "Spiral-type chaos in a simple oscillator model.", + "dt": 0.0007563, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 6.5134412, + 0.4772013, + 0.34164294 + ], + "kaplan_yorke_dimension": 2.0146095059018845, + "lyapunov_spectrum_estimated": [ + 0.0763301393780693, + 0.007522476799147231, + -5.741024338716747 + ], + "maximum_lyapunov_estimated": 0.15059688939547888, + "multiscale_entropy": 0.605878349292794, + "nonautonomous": false, + "parameters": { + "a": 0.2, + "b": 0.2, + "c": 5.7 + }, + "period": 5.9086, + "pesin_entropy": 0.08385261617721652, + "unbounded_indices": [] + }, + "Rucklidge": { + "bifurcation_parameter": null, + "citation": "Rucklidge, A.M. (1992). Chaos in models of double convection. Journal of Fluid Mechanics.", + "correlation_dimension": 1.9824460344125072, + "delay": false, + "description": "Two-dimensional convection in a horizontal layer of Boussinesq fluid with lateral constraints.", + "dt": 0.0007408, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.9257158, + 3.1923835, + 5.7829655 + ], + "kaplan_yorke_dimension": 2.055660980653234, + "lyapunov_spectrum_estimated": [ + 0.18286378999435815, + -0.0039065765687848, + -3.2151284307504713 + ], + "maximum_lyapunov_estimated": 0.1936356650629198, + "multiscale_entropy": 0.6441822675461503, + "nonautonomous": false, + "parameters": { + "a": 2.0, + "b": 6.7 + }, + "period": 6.0721, + "pesin_entropy": 0.18286397807774446, + "unbounded_indices": [] + }, + "Sakarya": { + "bifurcation_parameter": null, + "citation": "Li, Chunbiao, et al (2015). A novel four-wing strange attractor born in bistability. IEICE Electronics Express 12.4.", + "correlation_dimension": 2.055704010721625, + "delay": false, + "description": "An attractor that arises due to merging of two disjoint bistable attractors.", + "dt": 0.0004486, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -2.8976045, + 3.8877978, + 3.07465 + ], + "kaplan_yorke_dimension": 2.245095314885476, + "lyapunov_spectrum_estimated": [ + 0.3080921246264039, + 0.00035292037656675234, + -1.2584697568737606 + ], + "maximum_lyapunov_estimated": 0.26501036485491514, + "multiscale_entropy": 0.6082767822064958, + "nonautonomous": false, + "parameters": { + "a": -1.0, + "b": 1.0, + "c": 1.0, + "h": 1.0, + "p": 1.0, + "q": 0.4, + "r": 0.3, + "s": 1.0 + }, + "period": 4.9844, + "pesin_entropy": 0.3084450450029706, + "unbounded_indices": [] + }, + "SaltonSea": { + "bifurcation_parameter": null, + "citation": "Upadhyay, Bairagi, Kundu, Chattopadhyay (2007).Chaos in eco-epidemiological problem of the Salton Sea and its possible control. Applied mathematics and computation.", + "correlation_dimension": 1.699295461860061, + "delay": false, + "description": "An eco-epidemiological model of bird and fish abundances in the Salton sea of southern California.", + "dt": 0.0002728, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 231.92548, + 89.511944, + 56.753804 + ], + "kaplan_yorke_dimension": 2.0843843542474496, + "lyapunov_spectrum_estimated": [ + 0.3914445015077359, + -0.0037578848522063194, + -4.592867667006148 + ], + "maximum_lyapunov_estimated": 1.0702552017260383, + "multiscale_entropy": 0.9335269725171643, + "nonautonomous": false, + "parameters": { + "a": 15, + "d": 8.3, + "k": 400, + "lam": 0.06, + "m": 15.5, + "mu": 3.4, + "r": 22, + "th": 10.0 + }, + "period": 0.96738, + "pesin_entropy": 0.39160860195935765, + "unbounded_indices": [] + }, + "SanUmSrisuchinwong": { + "bifurcation_parameter": null, + "citation": "San-Um, Srisuchinwong. J. Comp 2012", + "correlation_dimension": 2.067524991580239, + "delay": false, + "description": "A two-scroll attractor arising from dynamical equations with piecewise nonlinearities. Equivalent to the Wimol-Banlue system", + "dt": 0.001941, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.63878078, + 1.0901873, + 2.4479814 + ], + "kaplan_yorke_dimension": 2.194219372064799, + "lyapunov_spectrum_estimated": [ + 0.23913890446639047, + -0.0002916165416126154, + -1.2296759041605134 + ], + "maximum_lyapunov_estimated": 0.2606135207962152, + "multiscale_entropy": 0.9947542017597873, + "nonautonomous": false, + "parameters": { + "a": 2 + }, + "period": 7.4654, + "pesin_entropy": 0.23946267672516214, + "unbounded_indices": [] + }, + "ScrollDelay": { + "bifurcation_parameter": null, + "citation": "R.D. Driver, Ordinary and Delay Differential Equations (Springer, New York, 1977).", + "correlation_dimension": 1.6731262397195827, + "delay": true, + "description": "A delay model that can be implemented as an electronic circuit. A standard delay dimension of three is used.", + "dt": 0.028957332188474537, + "embedding_dimension": 10, + "hamiltonian": false, + "initial_conditions": [ + -0.70009241, + -0.1619611, + -1.3858096, + -2.00973849, + -0.3170297, + 0.33881451, + 0.97378904, + 1.95957145, + 0.89772925, + -0.340544 + ], + "kaplan_yorke_dimension": 6.359079465434583, + "lyapunov_spectrum_estimated": [ + 0.016452858090143806, + 0.0, + -0.002980358467759353, + -0.0033440357003520953, + -0.003808966070507634, + -0.004424379846505175, + -0.005277712003736954, + -0.0065407988372825875, + -0.008605197946011937, + -0.012607310979495853 + ], + "maximum_lyapunov_estimated": 0.024859095331628417, + "nonautonomous": false, + "parameters": { + "alpha": 0.2, + "beta": 0.2, + "tau": 10.0 + }, + "period": 152.40701151828662, + "pesin_entropy": 0.016452858090143806, + "unbounded_indices": [] + }, + "ShimizuMorioka": { + "bifurcation_parameter": null, + "citation": "Shimizu, Morioka. Phys Lett A. 1980: 201-204", + "correlation_dimension": 1.7168454070369197, + "delay": false, + "description": "A system that bifurcates from a symmetric limit cycle to an asymmetric one, similar to the Lorenz attractor.", + "dt": 0.002215, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.016838697, + 0.03489384, + 0.35346848 + ], + "kaplan_yorke_dimension": 2.0312187919639926, + "lyapunov_spectrum_estimated": [ + 0.044032234819090736, + -1.3942528300804223e-05, + -1.409991553164768 + ], + "maximum_lyapunov_estimated": 0.03577425334463406, + "multiscale_entropy": 0.7156563118943259, + "nonautonomous": false, + "parameters": { + "a": 0.85, + "b": 0.5 + }, + "period": 12.038, + "pesin_entropy": 0.044239420179671494, + "unbounded_indices": [] + }, + "SprottA": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.9642234277909487, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.01299, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.54131864, + 1.43079727, + -1.52555412 + ], + "kaplan_yorke_dimension": 60.66528307527488, + "lyapunov_spectrum_estimated": [ + 0.029259920155059096, + 0.004990159457687409, + -0.0015561317158397701 + ], + "maximum_lyapunov_estimated": 0.012993052652429771, + "multiscale_entropy": 0.5748267225365974, + "nonautonomous": false, + "parameters": {}, + "period": 6.3728461538461545, + "pesin_entropy": 0.0343008088722448, + "unbounded_indices": [] + }, + "SprottB": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.9347401711496346, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.0008119, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.6878282, + 1.4848132, + -0.53706628 + ], + "kaplan_yorke_dimension": 2.1852994894688953, + "lyapunov_spectrum_estimated": [ + 0.21987503866971636, + 0.005187437926969091, + -1.2145826242115807 + ], + "maximum_lyapunov_estimated": 0.20674275256006883, + "multiscale_entropy": 0.8826029903839796, + "nonautonomous": false, + "parameters": {}, + "period": 11.050142857142857, + "pesin_entropy": 0.2250624765966855, + "unbounded_indices": [] + }, + "SprottC": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.903676120558973, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001084, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.47199823, + -0.27198066, + 1.9418244 + ], + "kaplan_yorke_dimension": 2.1529236029587073, + "lyapunov_spectrum_estimated": [ + 0.17898394736414464, + -0.0007304674803429964, + -1.1644550651924115 + ], + "maximum_lyapunov_estimated": 0.15806924766944033, + "multiscale_entropy": 1.14839462464542, + "nonautonomous": false, + "parameters": {}, + "period": 8.8852, + "pesin_entropy": 0.17933456833596748, + "unbounded_indices": [] + }, + "SprottD": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.950013918317399, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001769, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.3396906, + -0.21238338, + 0.32982163 + ], + "kaplan_yorke_dimension": 2.0807565309303526, + "lyapunov_spectrum_estimated": [ + 0.11415315682442645, + 0.001787998513315278, + -1.4601870646976078 + ], + "maximum_lyapunov_estimated": 0.10170941886932346, + "multiscale_entropy": 1.0030259093693934, + "nonautonomous": false, + "parameters": {}, + "period": 4.8333, + "pesin_entropy": 0.11594526886491094, + "unbounded_indices": [] + }, + "SprottDelay": { + "bifurcation_parameter": null, + "citation": "Sprott, J. C (2007). A simple chaotic delay differential equation. Physics Letters A 366.4-5: 397-402.", + "correlation_dimension": 1.6845848125572829, + "delay": true, + "description": "An algebraically simple delay equation. A standard delay dimension of three is used.", + "dt": 0.001875, + "embedding_dimension": 10, + "hamiltonian": false, + "initial_conditions": [ + 9.30770542, + 12.7465327, + 9.98335715, + 7.33212279, + 8.554363, + 11.19207081, + 10.35063786, + 6.07706904, + 8.05360832, + 8.98894939 + ], + "kaplan_yorke_dimension": 18.013378102775214, + "lyapunov_spectrum_estimated": [ + 0.2056760250875861, + 0.0, + -0.008870752665977713, + -0.009336907144022626, + -0.009854805468436065, + -0.010433576101488581, + -0.011084630775277052, + -0.0118224267121919, + -0.012665556385738196, + -0.014601336849935557 + ], + "maximum_lyapunov_estimated": 0.0794701998101797, + "nonautonomous": false, + "parameters": { + "c": 0.0, + "mu": 1.0, + "tau": 5.1, + "x0": 0.0 + }, + "period": 14.15628, + "pesin_entropy": 0.2056760250875861, + "unbounded_indices": [] + }, + "SprottE": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.5319512189227282, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.0008543, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.6173759, + 0.66599285, + -1.6575023 + ], + "kaplan_yorke_dimension": 2.0894640654250147, + "lyapunov_spectrum_estimated": [ + 0.09834470642927143, + -0.00031069798260046597, + -1.0953799295090543 + ], + "maximum_lyapunov_estimated": 0.09016067590084897, + "multiscale_entropy": 0.8387888716672988, + "nonautonomous": false, + "parameters": {}, + "period": 7.6275, + "pesin_entropy": 0.09866310814686535, + "unbounded_indices": [] + }, + "SprottF": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 2.248574151957115, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001655, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.98941275, + -1.4191706, + 0.85797204 + ], + "kaplan_yorke_dimension": 2.2516153966506316, + "lyapunov_spectrum_estimated": [ + 0.13246006583273318, + 0.0192716855937824, + -0.603011686855317 + ], + "maximum_lyapunov_estimated": 0.1183090101484132, + "multiscale_entropy": 0.7674306147320477, + "nonautonomous": false, + "parameters": { + "a": 0.5 + }, + "period": 19.244, + "pesin_entropy": 0.1517317514265156, + "unbounded_indices": [] + }, + "SprottG": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.4356008167477212, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.00216, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.77182478, + -0.74756595, + 1.3073285 + ], + "kaplan_yorke_dimension": 2.0519020031307744, + "lyapunov_spectrum_estimated": [ + 0.03349131570257798, + -0.0012749369106980868, + -0.6182204265060449 + ], + "maximum_lyapunov_estimated": 0.09067832253388744, + "multiscale_entropy": 0.6185493944257671, + "nonautonomous": false, + "parameters": { + "a": 0.4 + }, + "period": 8.7097, + "pesin_entropy": 0.03403484153064641, + "unbounded_indices": [] + }, + "SprottH": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 2.1841850324956043, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001416, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.360042, + 0.62585352, + -1.2788196 + ], + "kaplan_yorke_dimension": 2.2414973487697853, + "lyapunov_spectrum_estimated": [ + 0.13871794302385684, + 0.003501431527456669, + -0.5889065665901029 + ], + "maximum_lyapunov_estimated": 0.13100182470690253, + "multiscale_entropy": 0.6325364503922819, + "nonautonomous": false, + "parameters": { + "a": 0.5 + }, + "period": 20.229, + "pesin_entropy": 0.14221937455131348, + "unbounded_indices": [] + }, + "SprottI": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.5880853049819768, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.003104, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.060099389, + -0.49558355, + 0.023159035 + ], + "kaplan_yorke_dimension": 2.019844528960972, + "lyapunov_spectrum_estimated": [ + 0.020459651934364873, + 9.478591964272237e-06, + -1.031514712617076 + ], + "maximum_lyapunov_estimated": 0.023218704376506836, + "multiscale_entropy": 0.5893805046352655, + "nonautonomous": false, + "parameters": { + "a": 0.2 + }, + "period": 10.93, + "pesin_entropy": 0.02077411702709478, + "unbounded_indices": [] + }, + "SprottJ": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.7631890086601887, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001209, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 4.4786928, + 2.2977432, + 6.5847115 + ], + "kaplan_yorke_dimension": 2.0221468017281006, + "lyapunov_spectrum_estimated": [ + 0.04451808076432957, + 0.0010621228852282804, + -2.055842238064512 + ], + "maximum_lyapunov_estimated": 0.12290789099642041, + "multiscale_entropy": 0.6352974298685767, + "nonautonomous": false, + "parameters": {}, + "period": 4.836, + "pesin_entropy": 0.04588958821017871, + "unbounded_indices": [] + }, + "SprottJerk": { + "bifurcation_parameter": null, + "citation": "Sprott, J. C. Simplest dissipative chaotic flow. Physics Letters A (1997).", + "correlation_dimension": 1.1444423838257205, + "delay": false, + "description": "An algebraidally simple flow depending on a third time derivative. Numerical integration of this attractor is extremely sensitive to the initial conditions", + "dt": 0.002408, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.54106056, + 0.59383201, + 0.45127217 + ], + "kaplan_yorke_dimension": 2.031190248069004, + "lyapunov_spectrum_estimated": [ + 0.06738258231535933, + -0.0007831911114099333, + -2.1347047232043663 + ], + "maximum_lyapunov_estimated": 0.08785190282162628, + "multiscale_entropy": 0.5314887786603959, + "nonautonomous": false, + "parameters": { + "mu": 2.017 + }, + "period": 11.921, + "pesin_entropy": 0.06776939078007471, + "unbounded_indices": [] + }, + "SprottK": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.817781482577807, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001177, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.3165015, + -1.5429951, + 0.664053 + ], + "kaplan_yorke_dimension": 2.0417036451446204, + "lyapunov_spectrum_estimated": [ + 0.03778259119323125, + -0.0005109461395399151, + -0.8934722146671759 + ], + "maximum_lyapunov_estimated": 0.05962593786799159, + "multiscale_entropy": 0.6562812206790845, + "nonautonomous": false, + "parameters": { + "a": 0.3 + }, + "period": 7.006, + "pesin_entropy": 0.03788160511007809, + "unbounded_indices": [] + }, + "SprottL": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.410583582611956, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.0008475, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 4.3611557, + 13.705573, + -2.6835659 + ], + "kaplan_yorke_dimension": 2.0329815956000377, + "lyapunov_spectrum_estimated": [ + 0.03407149258791976, + -0.000391471796353918, + -1.012962157697122 + ], + "maximum_lyapunov_estimated": 0.09216197583296963, + "multiscale_entropy": 0.5605870039438788, + "nonautonomous": false, + "parameters": { + "a": 0.9, + "b": 3.9 + }, + "period": 6.7262, + "pesin_entropy": 0.0343958205328805, + "unbounded_indices": [] + }, + "SprottM": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.5501956414464297, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.002017, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.6024402, + -1.5983203, + -2.6236374 + ], + "kaplan_yorke_dimension": 2.04996202872584, + "lyapunov_spectrum_estimated": [ + 0.05230117379497565, + -0.00033063791832836577, + -1.0391447706177515 + ], + "maximum_lyapunov_estimated": 0.08422043130700084, + "multiscale_entropy": 0.7481178461456197, + "nonautonomous": false, + "parameters": { + "a": 1.7 + }, + "period": 5.3644, + "pesin_entropy": 0.05234518101225785, + "unbounded_indices": [] + }, + "SprottMore": { + "bifurcation_parameter": null, + "citation": "Sprott, J. C. (2020). Do We Need More Chaos Examples? Chaos Theory and Applications 2(2),1-3, 2020.", + "correlation_dimension": 2.234865750080784, + "delay": false, + "description": "A multifractal system with a nearly 3D attractor", + "dt": 0.001769, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.3396906, + -0.21238338, + 0.32982163 + ], + "kaplan_yorke_dimension": 2.999952495039482, + "lyapunov_spectrum_estimated": [ + 0.32499834596046606, + -0.0001641583999746131, + -0.31918544080126926 + ], + "maximum_lyapunov_estimated": 1.0946909441433958, + "multiscale_entropy": 0.6370154977546665, + "nonautonomous": false, + "parameters": {}, + "period": 6.62095890410959, + "pesin_entropy": 0.32515558132375566, + "unbounded_indices": [] + }, + "SprottN": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.7798181024992923, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001213, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -8.3258705, + 7.3033716, + 3.2798909 + ], + "kaplan_yorke_dimension": 2.028951405806632, + "lyapunov_spectrum_estimated": [ + 0.06095861449194353, + 6.560209716837452e-05, + -2.101648044064128 + ], + "maximum_lyapunov_estimated": 0.11869612209728901, + "multiscale_entropy": 0.6385218945868028, + "nonautonomous": false, + "parameters": {}, + "period": 4.8135, + "pesin_entropy": 0.061478272616693266, + "unbounded_indices": [] + }, + "SprottO": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.710108209511237, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001951, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.20549455, + 0.022792985, + 0.93636949 + ], + "kaplan_yorke_dimension": 2.2474645346215256, + "lyapunov_spectrum_estimated": [ + 0.06685684927644238, + 0.011533284505120292, + -0.3165440349833235 + ], + "maximum_lyapunov_estimated": 0.09141077854590315, + "multiscale_entropy": 0.4161154943097029, + "nonautonomous": false, + "parameters": { + "a": 2.7 + }, + "period": 9.755, + "pesin_entropy": 0.07839013378156268, + "unbounded_indices": [] + }, + "SprottP": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.9850786402587843, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001549, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.83420675, + 0.14915817, + 0.44028635 + ], + "kaplan_yorke_dimension": 2.2122245136720187, + "lyapunov_spectrum_estimated": [ + 0.1026165705645786, + 0.00025136328640969387, + -0.4843551814513015 + ], + "maximum_lyapunov_estimated": 0.1064676723437159, + "multiscale_entropy": 0.8486396469370624, + "nonautonomous": false, + "parameters": { + "a": 2.7 + }, + "period": 5.3414, + "pesin_entropy": 0.10329419803150507, + "unbounded_indices": [] + }, + "SprottQ": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.831711145721785, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001618, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 2.978102, + -0.065260683, + -2.8031286 + ], + "kaplan_yorke_dimension": 2.2246852931286063, + "lyapunov_spectrum_estimated": [ + 0.13698250147166127, + 0.0010386716745898255, + -0.6140516336902575 + ], + "maximum_lyapunov_estimated": 0.17169784338063596, + "multiscale_entropy": 0.8105158145249107, + "nonautonomous": false, + "parameters": { + "a": 3.1, + "b": 0.5 + }, + "period": 4.8443, + "pesin_entropy": 0.13852213114060488, + "unbounded_indices": [] + }, + "SprottR": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.831336989240481, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.001585, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -1.6914909, + -1.9783678, + 1.9807775 + ], + "kaplan_yorke_dimension": 2.071744469374985, + "lyapunov_spectrum_estimated": [ + 0.07608481335025485, + 0.0013697096816499383, + -1.0784000269941107 + ], + "maximum_lyapunov_estimated": 0.09661415277799693, + "multiscale_entropy": 0.5877166245477188, + "nonautonomous": false, + "parameters": { + "a": 0.9, + "b": 0.4 + }, + "period": 7.0133, + "pesin_entropy": 0.07840404228136309, + "unbounded_indices": [] + }, + "SprottS": { + "bifurcation_parameter": null, + "citation": "Sprott (1994). Some simple chaotic flows. Physical Review E (1994).", + "correlation_dimension": 1.909825606415139, + "delay": false, + "description": "A member of the Sprott family of algebraically-simple chaotic sytems.", + "dt": 0.0013, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.12635702, + 0.12260693, + 1.2215429 + ], + "kaplan_yorke_dimension": 2.182390107009358, + "lyapunov_spectrum_estimated": [ + 0.2149312025337423, + 0.0030194370306177213, + -1.1945344436340624 + ], + "maximum_lyapunov_estimated": 0.2737629235389973, + "multiscale_entropy": 0.6690400524585065, + "nonautonomous": false, + "parameters": {}, + "period": 3.3505, + "pesin_entropy": 0.21876911249150574, + "unbounded_indices": [] + }, + "SprottTorus": { + "bifurcation_parameter": null, + "citation": "Sprott Physics Letters A 2014", + "correlation_dimension": 1.0564310259305965, + "delay": false, + "description": "A multiattractor system that goes to a torus or a complex attractor depending on the initial conditions.", + "dt": 0.0006259, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.6883476, + -0.18017646, + 0.58539724 + ], + "kaplan_yorke_dimension": 2.759693065535405, + "lyapunov_spectrum_estimated": [ + 0.29656066211909027, + 0.0005468818242604863, + -0.3910853761095065 + ], + "maximum_lyapunov_estimated": 0.1056964344650892, + "multiscale_entropy": 0.9562901894463037, + "nonautonomous": false, + "parameters": {}, + "period": 13.607, + "pesin_entropy": 0.29710937347161515, + "unbounded_indices": [] + }, + "StickSlipOscillator": { + "bifurcation_parameter": null, + "citation": "Awrejcewicz, Jan, and M. M. Holicke (1999). Int J of Bifurcation and Chaos.", + "correlation_dimension": 1.7159805502964127, + "delay": false, + "description": "A weakly forced (quasiautonomous) oscillator with dynamics similar to stick-slip friction. The parameter gamma controls the transition to chaos.", + "dt": 0.0001, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.85539847, + -0.39125834, + 0 + ], + "kaplan_yorke_dimension": 5.682155291949877, + "lyapunov_spectrum_estimated": [ + 0.07073329226101453, + 3.356854711815694e-05, + -0.02131392884593247 + ], + "maximum_lyapunov_estimated": 0.06406131604734494, + "multiscale_entropy": 0.9213029740441252, + "nonautonomous": true, + "parameters": { + "a": 1, + "alpha": 0.3, + "b": 1, + "beta": 0.3, + "eps": 0.05, + "gamma": 1.0, + "t0": 0.3, + "vs": 0.4, + "w": 2 + }, + "period": 1.6129, + "pesin_entropy": 0.07108101456222432, + "unbounded_indices": [ + 2 + ] + }, + "SwingingAtwood": { + "bifurcation_parameter": null, + "citation": "Tufillaro, Nicholas B.; Abbott, Tyler A.; Griffiths, David J. (1984). Swinging Atwood's Machine. American Journal of Physics. 52 (10): 895--903.", + "correlation_dimension": 1.8299454879703774, + "delay": false, + "description": "A mechanical system consisting of two swinging weights connected by ropes and pulleys. This is only chaotic when m2 is sufficiently larger than m1, and there are nonzero initial momenta", + "dt": 0.00010288, + "embedding_dimension": 4, + "hamiltonian": true, + "initial_conditions": [ + 0.113296, + 1.5707963267948966, + 0.10992, + 0.17747 + ], + "kaplan_yorke_dimension": 4.0198847313975445, + "lyapunov_spectrum_estimated": [ + 7.735006558021491, + 3.0380875684439133, + -3.002075505122432, + -7.664246463289054 + ], + "maximum_lyapunov_estimated": 1.0111284961954359, + "nonautonomous": false, + "parameters": { + "m1": 1.0, + "m2": 4.5 + }, + "period": 0.3417647058823529, + "pesin_entropy": 10.773094126465404, + "unbounded_indices": [] + }, + "Thomas": { + "bifurcation_parameter": null, + "citation": "Thomas, Rene (1999). Deterministic chaos seen in terms of feedback circuits: Analysis, synthesis, labyrinth chaos. Int. J. Bifurc. Chaos.", + "correlation_dimension": 1.6488268116215494, + "delay": false, + "description": "A cyclically-symmetric attractor correspondng to a frictionally-damped particle traversing a 3D lattice of forces", + "dt": 0.0002882, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 2.199442, + 2.3634225, + 3.220197 + ], + "kaplan_yorke_dimension": 2.1271136075295507, + "lyapunov_spectrum_estimated": [ + 0.7589685797630259, + 0.057355308262307496, + -6.421950974462397 + ], + "maximum_lyapunov_estimated": 0.6324054000339867, + "multiscale_entropy": 0.9921951854111759, + "nonautonomous": false, + "parameters": { + "a": 1.85, + "b": 10 + }, + "period": 4.969, + "pesin_entropy": 0.8163238880253334, + "unbounded_indices": [] + }, + "ThomasLabyrinth": { + "bifurcation_parameter": null, + "citation": "Thomas, Rene. Deterministic chaos seen in terms of feedback circuits: Analysis, synthesis, labyrinth chaos. Int. J. Bifurc. Chaos. (1999).", + "correlation_dimension": 2.150032278884401, + "delay": false, + "description": "A system in which trajectories seemingly undergo Brownian motion on an infinite lattice, but remain bounded when the parameter a is less than one.", + "dt": 0.0003509, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -4.9599545, + 1.0302034, + -4.6883893 + ], + "kaplan_yorke_dimension": 2.4720317677959973, + "lyapunov_spectrum_estimated": [ + 1.338784931894327, + 0.004970451463443095, + -2.8467429841890293 + ], + "maximum_lyapunov_estimated": 1.390858033637042, + "multiscale_entropy": 1.3049872431864915, + "nonautonomous": false, + "parameters": { + "a": 0.5, + "b": 10 + }, + "period": 6.05, + "pesin_entropy": 1.3437553833577704, + "unbounded_indices": [] + }, + "Torus": { + "bifurcation_parameter": null, + "citation": "See, for example, Strogatz (1994). Nonlinear Dynamics and Chaos.", + "correlation_dimension": 1.0422059009112339, + "delay": false, + "description": "A minimal quasiperiodic flow on a torus. All lyapunov exponents and related quantities are zero", + "dt": 0.0003816, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -13.72884, + 1.9094726, + 0.72831447 + ], + "kaplan_yorke_dimension": 2.0, + "lyapunov_spectrum_estimated": [ + 0.0, + 0.0, + 0.0 + ], + "maximum_lyapunov_estimated": 0.00817284128815307, + "multiscale_entropy": 0.47330913201518593, + "nonautonomous": false, + "parameters": { + "a": 0.5, + "n": 15.3, + "r": 1 + }, + "period": 6.36, + "pesin_entropy": 0.0, + "unbounded_indices": [] + }, + "Tsucs2": { + "bifurcation_parameter": null, + "citation": "Pan, Zhou, Li (2013). Synchronization of Three-Scroll Unified Chaotic System (TSUCS) and its hyper-chaotic system using active pinning control", + "correlation_dimension": 1.4738205303007272, + "delay": false, + "description": "A named attractor related to the DequanLi attractor", + "dt": 3.936e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 1.2969944, + 1.12138, + 50.028988 + ], + "kaplan_yorke_dimension": 2.315349160163322, + "lyapunov_spectrum_estimated": [ + 0.6414001783252772, + -0.22409536897391863, + -1.3233103558456687 + ], + "maximum_lyapunov_estimated": 0.13621488344499086, + "multiscale_entropy": 0.3913632586715302, + "nonautonomous": false, + "parameters": { + "a": 40, + "c": 0.833, + "d": 0.5, + "eps": 0.65, + "f": 20, + "k": 0 + }, + "period": 0.34526, + "pesin_entropy": 0.6414001783252772, + "unbounded_indices": [] + }, + "TurchinHanski": { + "bifurcation_parameter": null, + "citation": "Turchin, Hanski. The American Naturalist 1997. Turchin, Hanski. Ecology 2000", + "correlation_dimension": 1.6209562623031344, + "delay": false, + "description": " A chaotic three species food web. The species growth rate has been increased from the default parameters in the original paper, in order to ensure that the system exhibits sustained chaotic oscillations.", + "dt": 0.0004074, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.018027788, + 0.013649976, + 30363.85 + ], + "kaplan_yorke_dimension": 1.2053069221786739, + "lyapunov_spectrum_estimated": [ + 0.03719830596656144, + -0.181183885924572, + -2.522759887828014 + ], + "maximum_lyapunov_estimated": 0.12906862565697674, + "multiscale_entropy": 0.4989636261373046, + "nonautonomous": true, + "parameters": { + "a": 8, + "d": 0.04, + "e": 0.5, + "g": 0.1, + "h": 0.8, + "r": 8.12, + "s": 1.25 + }, + "period": 4.40529411764706, + "pesin_entropy": 0.03719830596656144, + "unbounded_indices": [ + 2 + ] + }, + "VallisElNino": { + "bifurcation_parameter": null, + "citation": "Vallis GK. Conceptual models of El Nio and the southern oscillation. J Geophys Res 1988", + "correlation_dimension": 1.3112426349362432, + "delay": false, + "description": "Atmospheric temperature fluctuations with annual forcing.", + "dt": 0.0003048, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -6.99286331487343, + 0.023254276622294345, + -0.1658177563067799 + ], + "kaplan_yorke_dimension": 2.1205065379188333, + "lyapunov_spectrum_estimated": [ + 0.6561566154431996, + 0.022689184568283626, + -5.6332694618503885 + ], + "maximum_lyapunov_estimated": 0.5477586276153029, + "multiscale_entropy": 0.9058707360850027, + "nonautonomous": false, + "parameters": { + "b": 102, + "c": 3, + "p": 0 + }, + "period": 2.2087, + "pesin_entropy": 0.6788458000114831, + "unbounded_indices": [] + }, + "VossDelay": { + "bifurcation_parameter": null, + "citation": "Voss (2002). Real-time anticipation of chaotic states of an electronic circuit.", + "correlation_dimension": 0.3215769338785323, + "delay": true, + "description": "An electronic circuit with delayed feedback. A standard delay dimension of three is used.", + "dt": 0.005208196388368833, + "embedding_dimension": 10, + "hamiltonian": false, + "initial_conditions": [ + 0.24640194, + 0.02997028, + 0.02899997, + 0.07092207, + 0.29465271, + -0.46294535, + 0.27610925, + -0.52696993, + 0.19878552, + -0.23221942 + ], + "kaplan_yorke_dimension": 8.13505137593863, + "lyapunov_spectrum_estimated": [ + 0.029847825391001673, + 0.01075313048222275, + -0.0036634126920025815, + -0.004229099583734764, + -0.005001963149328523, + -0.006121908129323136, + -0.007892512275762806, + -0.011123871278670669, + -0.019016383554425968, + -9.625045518169777 + ], + "maximum_lyapunov_estimated": 0.017260872874199203, + "nonautonomous": false, + "parameters": { + "alpha": 3.24, + "tau": 13.28 + }, + "period": 26.57243055290214, + "pesin_entropy": 0.040600955873224424, + "unbounded_indices": [] + }, + "WangSun": { + "bifurcation_parameter": null, + "citation": "Wang, Z., Sun, Y., van Wyk, B. J., Qi, G. & van Wyk, M. A (2009). A 3-D four-wing attractor and its analysis. Brazilian J. Phys. 39.", + "correlation_dimension": 1.7810104871604908, + "delay": false, + "description": "A four-scroll attractor", + "dt": 0.001294, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.54770787, + 0.73876479, + -0.0049284531 + ], + "kaplan_yorke_dimension": 2.0595560098996604, + "lyapunov_spectrum_estimated": [ + 0.07990874520682271, + -0.001043918775422804, + -1.3240808432405 + ], + "maximum_lyapunov_estimated": 0.06735463002480017, + "multiscale_entropy": 0.9045422097501858, + "nonautonomous": false, + "parameters": { + "a": 0.2, + "b": -0.01, + "d": -0.4, + "e": -1.0, + "f": -1.0, + "q": 1.0 + }, + "period": 26.958, + "pesin_entropy": 0.07994326076367073, + "unbounded_indices": [] + }, + "WindmiReduced": { + "bifurcation_parameter": null, + "citation": "Smith, Thiffeault, Horton. J Geophys Res. 2000. Horton, Weigel, Sprott. Chaos 2001.", + "correlation_dimension": 0.9743571353772181, + "delay": false, + "description": "Energy transfer into the ionosphere and magnetosphere by the solar wind. The parameter vsw controls the onset of chaos.", + "dt": 0.000944, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.93337506, + 6.2678923, + 41.969547 + ], + "kaplan_yorke_dimension": 2.0947817139683895, + "lyapunov_spectrum_estimated": [ + 0.15595238514031914, + 9.695760899839663e-05, + -1.6450480911820564 + ], + "maximum_lyapunov_estimated": 0.403521000622694, + "multiscale_entropy": 0.5896070173085494, + "nonautonomous": false, + "parameters": { + "a1": 0.247, + "b1": 10.8, + "b2": 0.0752, + "b3": 1.06, + "d1": 2200, + "vsw": 5 + }, + "period": 4.6733, + "pesin_entropy": 0.15635149449218705, + "unbounded_indices": [] + }, + "YuWang": { + "bifurcation_parameter": null, + "citation": "Yu, Wang (2012). A novel three dimension autonomous chaotic system with a quadratic exponential nonlinear term. Eng Techn & Applied Science Research.", + "correlation_dimension": 1.8558772226523095, + "delay": false, + "description": "A temperature-compensation circuit with an operational amplifier", + "dt": 9.089e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.21422356, + -0.17935495, + 14.105516 + ], + "kaplan_yorke_dimension": 2.1703721122420614, + "lyapunov_spectrum_estimated": [ + 2.459880656234634, + -0.07297917814211805, + -14.00993065520751 + ], + "maximum_lyapunov_estimated": 1.8525516537708415, + "multiscale_entropy": 0.6340382196367295, + "nonautonomous": false, + "parameters": { + "a": 10, + "b": 40, + "c": 2, + "d": 2.5 + }, + "period": 1.3366, + "pesin_entropy": 2.459880656234634, + "unbounded_indices": [] + }, + "YuWang2": { + "bifurcation_parameter": null, + "citation": "Yu, Wang (2012). A novel three dimension autonomous chaotic system with a quadratic exponential nonlinear term. Eng Techn & Applied Science Research.", + "correlation_dimension": 1.5232465346725725, + "delay": false, + "description": "An alternative temperature-compensation circuit with an operational amplifier", + "dt": 0.0001068, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + 0.12581483, + 1.2467348, + 18.358568 + ], + "kaplan_yorke_dimension": 2.0619881661890873, + "lyapunov_spectrum_estimated": [ + 0.802715215563475, + 0.007966964664720393, + -13.078014115524866 + ], + "maximum_lyapunov_estimated": 1.1576066800869989, + "multiscale_entropy": 0.9335570471768684, + "nonautonomous": false, + "parameters": { + "a": 10, + "b": 30, + "c": 2, + "d": 2.5 + }, + "period": 0.39265, + "pesin_entropy": 0.8106827804626555, + "unbounded_indices": [] + }, + "ZhouChen": { + "bifurcation_parameter": null, + "citation": "Zhou, Chen (2004). A simple smooth chaotic system with a 3-layer attractor. Int J Bifurcat Chaos, 2004", + "correlation_dimension": 1.6212203970681585, + "delay": false, + "description": "A feedback circuit model.", + "dt": 4.901e-05, + "embedding_dimension": 3, + "hamiltonian": false, + "initial_conditions": [ + -0.60390203, + 0.012111953, + 0.00083277923 + ], + "kaplan_yorke_dimension": 2.045920730005392, + "lyapunov_spectrum_estimated": [ + 0.5917259125455694, + 0.005203946388490041, + -12.999237688229242 + ], + "maximum_lyapunov_estimated": 0.6828000288089435, + "multiscale_entropy": 0.7337896982114851, + "nonautonomous": false, + "parameters": { + "a": 2.97, + "b": 0.15, + "c": -3.0, + "d": 1, + "e": -8.78 + }, + "period": 0.87518, + "pesin_entropy": 0.5969734164748293, + "unbounded_indices": [] + } +} diff --git a/test/runtests.jl b/test/runtests.jl index 24ec520..447a6dc 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,6 +1,6 @@ -using Dysts +using ChaoticDynamicalSystemLibrary using Test -@testset "Dysts.jl" begin +@testset "ChaoticDynamicalSystemLibrary.jl" begin # Write your tests here. end