diff --git a/Project.toml b/Project.toml index 4e0b4a5..74f0cd2 100644 --- a/Project.toml +++ b/Project.toml @@ -3,6 +3,13 @@ uuid = "55704126-756f-498a-a54f-434b72ecbddd" authors = ["Nathanael Bosch and contributors"] version = "1.0.0-DEV" +[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..7f10f8f 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,52 @@ -# Dysts +# Dysts.jl: A Julia Port of [`dysts`](https://github.com/williamgilpin/dysts) [![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) + +## Overview + +Dysts.jl is a Julia port of the "dysts" package originally developed by William Gilpin. The original code is publicly available under the Apache-2.0 license, and we extend our gratitude to William for his contribution to the project. This port was made possible by leveraging the power of GitHub Copilot for code generation, as well as incorporating helpful Emacs/Vim macros. + +## Acknowledgments + +- William Gilpin: The original author of the "dysts" package. We stand on the shoulders of his work, and much credit goes to him for creating the foundation. +- GitHub Copilot: The AI-powered coding assistant that played a significant role in accelerating the porting process. It's an invaluable tool for collaborative and efficient code development. +- Emacs/Vim Macros: Shoutout to the classic text editors and their macros that facilitated the coding experience, making repetitive tasks more manageable. + +## Package Description + +Dysts.jl is a collection of strange attractors implemented as functions returning ODEProblems. These ODE problems are fully compatible with the DifferentialEquations.jl ecosystem. Unlike the original "dysts" package, this port focuses solely on creating the ODEs and does not provide tools for discrete solution methods. + +## Features +- Chaotic ODEs: Explore a variety of chaotic systems represented as ODEs. +- DifferentialEquations.jl Compatibility: Easily integrate these chaotic systems into the DifferentialEquations.jl ecosystem for seamless exploration and analysis. + +## Installation + +```julia + +import Pkg +Pkg.add("Dysts") +``` + +## Usage + +```julia +using Dysts, DifferentialEquations, Plots + +prob = Dysts.Lorenz +sol = solve(prob, Tsit5()) +plot(sol, vars=(1,2,3)) +``` + +For more details and available attractors, refer to the original [`dysts`](https://github.com/williamgilpin/dysts) package. + +## Contributing + +Feel free to contribute by opening issues, suggesting improvements, or creating pull requests. Your feedback and participation are highly encouraged! + +## License + +Dysts.jl is licensed under the Apache-2.0 License. diff --git a/docs/Project.toml b/docs/Project.toml index b5722bd..f88f025 100644 --- a/docs/Project.toml +++ b/docs/Project.toml @@ -1,3 +1,4 @@ [deps] 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..79d3635 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -13,6 +13,7 @@ makedocs(; canonical="https://nathanaelbosch.github.io/Dysts.jl", edit_link="main", assets=String[], + size_threshold_ignore = ["index.md"], ), pages=[ "Home" => "index.md", diff --git a/docs/src/index.md b/docs/src/index.md index 158c040..f24201e 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -2,13 +2,12 @@ CurrentModule = Dysts ``` -# Dysts +# Dysts.jl -Documentation for [Dysts](https://github.com/nathanaelbosch/Dysts.jl). - -```@index -``` +Full list of all dynamical systems: ```@autodocs Modules = [Dysts] +Public = false +Pages = ["chaotic_attractors.jl"] ``` diff --git a/src/Dysts.jl b/src/Dysts.jl index 5928990..7337cf6 100644 --- a/src/Dysts.jl +++ b/src/Dysts.jl @@ -1,5 +1,82 @@ module Dysts -# Write your package code here. +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 = """ + ## Citation + $(data["citation"]) + """ + + code_string = """ + ## Original Python Code from the `dysts` package + + ```python + """ * originalcode(f) * """ + ``` + """ + + return header * stats * citation * code_string +end + +include("chaotic_attractors.jl") 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..2f9999d --- /dev/null +++ b/src/chaotic_attractors.json @@ -0,0 +1,4820 @@ +{ + "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": [] + } +} \ No newline at end of file