ChaoticDynamicalSystemLibrary.Aizawa — Function Aizawa()A torus-like attractor related to the forced Lorenz system.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.3501297618370773 - Lyapunov spectrum (estimated):
Any[0.08947878317195473, 0.020305496211675024, -0.3090729926541944] - Maximum Lyapunov exponent (estimated):
0.13489555530106362 - Multiscale Entropy:
0.514512246123007 - Non-autonomous:
false - Period:
2.5837 - Pesin entropy:
0.10978427938362978
References
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.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.AnishchenkoAstakhov — Function AnishchenkoAstakhov()Stochastic resonance in forced oscillators.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0916403758729327 - Lyapunov spectrum (estimated):
Any[0.039777554890210017, 0.0008785544495802295, -0.44025308728606666] - Maximum Lyapunov exponent (estimated):
0.10107726791527546 - Multiscale Entropy:
0.7612343892027325 - Non-autonomous:
false - Period:
6.814 - Pesin entropy:
0.040715925817307534
References
Anishchenko, et al. Nonlinear dynamics of chaotic and stochastic systems: tutorial and modern developments. 2007.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.Arneodo — Function Arneodo()A modified Lotka-Volterra ecosystem, also known as the ACT attractor.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.198607392233255 - Lyapunov spectrum (estimated):
Any[0.24285661379003065, -0.0006168721448237418, -1.2169777901647385] - Maximum Lyapunov exponent (estimated):
0.23737468667051287 - Multiscale Entropy:
0.7388404221540498 - Non-autonomous:
false - Period:
3.1641 - Pesin entropy:
0.2428749592514372
References
Arneodo, A., Coullet, P. & Tresser, C. Occurence of strange attractors in three-dimensional Volterra equations. Physics Letters A 79, 259–263 (1980)
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.ArnoldBeltramiChildress — Function ArnoldBeltramiChildress()An exact solution of Euler's equation for inviscid flow in 3D. Often referred to as the ABC flow.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.612281260580053 - Lyapunov spectrum (estimated):
Any[1.47222087191395, -0.01824039630029517, -2.378562986862767] - Maximum Lyapunov exponent (estimated):
0.3667300080060703 - Multiscale Entropy:
1.2759526834024162 - Non-autonomous:
false - Period:
2.8508 - Pesin entropy:
1.47222087191395
References
V. I. Arnold, Journal of Applied Mathematics and Mechanics 30, 223 (1966).
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.ArnoldWeb — Function ArnoldWeb()A quasi-integrable system that transitions to Chirikov diffusive dynamics when perturbed.
Stats
- Embedding dimension:
5 - Hamiltonian:
true - Kaplan-Yorke dimension:
22.554733912627043 - Lyapunov spectrum (estimated):
Any[0.06266308160064184, 0.0032177165561558833, 0.0011281526899086728, -0.00233619507966634, -0.0039196281630406] - Maximum Lyapunov exponent (estimated):
0.06514413995171335 - Multiscale Entropy:
0.620621428966386 - Non-autonomous:
true - Period:
67.25 - Pesin entropy:
0.06706808893310089
References
Froeschle, C., Guzzo, M. & Legga, E (2000). Graphical evolution of the Arnold web: From order to chaos. Science 289.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.AtmosphericRegime — Function AtmosphericRegime()A model of regime transition in atmospheric flows. Contains widely-separated timescales due a quadratic term, which itself arises from a conservation law.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1859596374283137 - Lyapunov spectrum (estimated):
nothing - Maximum Lyapunov exponent (estimated):
0.010543274932274862 - Multiscale Entropy:
0.4278776303819699 - Non-autonomous:
false - Period:
89.59496756697331 - Pesin entropy:
0.3055574134566322
References
Tuwankotta (2006). Chaos in a coupled oscillators system with widely spaced frequencies and energy-preserving non-linearity
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.BeerRNN — Function BeerRNN()A two-neuron minimal model nervous system.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0303797735862443 - Lyapunov spectrum (estimated):
Any[0.016274571192515633, -0.00011803510272572572, -0.5318869010933206] - Maximum Lyapunov exponent (estimated):
0.038767800131815223 - Multiscale Entropy:
0.5244807630539362 - Non-autonomous:
false - Period:
181.58 - Pesin entropy:
0.01647451962951782
References
Beer, R. D. (1995). On the dynamics of small continuous-time recurrent neural networks. Adapt. Behav., 3(4), 4692013509.
Original code from the dysts Python package
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 XdotChaoticDynamicalSystemLibrary.BelousovZhabotinsky — Function BelousovZhabotinsky()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
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0206505961796535 - Lyapunov spectrum (estimated):
Any[114.64513768787073, -0.4669861532822692, -5529.048679334775] - Maximum Lyapunov exponent (estimated):
132.08766434104578 - Multiscale Entropy:
0.8764191281600929 - Non-autonomous:
false - Period:
0.018257 - Pesin entropy:
114.64513768787073
References
Gyorgyi and Field (1992). A three-variable model of deterministic chaos in the Belousov-Zhabotinsky reaction. Nature.
Original code from the dysts Python package
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 * t0ChaoticDynamicalSystemLibrary.BickleyJet — Function BickleyJet()A zonal jet passing between two counter rotating vortices. A steady Hamiltonian with a time-dependent perturbation.
Stats
- Embedding dimension:
3 - Hamiltonian:
true - Kaplan-Yorke dimension:
4.066710025133773 - Lyapunov spectrum (estimated):
Any[1.9651794377408363e-7, 2.5409880958463764e-9, -9.631983584415862e-8] - Maximum Lyapunov exponent (estimated):
3.0318672544949706e-6 - Multiscale Entropy:
0.733566708397195 - Non-autonomous:
false - Period:
87826.57 - Pesin entropy:
1.99059498764899e-7
References
Hadjighasem, Karrasch, Teramoto, Haller (2016). A Spectral Clustering Approach to Lagrangian Vortex Detection Phys Rev E.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.Blasius — Function Blasius()
A chaotic food web composed of interacting predators,, consumers, and vegetation.Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.016657959617314 - Lyapunov spectrum (estimated):
Any[0.04712755400915782, 0.001803137034352918, -2.9362739640325555] - Maximum Lyapunov exponent (estimated):
0.12597339364128174 - Multiscale Entropy:
0.5917316835585642 - Non-autonomous:
false - Period:
6.6038 - Pesin entropy:
0.04893069104351076
References
Blasius, Huppert, Stone. Nature 1999
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.BlinkingRotlet — Function BlinkingRotlet()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).
Stats
- Embedding dimension:
3 - Hamiltonian:
true - Kaplan-Yorke dimension:
2.910902586026695 - Lyapunov spectrum (estimated):
Any[5.609358269449125, 0.007963961496808246, -6.16801583110239] - Maximum Lyapunov exponent (estimated):
2.120338159738003 - Multiscale Entropy:
1.2895030395332947 - Non-autonomous:
true - Period:
2.9520625 - Pesin entropy:
5.617567417119514
References
Meleshko & Aref. A blinking rotlet model for chaotic advection. Physics of Fluids 1996. See also Tallapragada and Sudarsanam PRE 2019
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.BlinkingVortex — Function BlinkingVortex()A classic minimal chaotic mixing flow. Solution is given in polar coordinates (r, theta)
Stats
- Embedding dimension:
3 - Hamiltonian:
true - Kaplan-Yorke dimension:
2.8911482753116986 - Lyapunov spectrum (estimated):
Any[4.877365151111008, -0.0016245138226140734, -5.476774413564737] - Maximum Lyapunov exponent (estimated):
2.863016777441748 - Multiscale Entropy:
1.1011364489263011 - Non-autonomous:
true - Period:
2.7616666666666667 - Pesin entropy:
4.877593783333199
References
Aref (1984). Stirring by chaotic advection. J. Fluid Mechanics.
Original code from the dysts Python package
class BlinkingVortex(BlinkingRotlet):
passChaoticDynamicalSystemLibrary.Bouali — Function Bouali()Economic cycles with fluctuating demand. Related to the DequanLi attractor
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.224727237508172 - Lyapunov spectrum (estimated):
Any[0.04911273564448129, 0.0006869653413631164, -0.22171821407820913] - Maximum Lyapunov exponent (estimated):
0.06012563518102038 - Multiscale Entropy:
0.7505556173926505 - Non-autonomous:
false - Period:
3.0411 - Pesin entropy:
0.049816045406570614
References
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
Original code from the dysts Python package
class Bouali(Bouali2):
passChaoticDynamicalSystemLibrary.Bouali2 — Function Bouali2()A modified economic cycle model.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
16.471858210544983 - Lyapunov spectrum (estimated):
Any[0.020389225004628773, 0.0033455417942589724, -0.009602768742817189] - Maximum Lyapunov exponent (estimated):
0.07681730213975516 - Multiscale Entropy:
0.4520009826326611 - Non-autonomous:
false - Period:
2.6779 - Pesin entropy:
0.02439941982137089
References
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
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.BurkeShaw — Function BurkeShaw()A scroll-like attractor with unique symmetry along the z axis.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.2113447891991065 - Lyapunov spectrum (estimated):
Any[2.3453555864112117, 0.027056468824027846, -11.225316054517004] - Maximum Lyapunov exponent (estimated):
2.324596351534631 - Multiscale Entropy:
0.906432166797223 - Non-autonomous:
false - Period:
0.78333 - Pesin entropy:
2.37241205523524
References
Shaw (1981). Zeitschrift fur Naturforschung.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.CaTwoPlus — Function CaTwoPlus()Intracellular calcium ion oscillations.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0647813731079956 - Lyapunov spectrum (estimated):
Any[0.5788123099350391, 0.022652249040266133, -9.284523260554844] - Maximum Lyapunov exponent (estimated):
0.5802865327706731 - Multiscale Entropy:
0.5770296569860646 - Non-autonomous:
false - Period:
1.343 - Pesin entropy:
0.6014645592138562
References
Houart, Dupont, Goldbeter. Bull Math Biol 1999.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.CaTwoPlusQuasiperiodic — Function CaTwoPlusQuasiperiodic()Intracellular calcium ion oscillations with quasiperiodic parameter values. The original paper also includes parameters for a limit cycle
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
4.547800407390443 - Lyapunov spectrum (estimated):
Any[0.1620868046117494, -0.02225809783295617, -0.054895455267669285] - Maximum Lyapunov exponent (estimated):
0.48083152954373326 - Multiscale Entropy:
0.8512706770213926 - Non-autonomous:
false - Period:
0.65614 - Pesin entropy:
0.16210233717161812
References
Houart, Dupont, Goldbeter. Bull Math Biol 1999.
Original code from the dysts Python package
class CaTwoPlusQuasiperiodic(CaTwoPlus):
passChaoticDynamicalSystemLibrary.CellCycle — Function CellCycle()A simplified model of the cell cycle. The parameter Kim controls the bifurcations.
Stats
- Embedding dimension:
6 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.020810681242375 - Lyapunov spectrum (estimated):
Any[0.00469985418122158, -0.0003567612310661562, -0.20915644240415007, -0.43394905365820846, -2.850536314608979, -6.767614340964144] - Maximum Lyapunov exponent (estimated):
0.010172128409635746 - Multiscale Entropy:
1.021736994304444 - Non-autonomous:
false - Period:
204.71 - Pesin entropy:
0.004765100518900255
References
Romond, Rustici, Gonze, Goldbeter. 1999.
Original code from the dysts Python package
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, x2dotChaoticDynamicalSystemLibrary.CellularNeuralNetwork — Function CellularNeuralNetwork()Cellular neural network dynamics.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.167668286708633 - Lyapunov spectrum (estimated):
Any[0.09799656528996928, 0.0036354952626342415, -0.6061495728157424] - Maximum Lyapunov exponent (estimated):
2.3258468977096562 - Multiscale Entropy:
1.2414841874061011 - Non-autonomous:
false - Period:
3.2 - Pesin entropy:
0.1016320623247746
References
Arena, Caponetto, Fortuna, and Porto., Int J Bifurcat Chaos. 1998: 1527-1539.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.Chen — Function Chen()A system based on feedback anti-control in engineering.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.168621926035506 - Lyapunov spectrum (estimated):
Any[2.0471208808332557, -0.05031354288886987, -11.841816202859391] - Maximum Lyapunov exponent (estimated):
2.005961349488129 - Multiscale Entropy:
0.7604529380690989 - Non-autonomous:
false - Period:
0.58689 - Pesin entropy:
2.047313967129477
References
Chen (1997). Proc. First Int. Conf. Control of Oscillations and Chaos.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.ChenLee — Function ChenLee()A rigid body with feedback anti-control.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0300416878282137 - Lyapunov spectrum (estimated):
Any[0.16460631102343384, 0.00018225769802326938, -5.485329903201408] - Maximum Lyapunov exponent (estimated):
0.16363115430160305 - Multiscale Entropy:
0.6224325755254609 - Non-autonomous:
false - Period:
2.8043 - Pesin entropy:
0.16478856872146466
References
Chen HK, Lee CI (2004). Anti-control of chaos in rigid body motion. Chaos, Solitons & Fractals
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Chua — Function Chua()An electronic circuit with a diode providing negative resistance.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.10727056025829 - Lyapunov spectrum (estimated):
Any[0.4605474829443073, 0.0022048281168492866, -4.319076735248446] - Maximum Lyapunov exponent (estimated):
1.2301163591725595 - Multiscale Entropy:
1.2693527097629784 - Non-autonomous:
false - Period:
1.4235 - Pesin entropy:
0.4645707969482971
References
Chua, L. O. (1969) Introduction to Nonlinear Network Theory, McGraw-Hill, New York.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.CircadianRhythm — Function CircadianRhythm()The Drosophila circadian rhythm under periodic light/dark forcing.
Stats
- Embedding dimension:
5 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.640554412377753 - Lyapunov spectrum (estimated):
Any[0.09298369588063138, 0.00046501992305171574, -0.14586025062784352, -0.3598453092044599, -1.091393481159416] - Maximum Lyapunov exponent (estimated):
0.006263277393890506 - Multiscale Entropy:
0.7054585345031309 - Non-autonomous:
true - Period:
27.0 - Pesin entropy:
0.09372724379002938
References
Leloup, Gonze, Goldbeter. 1999. Gonze, Leloup, Goldbeter. 2000Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.CoevolvingPredatorPrey — Function CoevolvingPredatorPrey()A system of predator-prey equations with co-evolving prey.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0026539580881706 - Lyapunov spectrum (estimated):
Any[0.0034879428860592264, 0.0017391810332012293, -1.9676998121970224] - Maximum Lyapunov exponent (estimated):
0.00732698039035783 - Multiscale Entropy:
1.006450625395487 - Non-autonomous:
false - Period:
122.77 - Pesin entropy:
0.005379136261058156
References
Gilpin & Feldman (2017). PLOS Comp Biol
Original code from the dysts Python package
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, alphadotChaoticDynamicalSystemLibrary.Colpitts — Function Colpitts()An electrical circuit used as a signal generator.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.134959031654127 - Lyapunov spectrum (estimated):
Any[0.13750285290669104, -0.0021021241106901328, -1.0014048629576902] - Maximum Lyapunov exponent (estimated):
0.3736008151161584 - Multiscale Entropy:
0.7266290517682168 - Non-autonomous:
false - Period:
4.2676 - Pesin entropy:
0.1390751886208436
References
Kennedy (2007). IEEE Trans Circuits & Systems. 1994: 771-774. Li, Zhou, Yang. Chaos, Solitons, & Fractals.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.Coullet — Function Coullet()A variant of the Arneodo attractor
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.252992250313846 - Lyapunov spectrum (estimated):
Any[0.14890693833273877, -6.504894715051528e-5, -0.5873658566804084] - Maximum Lyapunov exponent (estimated):
0.13718762024831516 - Multiscale Entropy:
0.9055084400125268 - Non-autonomous:
false - Period:
5.7663 - Pesin entropy:
0.14919849957322842
References
Arneodo, A., Coullet, P. & Tresser, C. Occurence of strange attractors in three-dimensional volterra equations. Physics Letters A 79, 259–263 (1980)
Original code from the dysts Python package
class Coullet(Arneodo):
passChaoticDynamicalSystemLibrary.Dadras — Function Dadras()An electronic circuit capable of producing multiple attractors under bifurcations.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0430103150081735 - Lyapunov spectrum (estimated):
Any[0.47344233096408, 0.0064562720284210215, -11.157725546142514] - Maximum Lyapunov exponent (estimated):
0.40591521049520063 - Multiscale Entropy:
0.8537980405426894 - Non-autonomous:
false - Period:
3.2886 - Pesin entropy:
0.4798988304624064
References
S Dadras, HR Momeni (2009). A novel three-dimensional autonomous chaotic system generating two, three and four-scroll attractors. Physics Letters A.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.DequanLi — Function DequanLi()Related to the Three Scroll unified attractor TSUCS-2
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.6848604732863537 - Lyapunov spectrum (estimated):
Any[1.8601963396884453, 0.09866428540326228, -2.867185439620747] - Maximum Lyapunov exponent (estimated):
0.739747976641268 - Multiscale Entropy:
0.8319369667525882 - Non-autonomous:
false - Period:
0.083806 - Pesin entropy:
1.9588606250917073
References
Li, Phys Lett A. 2008: 387-393.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.DoubleGyre — Function DoubleGyre()A time-dependent fluid flow exhibiting Lagrangian coherent structures
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.881525629972418 - Lyapunov spectrum (estimated):
Any[0.06285936079346421, -0.0036702088073069326, -0.06633987533400756] - Maximum Lyapunov exponent (estimated):
0.12185254082886439 - Multiscale Entropy:
0.66519273658672 - Non-autonomous:
true - Period:
13.953 - Pesin entropy:
0.06285936079346421
References
Shadden, Lekien, Marsden (2005). Definition and properties of Lagrangian coherent structures from finite-time Lyapunov exponents in two-dimensional aperiodic flows. Physica D.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.DoublePendulum — Function DoublePendulum()Two coupled rigid pendula without damping.
Stats
- Embedding dimension:
4 - Hamiltonian:
true - Kaplan-Yorke dimension:
3.810221473882809 - Lyapunov spectrum (estimated):
Any[8.464443924343541, 0.46411672696182493, -0.17345525567611142, -10.805817517613212] - Maximum Lyapunov exponent (estimated):
3.985298067514186 - Multiscale Entropy:
0.5591104791210428 - Non-autonomous:
false - Period:
4.0234 - Pesin entropy:
8.928560651305366
References
See, for example: Marion (2013). Classical dynamics of particles and systems.
Original code from the dysts Python package
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_dotChaoticDynamicalSystemLibrary.Duffing — Function Duffing()A monochromatically-forced rigid pendulum, with the nonlinearity approximated as cubic.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.561219319140712 - Lyapunov spectrum (estimated):
Any[0.09952054532941002, 0.0003077550037828977, -0.17595301607629793] - Maximum Lyapunov exponent (estimated):
0.14026545752865122 - Multiscale Entropy:
0.8686568999981737 - Non-autonomous:
true - Period:
7.4496 - Pesin entropy:
0.10008657388524086
References
Duffing, G. (1918), Forced oscillations with variable natural frequency and their technical relevance, Heft 41/42, Braunschweig: Vieweg.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.ExcitableCell — Function ExcitableCell()A reduced-order variant of the Hodgkin-Huxley model. The parameter gkc controls the onset of chaos.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1287842177704674 - Lyapunov spectrum (estimated):
Any[17.030315084501463, -0.3267053778962445, -129.70230355691595] - Maximum Lyapunov exponent (estimated):
0.7164303367057223 - Multiscale Entropy:
0.7807524009298388 - Non-autonomous:
false - Period:
0.5528 - Pesin entropy:
17.030315084501463
References
Teresa Chay. Chaos In A Three-variable Model Of An Excitable Cell. Physica D 1985
Original code from the dysts Python package
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, cdotChaoticDynamicalSystemLibrary.Finance — Function Finance()Stock fluctuations under varying investment demand and interest rates
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.172040321306389 - Lyapunov spectrum (estimated):
Any[0.10708598383274774, 0.0009835797228343356, -0.6279525877233353] - Maximum Lyapunov exponent (estimated):
0.09354106442670211 - Multiscale Entropy:
0.7817861077722251 - Non-autonomous:
false - Period:
9.8932 - Pesin entropy:
0.1084488028544319
References
Guoliang Cai, Juanjuan Huang. International Journal of Nonlinear Science, Vol. 3 (2007)
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.FluidTrampoline — Function FluidTrampoline()A droplet bouncing on a horizontal soap film.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.8462636972682116 - Lyapunov spectrum (estimated):
Any[0.08081301489037329, -0.0011783910877478326, -0.09403052188090477] - Maximum Lyapunov exponent (estimated):
0.22311237411461174 - Multiscale Entropy:
0.796312585554829 - Non-autonomous:
true - Period:
7.7351 - Pesin entropy:
0.08094585172323163
References
Gilet, Bush. The fluid trampoline: droplets bouncing on a soap film. JFM 2009.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.ForcedBrusselator — Function ForcedBrusselator()An autocatalytic chemical system.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
1.190019824057157 - Lyapunov spectrum (estimated):
Any[0.0028307087627546254, -0.014898681909916936, -0.23304448314240073] - Maximum Lyapunov exponent (estimated):
0.015326007974604663 - Multiscale Entropy:
0.47299463051887286 - Non-autonomous:
true - Period:
20.411 - Pesin entropy:
0.0028307087627546254
References
I. Prigogine, From Being to Becoming: Time and Complexity in the Physical Sciences, New York: W.H. Freeman and Company, 1980.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.ForcedFitzHughNagumo — Function ForcedFitzHughNagumo()A driven neuron model sustaining both quiesent and oscillating states.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
1.5705852319395741 - Lyapunov spectrum (estimated):
Any[0.0006271045837994497, -0.0017541532237019502, -0.9544351506941636] - Maximum Lyapunov exponent (estimated):
0.007561278655908403 - Multiscale Entropy:
0.946734422406113 - Non-autonomous:
true - Period:
42.12235294117647 - Pesin entropy:
0.000828176101772673
References
FitzHugh, Richard (1961). Impulses and Physiological States in Theoretical Models of Nerve Membrane. Biophysical Journal. 1 (6).
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.ForcedVanDerPol — Function ForcedVanDerPol()An electronic circuit containing a triode.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.012828649055009 - Lyapunov spectrum (estimated):
Any[0.2651824388815116, -0.0008450617218488057, -20.60632249066986] - Maximum Lyapunov exponent (estimated):
0.0035097622587646343 - Multiscale Entropy:
0.39443058905146283 - Non-autonomous:
true - Period:
14.476875 - Pesin entropy:
0.26518243888151155
References
B. van der Pol (1920). A theory of the amplitude of free and forced triode vibrations. Radio Review 1.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.GenesioTesi — Function GenesioTesi()A nonlinear control system with feedback.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1892507433089325 - Lyapunov spectrum (estimated):
Any[0.09974381765927798, 0.00038146676582121423, -0.5282231255530121] - Maximum Lyapunov exponent (estimated):
0.10509061137519304 - Multiscale Entropy:
0.7003576241153363 - Non-autonomous:
false - Period:
5.9431 - Pesin entropy:
0.10027488648885732
References
Genesio, Tesi (1992). Harmonic balance methods for the analysis of chaotic dynamics in nonlinear systems. Automatica 28.3 (1992): 531-548.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.GuckenheimerHolmes — Function GuckenheimerHolmes()A nonlinear oscillator.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.3663164666051353 - Lyapunov spectrum (estimated):
Any[0.34082003567895874, -0.0032191807339425173, -0.9216135618098852] - Maximum Lyapunov exponent (estimated):
0.7885729042404602 - Multiscale Entropy:
0.5385101182847213 - Non-autonomous:
false - Period:
0.3076923076923077 - Pesin entropy:
0.3408200356941137
References
Guckenheimer, John, and Philip Holmes (1983). Nonlinear oscillations, dynamical systems, and bifurcations of vector fields. Vol. 42. Springer Science & Business Media.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Hadley — Function Hadley()An atmospheric convective cell.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.7273838319442127 - Lyapunov spectrum (estimated):
Any[0.31166133927315953, -0.0010838827053467116, -0.42739317979015523] - Maximum Lyapunov exponent (estimated):
0.2386587703845738 - Multiscale Entropy:
0.9351389987191853 - Non-autonomous:
false - Period:
1.4541 - Pesin entropy:
0.3144504334934165
References
G. Hadley (1735). On the cause of the general trade winds. Philosophical Transactions of the Royal Society, vol. 34, pp. 58–62.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Halvorsen — Function Halvorsen()An algebraically-simple chaotic system with quadratic nonlinearity
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.118235268907861 - Lyapunov spectrum (estimated):
Any[0.586197150399321, -0.031953945256851884, -4.6876300977027565] - Maximum Lyapunov exponent (estimated):
0.6963711539102683 - Multiscale Entropy:
0.7527831765757674 - Non-autonomous:
false - Period:
1.4889 - Pesin entropy:
0.586197150399321
References
Sprott, Julien C (2010). Elegant chaos: algebraically simple chaotic flows. World Scientific, 2010.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.HastingsPowell — Function HastingsPowell()A three species food web.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.027757892627057 - Lyapunov spectrum (estimated):
Any[0.008585012825774563, 0.005765040490702786, -0.5169232002224432] - Maximum Lyapunov exponent (estimated):
0.012532796124563227 - Multiscale Entropy:
0.47829796264231095 - Non-autonomous:
false - Period:
135.19 - Pesin entropy:
0.014350053316477346
References
Hastings, Powell. Ecology 1991
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.HenonHeiles — Function HenonHeiles()A star's motion around the galactic center.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
6.81141589838772 - Lyapunov spectrum (estimated):
Any[0.026747154244887203, 0.011500891097175434, -1.4057113933414076e-5, -0.011151041415888588] - Maximum Lyapunov exponent (estimated):
0.03551120315239528 - Multiscale Entropy:
0.7137794258156454 - Non-autonomous:
false - Period:
6.37 - Pesin entropy:
0.03870865064107525
References
Henon, M.; Heiles, C. (1964). The applicability of the third integral of motion: Some numerical experiments. The Astronomical Journal. 69: 73.
Original code from the dysts Python package
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, pydotChaoticDynamicalSystemLibrary.HindmarshRose — Function HindmarshRose()A neuron model exhibiting spiking and bursting.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0405369895957373 - Lyapunov spectrum (estimated):
Any[0.2621464274609406, 0.0017705383465481184, -6.510663065519547] - Maximum Lyapunov exponent (estimated):
0.6535393283242747 - Multiscale Entropy:
0.8692605688019491 - Non-autonomous:
false - Period:
1.752 - Pesin entropy:
0.2639169709155772
References
Marhl, Perc. Chaos, Solitons, Fractals 2005.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Hopfield — Function Hopfield()A neural network with frustrated connectivity
Stats
- Embedding dimension:
6 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.264479110541058 - Lyapunov spectrum (estimated):
Any[0.07726437124258394, -0.00018152933777384922, -0.29083324580448194, -0.36906925337474944, -0.40604718386075256, -1.4425404449511432] - Maximum Lyapunov exponent (estimated):
0.5684266951234997 - Multiscale Entropy:
0.9160145554679957 - Non-autonomous:
false - Period:
10.865 - Pesin entropy:
0.07748903749076723
References
Lewis & Glass, Neur Comp (1992)
Original code from the dysts Python package
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 XdotChaoticDynamicalSystemLibrary.HyperBao — Function HyperBao()Hyperchaos in the Lu system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.0460429607933572 - Lyapunov spectrum (estimated):
Any[0.6959739496471207, 0.2076688444499756, 0.01646766869238271, -19.983737503321315] - Maximum Lyapunov exponent (estimated):
0.7941925747845208 - Multiscale Entropy:
0.8910215561062699 - Non-autonomous:
false - Period:
0.5831505997603473 - Pesin entropy:
0.9201105075982862
References
Bao, Liu (2008). A hyperchaotic attractor coined from the chaotic Lu system. Chin. Physics Letters, Vol. 25, pp 2396-2399.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperCai — Function HyperCai()A hyperchaotic variant of the Finance system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.138030987910704 - Lyapunov spectrum (estimated):
Any[1.634443623908957, 0.12845528254618424, -0.003328688360603957, -12.747646341795276] - Maximum Lyapunov exponent (estimated):
1.6777584899044127 - Multiscale Entropy:
1.1155413734604414 - Non-autonomous:
false - Period:
0.6113936187028436 - Pesin entropy:
1.7628989064551457
References
Guoliang, Huang (2007). A New Finance Chaotic Attractor. International Journal of Nonlinear Science.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperJha — Function HyperJha()A hyperchaotic system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.053181782412727 - Lyapunov spectrum (estimated):
Any[0.3949499860671474, 0.2920214751184925, 0.005568431034995312, -13.022125042186726] - Maximum Lyapunov exponent (estimated):
0.38695361636760767 - Multiscale Entropy:
0.8934166449122942 - Non-autonomous:
false - Period:
0.8564467295817622 - Pesin entropy:
0.6925398922206352
References
Jürgen Meier (2003). Presentation of Attractors with Cinema.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperLorenz — Function HyperLorenz()A hyperchaotic variant of the Lorenz attractor.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.044709906668086 - Lyapunov spectrum (estimated):
Any[0.2925643599949083, 0.24691553258701357, 0.04704434899468292, -13.118440302968889] - Maximum Lyapunov exponent (estimated):
0.3288809596909799 - Multiscale Entropy:
0.8026458791332332 - Non-autonomous:
false - Period:
1.277546730110058 - Pesin entropy:
0.5865242415766048
References
Jürgen Meier (2003). Presentation of Attractors with Cinema.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperLu — Function HyperLu()A hyperchaotic variant of the Lu attractor.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.0822889656900583 - Lyapunov spectrum (estimated):
Any[1.0855770127041702, 0.4753850931706396, 0.02849951886859947, -19.313823203887658] - Maximum Lyapunov exponent (estimated):
1.042961263138283 - Multiscale Entropy:
1.0455788608813867 - Non-autonomous:
false - Period:
0.7162856981996777 - Pesin entropy:
1.5894616248138722
References
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.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperPang — Function HyperPang()A hyperchaotic system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.08902125132107 - Lyapunov spectrum (estimated):
Any[1.586932998381499, 0.28444192185263556, -0.0011541322141891326, -21.007696151519628] - Maximum Lyapunov exponent (estimated):
1.4465315511406867 - Multiscale Entropy:
0.9172158388570456 - Non-autonomous:
false - Period:
0.8439374360017028 - Pesin entropy:
1.871913394885623
References
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.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperQi — Function HyperQi()A hyperchaotic variant of the Qi system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.2816770286126777 - Lyapunov spectrum (estimated):
Any[13.908799876284396, 2.8519979827853357, -0.04957904444451209, -59.32758839771818] - Maximum Lyapunov exponent (estimated):
12.787249321134263 - Multiscale Entropy:
0.9988440965886223 - Non-autonomous:
false - Period:
0.06186038560173437 - Pesin entropy:
16.760797859069733
References
G. Qi, M. A. van Wyk, B. J. van Wyk, and G. Chen, (2008). On a new hyperchaotic system. Physics Letters A.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperRossler — Function HyperRossler()A hyperchaotic variant of the Rossler system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.916384112225743 - Lyapunov spectrum (estimated):
Any[0.27859233648384435, -7.749198930652314e-5, -0.3014660985555502, -70.26609894565237] - Maximum Lyapunov exponent (estimated):
0.1718849632568779 - Multiscale Entropy:
0.9144754695112332 - Non-autonomous:
false - Period:
1.1157476694793766 - Pesin entropy:
0.2789695684743801
References
Rossler, O. E. (1979). An equation for hyperchaos.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperWang — Function HyperWang()A hyperchaotic variant of the Wang system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.105321722354005 - Lyapunov spectrum (estimated):
Any[1.2224015619377895, 0.25827623672371736, -0.0075512136517132625, -13.986919236227278] - Maximum Lyapunov exponent (estimated):
1.2930140887300063 - Multiscale Entropy:
0.9969261837212393 - Non-autonomous:
false - Period:
0.6481520567576332 - Pesin entropy:
1.480677798661507
References
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.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperXu — Function HyperXu()A hyperchaotic system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.0909471864561056 - Lyapunov spectrum (estimated):
Any[1.0420068843753962, 0.20717763316365526, -0.0033988115975040426, -13.697896294059921] - Maximum Lyapunov exponent (estimated):
0.9819830018599975 - Multiscale Entropy:
0.9312323303231519 - Non-autonomous:
false - Period:
1.1328151255687646 - Pesin entropy:
1.2491913312241498
References
Letellier & Rossler (2007). Hyperchaos. Scholarpedia 2.8 (2007): 1936.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperYan — Function HyperYan()A hyperchaotic system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0711118082329567 - Lyapunov spectrum (estimated):
Any[0.9120352761173002, 0.15303345953001665, -14.977382134147613, -39.36365990052555] - Maximum Lyapunov exponent (estimated):
1.3945968455812914 - Multiscale Entropy:
0.8166157518949907 - Non-autonomous:
false - Period:
0.9127028626966961 - Pesin entropy:
1.0650687356473167
References
Jürgen Meier (2003). Presentation of Attractors with Cinema.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.HyperYangChen — Function HyperYangChen()A hyperchaotic system.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.026605264361547 - Lyapunov spectrum (estimated):
Any[0.5742688696462735, 0.327365255173604, 0.023510192276255986, -34.77284163099938] - Maximum Lyapunov exponent (estimated):
0.42042732521941667 - Multiscale Entropy:
0.9730322217427024 - Non-autonomous:
false - Period:
0.9127028626966961 - Pesin entropy:
0.9255171125652686
References
Jürgen Meier (2003). Presentation of Attractors with Cinema.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.IsothermalChemical — Function IsothermalChemical()An isothermal chemical system with mixed-mode oscillations
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0385823810364654 - Lyapunov spectrum (estimated):
Any[0.3365871343421436, -0.05136527222093221, -7.392541736904205] - Maximum Lyapunov exponent (estimated):
0.450090505359164 - Multiscale Entropy:
0.6589422003608746 - Non-autonomous:
false - Period:
0.7302799999999999 - Pesin entropy:
0.3365871343421436
References
Petrov, Scott, Showalter. Mixed-mode oscillations in chemical systems. J Chem Phys 1992
Original code from the dysts Python package
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, gammadotChaoticDynamicalSystemLibrary.ItikBanksTumor — Function ItikBanksTumor()A model of cancer cell populations.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0152772613355485 - Lyapunov spectrum (estimated):
Any[0.022156938955395417, -0.0135394920593605, -0.5610833889492404] - Maximum Lyapunov exponent (estimated):
0.03621509684991421 - Multiscale Entropy:
0.5883298730506914 - Non-autonomous:
false - Period:
49.74 - Pesin entropy:
0.022156938955395417
References
Itik, Banks. Int J Bifurcat Chaos 2010
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.JerkCircuit — Function JerkCircuit()An electronic circuit with nonlinearity provided by a diode.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.5082428902531144 - Lyapunov spectrum (estimated):
Any[0.394872929553187, 0.1849026306096344, -1.1407351759248092] - Maximum Lyapunov exponent (estimated):
0.2922722771543928 - Multiscale Entropy:
0.38139916676685187 - Non-autonomous:
false - Period:
19.4546 - Pesin entropy:
0.5797755601628214
References
Sprott (2011). A new chaotic jerk circuit. IEEE Circ. Sys. 2011.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.KawczynskiStrizhak — Function KawczynskiStrizhak()A chemical oscillator model describing mixed-modes in the BZ equations.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
1.4235221965773541 - Lyapunov spectrum (estimated):
Any[0.025607519929323416, -0.06145426210744069, -0.31683393262481707] - Maximum Lyapunov exponent (estimated):
0.0757060839542753 - Multiscale Entropy:
0.5935098791328474 - Non-autonomous:
false - Period:
7.991666666666667 - Pesin entropy:
0.02560751992932341
References
P. E. Strizhak and A. L. Kawczynski, J. Phys. Chem. 99, 10830 (1995).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Laser — Function Laser()A semiconductor laser model
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.049321615812801 - Lyapunov spectrum (estimated):
Any[0.7637435195473311, 0.020943250302999646, -15.909545615344538] - Maximum Lyapunov exponent (estimated):
0.6080602180196161 - Multiscale Entropy:
1.004437967414151 - Non-autonomous:
false - Period:
0.94667 - Pesin entropy:
0.7848314215142518
References
Abooee, Yaghini-Bonabi, Jahed-Motlagh (2013). Analysis and circuitry realization of a novel three-dimensional chaotic system. Comm Nonline Sci 2013
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.LidDrivenCavityFlow — Function LidDrivenCavityFlow()A two-dimensional flow alternately driven by translation of the left and right walls.
Stats
- Embedding dimension:
3 - Hamiltonian:
true - Kaplan-Yorke dimension:
2.9856669109882814 - Lyapunov spectrum (estimated):
Any[1.00757312, -0.00276829, -1.01941623] - Maximum Lyapunov exponent (estimated):
2.172601412109087 - Multiscale Entropy:
0.7815824521381879 - Non-autonomous:
true - Period:
2.7333134945588955 - Pesin entropy:
1.007573134065856
References
Grover et al. Chaos (2012). Topological chaos, braiding and bifurcation of almost-cyclic sets.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.LiuChen — Function LiuChen()Derived from Sakarya.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
1.2188137323261288 - Lyapunov spectrum (estimated):
Any[0.21332142584135133, -0.9748996261500176, -18.807059276226646] - Maximum Lyapunov exponent (estimated):
0.2457084451352168 - Multiscale Entropy:
0.7641473604711979 - Non-autonomous:
false - Period:
8.0164 - Pesin entropy:
0.2133214258413513
References
Liu, Chen. Int J Bifurcat Chaos. 2004: 1395-1403.
Original code from the dysts Python package
class LiuChen(Sakarya):
passChaoticDynamicalSystemLibrary.Lorenz — Function Lorenz()A minimal weather model based on atmospheric convection.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.075158758095728 - Lyapunov spectrum (estimated):
Any[1.0910931847726466, 0.02994120961308413, -14.915552395875103] - Maximum Lyapunov exponent (estimated):
0.8917098035724058 - Multiscale Entropy:
1.1541457906835575 - Non-autonomous:
false - Period:
1.5008 - Pesin entropy:
1.121034394385731
References
Lorenz, Edward N (1963). Deterministic nonperiodic flow. Journal of the atmospheric sciences 20.2 (1963): 130-141.
Original code from the dysts Python package
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]ChaoticDynamicalSystemLibrary.Lorenz84 — Function Lorenz84()Atmospheric circulation analogous to Hadley convection.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.4449761695022096 - Lyapunov spectrum (estimated):
Any[1.0474807193950644, -0.045398035352994866, -2.251992293230755] - Maximum Lyapunov exponent (estimated):
0.46146683857936616 - Multiscale Entropy:
0.6685802317710752 - Non-autonomous:
false - Period:
6.2586 - Pesin entropy:
1.0474807193950644
References
E. Lorenz (1984). Irregularity: a fundamental property of the atmosphere. Tellus A, vol. 36, no. 2, pp. 98–110, 1984.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Lorenz96 — Function Lorenz96()A climate model containing fluid-like advective nonlinearities, and multiscale coupling of fast and slow variables.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.1698163415908196 - Lyapunov spectrum (estimated):
Any[1.6247012663091516, 0.17185232259745578, -1.1936282999960617, -3.550455057872212] - Maximum Lyapunov exponent (estimated):
1.3361667787286362 - Multiscale Entropy:
0.8046726640855828 - Non-autonomous:
false - Period:
2.1969 - Pesin entropy:
1.7965535889066073
References
Lorenz, Edward (1996). Predictability: A problem partly solved. Seminar on Predictability, Vol. I, ECMWF.
Original code from the dysts Python package
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 XdotChaoticDynamicalSystemLibrary.LorenzBounded — Function LorenzBounded()The Lorenz attractor in the presence of a confining potential.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0704391073439155 - Lyapunov spectrum (estimated):
Any[0.8497533717540197, 0.001413707285345669, -12.120634680260636] - Maximum Lyapunov exponent (estimated):
0.7124135270827626 - Multiscale Entropy:
1.1983193915488475 - Non-autonomous:
false - Period:
1.3716 - Pesin entropy:
0.8513198508911037
References
Sprott & Xiong (2015). Chaos.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.LorenzCoupled — Function LorenzCoupled()Two coupled Lorenz attractors.
Stats
- Embedding dimension:
6 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.0408069075490425 - Lyapunov spectrum (estimated):
Any[1.2218762961515068, 0.1222254715421154, -1.265209618630438, -1.9333037412103384, -13.618111101381306, -15.073328947851422] - Maximum Lyapunov exponent (estimated):
1.0284398414904556 - Multiscale Entropy:
1.1717493753138832 - Non-autonomous:
false - Period:
1.6207 - Pesin entropy:
1.3441017676936224
References
Lorenz, Edward N. Deterministic nonperiodic flow. Journal of the atmospheric sciences 20.2 (1963): 130-141.
Original code from the dysts Python package
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, z2dotChaoticDynamicalSystemLibrary.LorenzStenflo — Function LorenzStenflo()Atmospheric acoustic-gravity waves.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1738121741011174 - Lyapunov spectrum (estimated):
Any[0.44944459925783387, 0.026077542739630446, -2.7358399678801906, -3.4213273148340293] - Maximum Lyapunov exponent (estimated):
0.3807742646421621 - Multiscale Entropy:
1.0299236916146275 - Non-autonomous:
false - Period:
3.8877142857142855 - Pesin entropy:
0.47552214199746434
References
Letellier & Rossler (2007). Hyperchaos. Scholarpedia 2.8 (2007): 1936.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.LuChen — Function LuChen()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
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0358980309317456 - Lyapunov spectrum (estimated):
Any[0.6651845739025707, 0.1450338199952451, -22.56999542505058] - Maximum Lyapunov exponent (estimated):
0.3266868574498627 - Multiscale Entropy:
0.4483903807918106 - Non-autonomous:
false - Period:
2.3385 - Pesin entropy:
0.8102183938978158
References
Lu, Chen. Int J Bifurcat Chaos. 2002: 659-661.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.LuChenCheng — Function LuChenCheng()A four scroll attractor that reduces to Lorenz-like dynamics under bifurcations.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0293036172873244 - Lyapunov spectrum (estimated):
Any[0.35106210160478324, -0.012414362698175424, -11.556516575635818] - Maximum Lyapunov exponent (estimated):
0.2612775880231121 - Multiscale Entropy:
0.6029763775293518 - Non-autonomous:
false - Period:
0.92333 - Pesin entropy:
0.3510621518701211
References
Lu, Chen, Cheng. Int J Bifurcat Chaos. 2004: 1507–1537.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.MacArthur — Function MacArthur()Population abundances in a plankton community, based on MacArthur's consumer resource model. Growth rates are determined using Liebig's law of the maximum
Stats
- Embedding dimension:
10 - Hamiltonian:
false - Kaplan-Yorke dimension:
3.8961444775216614 - Lyapunov spectrum (estimated):
Any[0.1934617869736995, 0.004866584152339167, -0.0431132227766039, -0.17665092099562724, -0.30357752906614904, -0.30392441898183636, -0.30474608910196055, -0.3051840587615213, -0.3058908399877519, -17.37453227551654] - Maximum Lyapunov exponent (estimated):
0.2494638510848618 - Multiscale Entropy:
0.7844902548776685 - Non-autonomous:
false - Period:
43.406 - Pesin entropy:
0.19832837112603868
References
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.
Original code from the dysts Python package
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])ChaoticDynamicalSystemLibrary.MooreSpiegel — Function MooreSpiegel()A thermo-mechanical oscillator.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.3217713120052443 - Lyapunov spectrum (estimated):
Any[0.4074353399833356, -0.022079955878999143, -1.1975751283606624] - Maximum Lyapunov exponent (estimated):
0.6976623003008144 - Multiscale Entropy:
0.5401952179209213 - Non-autonomous:
false - Period:
1.2887 - Pesin entropy:
0.4076334003995097
References
Moore, Spiegel. A Thermally Excited Nonlinear Oscillator, Ap. J., 143, 871 (1966)
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.MultiChua — Function MultiChua()Multiple interacting Chua electronic circuits.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0710214570482988 - Lyapunov spectrum (estimated):
Any[0.2210571234274344, -0.00140279701621115, -3.10264254580399] - Maximum Lyapunov exponent (estimated):
1.462134784614238 - Multiscale Entropy:
0.8118881305702679 - Non-autonomous:
false - Period:
2.2586 - Pesin entropy:
0.22151080996231726
References
Mufcstak E. Yalcin, Johan A. K. Suykens, Joos Vandewalle. Cellular Neural Networks, Multi-Scroll Chaos And Synchronization.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.NewtonLiepnik — Function NewtonLiepnik()Euler's equations for a rigid body, augmented with a linear feedback term.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.2206092778719664 - Lyapunov spectrum (estimated):
Any[0.1723564207468104, -0.00036976661148194504, -0.7795789311467557] - Maximum Lyapunov exponent (estimated):
0.14945341784639976 - Multiscale Entropy:
0.6322918700854281 - Non-autonomous:
false - Period:
8.5095 - Pesin entropy:
0.17242608410350868
References
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.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.NoseHoover — Function NoseHoover()Fixed temperature molecular dynamics for a strained flow under a reduced order model.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
6.213204677134776 - Lyapunov spectrum (estimated):
Any[0.04757010871740569, 0.0013844486958287268, -0.011653762286922777] - Maximum Lyapunov exponent (estimated):
0.010464383779400952 - Multiscale Entropy:
0.5656074689683536 - Non-autonomous:
false - Period:
5.8673 - Pesin entropy:
0.04895455741323442
References
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.
Original code from the dysts Python package
class NoseHoover(DynSys):
@staticjit
def _rhs(x, y, z, t, a):
xdot = y
ydot = -x + y * z
zdot = a - y ** 2
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.NuclearQuadrupole — Function NuclearQuadrupole()A quadrupole boson Hamiltonian that produces chaos via a resonance overlap mechanism
Stats
- Embedding dimension:
4 - Hamiltonian:
true - Kaplan-Yorke dimension:
4.280996083113027 - Lyapunov spectrum (estimated):
Any[0.27858365099437626, 0.06629535725881477, -0.00449888101008936, -0.2658004759134054] - Maximum Lyapunov exponent (estimated):
0.29554197767663787 - Multiscale Entropy:
0.8209529097052416 - Non-autonomous:
false - Period:
6.023076923076923 - Pesin entropy:
0.3448827969293456
References
Baran V. and Raduta A. A. (1998), International Journal of Modern Physics E
Original code from the dysts Python package
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, p2dotChaoticDynamicalSystemLibrary.OscillatingFlow — Function OscillatingFlow()A model fluid flow that produces KAM tori. Original parameters have been rescaled by k
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.962629189215532 - Lyapunov spectrum (estimated):
Any[0.4274159768365289, -0.005029615144529367, -0.43888500460322705] - Maximum Lyapunov exponent (estimated):
0.13470179997834794 - Multiscale Entropy:
0.6177682255070645 - Non-autonomous:
true - Period:
23.857 - Pesin entropy:
0.4274159768365288
References
T. H. Solomon and J. P. Gollub, Phys. Rev. A 38, 6280 (1988).
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.PanXuZhou — Function PanXuZhou()A named attractor related to the DequanLi attractor
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0644468877116084 - Lyapunov spectrum (estimated):
Any[0.8697394318152156, 0.01603608355912526, -13.744271396596757] - Maximum Lyapunov exponent (estimated):
0.6132378917107628 - Multiscale Entropy:
1.0993195372407014 - Non-autonomous:
false - Period:
1.7829 - Pesin entropy:
0.885775515374341
References
Zhou, Wuneng, et al. On dynamics analysis of a new chaotic attractor. Physics Letters A 372.36 (2008): 5773-5777..
Original code from the dysts Python package
class PanXuZhou(DequanLi):
passChaoticDynamicalSystemLibrary.PehlivanWei — Function PehlivanWei()A system with quadratic nonlinearity, which undergoes Hopf bifurcations of codimension 1 and 2.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1563635563177295 - Lyapunov spectrum (estimated):
Any[0.09512327528959069, 0.0015323304198873254, -0.6168618108533457] - Maximum Lyapunov exponent (estimated):
0.10415076085878888 - Multiscale Entropy:
0.6547493000137818 - Non-autonomous:
false - Period:
3.7487330316742087 - Pesin entropy:
0.09665562724246173
References
Pehlivan, Ihsan, and Wei Zhouchao (2012). Analysis, nonlinear control, and chaos generator circuit of another strange chaotic system.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Qi — Function Qi()A hyperchaotic system with a wide power spectrum.
Stats
- Embedding dimension:
4 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.498645226832379 - Lyapunov spectrum (estimated):
Any[2.0360429519545677, 0.1320125824983059, -4.347891883424509, -44.356041824978305] - Maximum Lyapunov exponent (estimated):
2.1916060472989556 - Multiscale Entropy:
0.8855652233700573 - Non-autonomous:
false - Period:
0.40820999999999996 - Pesin entropy:
2.168055534452874
References
G. Qi, M. A. van Wyk, B. J. van Wyk, and G. Chen, (2008). On a new hyperchaotic system. Physics Letters A.
Original code from the dysts Python package
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, wdotChaoticDynamicalSystemLibrary.QiChen — Function QiChen()A double-wing chaotic attractor that arises from two bistable attractors. The system has quadratic nonlinearity.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0917466081236316 - Lyapunov spectrum (estimated):
Any[3.8880075026301206, 0.13379585631170307, -43.8359895934497] - Maximum Lyapunov exponent (estimated):
4.0275703123027435 - Multiscale Entropy:
0.846453868214798 - Non-autonomous:
false - Period:
0.39179 - Pesin entropy:
4.021803358941824
References
Qi et al. Chaos, Solitons & Fractals 2008.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.RabinovichFabrikant — Function RabinovichFabrikant()A reduced-order model of propagating waves in monequilibrium media.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.36076141745315 - Lyapunov spectrum (estimated):
Any[0.24233580922074083, 1.7068504600119996e-5, -0.6717710576786404] - Maximum Lyapunov exponent (estimated):
0.2541443669572464 - Multiscale Entropy:
0.9189339042839536 - Non-autonomous:
false - Period:
2.3356 - Pesin entropy:
0.24239107527154555
References
Rabinovich, Mikhail I.; Fabrikant, A. L. (1979). Stochastic Self-Modulation of Waves in Nonequilibrium Media. Sov. Phys. JETP.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.RayleighBenard — Function RayleighBenard()A reduced-order model of a convective cell.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1059475747031655 - Lyapunov spectrum (estimated):
Any[1.7098267053321798, 0.3076248958606731, -19.04195798211122] - Maximum Lyapunov exponent (estimated):
1.8138795790741327 - Multiscale Entropy:
0.9190517908569512 - Non-autonomous:
false - Period:
0.91967 - Pesin entropy:
2.0174516011928527
References
Yanagita, Kaneko (1995). Rayleigh-Bénard convection patterns, chaos, spatiotemporal chaos and turbulence. Physica D: Nonlinear Phenomena 82.3 (1995): 288-313.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.RikitakeDynamo — Function RikitakeDynamo()Electric current and magnetic field of two coupled disk dynamos.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0672834652602137 - Lyapunov spectrum (estimated):
Any[0.14571192786308473, 0.0007222098218782572, -2.1743990404663296] - Maximum Lyapunov exponent (estimated):
0.1318127385277225 - Multiscale Entropy:
0.9664471212975273 - Non-autonomous:
false - Period:
5.8975 - Pesin entropy:
0.14655639292019562
References
Rikitake, T., Oscillations of a system of disk dynamos, Mathematical Proceedings of the Cambridge Philosophical Society, 1958.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Rossler — Function Rossler()Spiral-type chaos in a simple oscillator model.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0146095059018845 - Lyapunov spectrum (estimated):
Any[0.0763301393780693, 0.007522476799147231, -5.741024338716747] - Maximum Lyapunov exponent (estimated):
0.15059688939547888 - Multiscale Entropy:
0.605878349292794 - Non-autonomous:
false - Period:
5.9086 - Pesin entropy:
0.08385261617721652
References
Rossler, O. E. (1976), An Equation for Continuous Chaos, Physics Letters, 57A (5): 3972013398,
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Rucklidge — Function Rucklidge()Two-dimensional convection in a horizontal layer of Boussinesq fluid with lateral constraints.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.055660980653234 - Lyapunov spectrum (estimated):
Any[0.18286378999435815, -0.0039065765687848, -3.2151284307504713] - Maximum Lyapunov exponent (estimated):
0.1936356650629198 - Multiscale Entropy:
0.6441822675461503 - Non-autonomous:
false - Period:
6.0721 - Pesin entropy:
0.18286397807774446
References
Rucklidge, A.M. (1992). Chaos in models of double convection. Journal of Fluid Mechanics.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Sakarya — Function Sakarya()An attractor that arises due to merging of two disjoint bistable attractors.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.245095314885476 - Lyapunov spectrum (estimated):
Any[0.3080921246264039, 0.00035292037656675234, -1.2584697568737606] - Maximum Lyapunov exponent (estimated):
0.26501036485491514 - Multiscale Entropy:
0.6082767822064958 - Non-autonomous:
false - Period:
4.9844 - Pesin entropy:
0.3084450450029706
References
Li, Chunbiao, et al (2015). A novel four-wing strange attractor born in bistability. IEICE Electronics Express 12.4.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SaltonSea — Function SaltonSea()An eco-epidemiological model of bird and fish abundances in the Salton sea of southern California.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0843843542474496 - Lyapunov spectrum (estimated):
Any[0.3914445015077359, -0.0037578848522063194, -4.592867667006148] - Maximum Lyapunov exponent (estimated):
1.0702552017260383 - Multiscale Entropy:
0.9335269725171643 - Non-autonomous:
false - Period:
0.96738 - Pesin entropy:
0.39160860195935765
References
Upadhyay, Bairagi, Kundu, Chattopadhyay (2007).Chaos in eco-epidemiological problem of the Salton Sea and its possible control. Applied mathematics and computation.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SanUmSrisuchinwong — Function SanUmSrisuchinwong()A two-scroll attractor arising from dynamical equations with piecewise nonlinearities. Equivalent to the Wimol-Banlue system
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.194219372064799 - Lyapunov spectrum (estimated):
Any[0.23913890446639047, -0.0002916165416126154, -1.2296759041605134] - Maximum Lyapunov exponent (estimated):
0.2606135207962152 - Multiscale Entropy:
0.9947542017597873 - Non-autonomous:
false - Period:
7.4654 - Pesin entropy:
0.23946267672516214
References
San-Um, Srisuchinwong. J. Comp 2012
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.ShimizuMorioka — Function ShimizuMorioka()A system that bifurcates from a symmetric limit cycle to an asymmetric one, similar to the Lorenz attractor.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0312187919639926 - Lyapunov spectrum (estimated):
Any[0.044032234819090736, -1.3942528300804223e-5, -1.409991553164768] - Maximum Lyapunov exponent (estimated):
0.03577425334463406 - Multiscale Entropy:
0.7156563118943259 - Non-autonomous:
false - Period:
12.038 - Pesin entropy:
0.044239420179671494
References
Shimizu, Morioka. Phys Lett A. 1980: 201-204
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottA — Function SprottA()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
60.66528307527488 - Lyapunov spectrum (estimated):
Any[0.029259920155059096, 0.004990159457687409, -0.0015561317158397701] - Maximum Lyapunov exponent (estimated):
0.012993052652429771 - Multiscale Entropy:
0.5748267225365974 - Non-autonomous:
false - Period:
6.3728461538461545 - Pesin entropy:
0.0343008088722448
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
class SprottA(DynSys):
@staticjit
def _rhs(x, y, z, t):
xdot = y
ydot = -x + y * z
zdot = 1 - y ** 2
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.SprottB — Function SprottB()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1852994894688953 - Lyapunov spectrum (estimated):
Any[0.21987503866971636, 0.005187437926969091, -1.2145826242115807] - Maximum Lyapunov exponent (estimated):
0.20674275256006883 - Multiscale Entropy:
0.8826029903839796 - Non-autonomous:
false - Period:
11.050142857142857 - Pesin entropy:
0.2250624765966855
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
class SprottB(DynSys):
@staticjit
def _rhs(x, y, z, t):
xdot = y * z
ydot = x - y
zdot = 1 - x * y
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.SprottC — Function SprottC()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1529236029587073 - Lyapunov spectrum (estimated):
Any[0.17898394736414464, -0.0007304674803429964, -1.1644550651924115] - Maximum Lyapunov exponent (estimated):
0.15806924766944033 - Multiscale Entropy:
1.14839462464542 - Non-autonomous:
false - Period:
8.8852 - Pesin entropy:
0.17933456833596748
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
class SprottC(DynSys):
@staticjit
def _rhs(x, y, z, t):
xdot = y * z
ydot = x - y
zdot = 1 - x ** 2
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.SprottD — Function SprottD()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0807565309303526 - Lyapunov spectrum (estimated):
Any[0.11415315682442645, 0.001787998513315278, -1.4601870646976078] - Maximum Lyapunov exponent (estimated):
0.10170941886932346 - Multiscale Entropy:
1.0030259093693934 - Non-autonomous:
false - Period:
4.8333 - Pesin entropy:
0.11594526886491094
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
class SprottD(DynSys):
@staticjit
def _rhs(x, y, z, t):
xdot = -y
ydot = x + z
zdot = x * z + 3 * y ** 2
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.SprottE — Function SprottE()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0894640654250147 - Lyapunov spectrum (estimated):
Any[0.09834470642927143, -0.00031069798260046597, -1.0953799295090543] - Maximum Lyapunov exponent (estimated):
0.09016067590084897 - Multiscale Entropy:
0.8387888716672988 - Non-autonomous:
false - Period:
7.6275 - Pesin entropy:
0.09866310814686535
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
class SprottE(DynSys):
@staticjit
def _rhs(x, y, z, t):
xdot = y * z
ydot = x ** 2 - y
zdot = 1 - 4 * x
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.SprottF — Function SprottF()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.2516153966506316 - Lyapunov spectrum (estimated):
Any[0.13246006583273318, 0.0192716855937824, -0.603011686855317] - Maximum Lyapunov exponent (estimated):
0.1183090101484132 - Multiscale Entropy:
0.7674306147320477 - Non-autonomous:
false - Period:
19.244 - Pesin entropy:
0.1517317514265156
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottG — Function SprottG()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0519020031307744 - Lyapunov spectrum (estimated):
Any[0.03349131570257798, -0.0012749369106980868, -0.6182204265060449] - Maximum Lyapunov exponent (estimated):
0.09067832253388744 - Multiscale Entropy:
0.6185493944257671 - Non-autonomous:
false - Period:
8.7097 - Pesin entropy:
0.03403484153064641
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottH — Function SprottH()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.2414973487697853 - Lyapunov spectrum (estimated):
Any[0.13871794302385684, 0.003501431527456669, -0.5889065665901029] - Maximum Lyapunov exponent (estimated):
0.13100182470690253 - Multiscale Entropy:
0.6325364503922819 - Non-autonomous:
false - Period:
20.229 - Pesin entropy:
0.14221937455131348
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottI — Function SprottI()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.019844528960972 - Lyapunov spectrum (estimated):
Any[0.020459651934364873, 9.478591964272237e-6, -1.031514712617076] - Maximum Lyapunov exponent (estimated):
0.023218704376506836 - Multiscale Entropy:
0.5893805046352655 - Non-autonomous:
false - Period:
10.93 - Pesin entropy:
0.02077411702709478
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottJ — Function SprottJ()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0221468017281006 - Lyapunov spectrum (estimated):
Any[0.04451808076432957, 0.0010621228852282804, -2.055842238064512] - Maximum Lyapunov exponent (estimated):
0.12290789099642041 - Multiscale Entropy:
0.6352974298685767 - Non-autonomous:
false - Period:
4.836 - Pesin entropy:
0.04588958821017871
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.SprottJerk — Function SprottJerk()An algebraidally simple flow depending on a third time derivative. Numerical integration of this attractor is extremely sensitive to the initial conditions
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.031190248069004 - Lyapunov spectrum (estimated):
Any[0.06738258231535933, -0.0007831911114099333, -2.1347047232043663] - Maximum Lyapunov exponent (estimated):
0.08785190282162628 - Multiscale Entropy:
0.5314887786603959 - Non-autonomous:
false - Period:
11.921 - Pesin entropy:
0.06776939078007471
References
Sprott, J. C. Simplest dissipative chaotic flow. Physics Letters A (1997).
Original code from the dysts Python package
class SprottJerk(DynSys):
@staticjit
def _rhs(x, y, z, t, mu):
xdot = y
ydot = z
zdot = -x + y ** 2 - mu * z
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.SprottK — Function SprottK()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0417036451446204 - Lyapunov spectrum (estimated):
Any[0.03778259119323125, -0.0005109461395399151, -0.8934722146671759] - Maximum Lyapunov exponent (estimated):
0.05962593786799159 - Multiscale Entropy:
0.6562812206790845 - Non-autonomous:
false - Period:
7.006 - Pesin entropy:
0.03788160511007809
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottL — Function SprottL()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0329815956000377 - Lyapunov spectrum (estimated):
Any[0.03407149258791976, -0.000391471796353918, -1.012962157697122] - Maximum Lyapunov exponent (estimated):
0.09216197583296963 - Multiscale Entropy:
0.5605870039438788 - Non-autonomous:
false - Period:
6.7262 - Pesin entropy:
0.0343958205328805
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottM — Function SprottM()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.04996202872584 - Lyapunov spectrum (estimated):
Any[0.05230117379497565, -0.00033063791832836577, -1.0391447706177515] - Maximum Lyapunov exponent (estimated):
0.08422043130700084 - Multiscale Entropy:
0.7481178461456197 - Non-autonomous:
false - Period:
5.3644 - Pesin entropy:
0.05234518101225785
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottMore — Function SprottMore()A multifractal system with a nearly 3D attractor
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.999952495039482 - Lyapunov spectrum (estimated):
Any[0.32499834596046606, -0.0001641583999746131, -0.31918544080126926] - Maximum Lyapunov exponent (estimated):
1.0946909441433958 - Multiscale Entropy:
0.6370154977546665 - Non-autonomous:
false - Period:
6.62095890410959 - Pesin entropy:
0.32515558132375566
References
Sprott, J. C. (2020). Do We Need More Chaos Examples? Chaos Theory and Applications 2(2),1-3, 2020.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottN — Function SprottN()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.028951405806632 - Lyapunov spectrum (estimated):
Any[0.06095861449194353, 6.560209716837452e-5, -2.101648044064128] - Maximum Lyapunov exponent (estimated):
0.11869612209728901 - Multiscale Entropy:
0.6385218945868028 - Non-autonomous:
false - Period:
4.8135 - Pesin entropy:
0.061478272616693266
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottO — Function SprottO()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.2474645346215256 - Lyapunov spectrum (estimated):
Any[0.06685684927644238, 0.011533284505120292, -0.3165440349833235] - Maximum Lyapunov exponent (estimated):
0.09141077854590315 - Multiscale Entropy:
0.4161154943097029 - Non-autonomous:
false - Period:
9.755 - Pesin entropy:
0.07839013378156268
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottP — Function SprottP()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.2122245136720187 - Lyapunov spectrum (estimated):
Any[0.1026165705645786, 0.00025136328640969387, -0.4843551814513015] - Maximum Lyapunov exponent (estimated):
0.1064676723437159 - Multiscale Entropy:
0.8486396469370624 - Non-autonomous:
false - Period:
5.3414 - Pesin entropy:
0.10329419803150507
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottQ — Function SprottQ()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.2246852931286063 - Lyapunov spectrum (estimated):
Any[0.13698250147166127, 0.0010386716745898255, -0.6140516336902575] - Maximum Lyapunov exponent (estimated):
0.17169784338063596 - Multiscale Entropy:
0.8105158145249107 - Non-autonomous:
false - Period:
4.8443 - Pesin entropy:
0.13852213114060488
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.SprottR — Function SprottR()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.071744469374985 - Lyapunov spectrum (estimated):
Any[0.07608481335025485, 0.0013697096816499383, -1.0784000269941107] - Maximum Lyapunov exponent (estimated):
0.09661415277799693 - Multiscale Entropy:
0.5877166245477188 - Non-autonomous:
false - Period:
7.0133 - Pesin entropy:
0.07840404228136309
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.SprottS — Function SprottS()A member of the Sprott family of algebraically-simple chaotic sytems.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.182390107009358 - Lyapunov spectrum (estimated):
Any[0.2149312025337423, 0.0030194370306177213, -1.1945344436340624] - Maximum Lyapunov exponent (estimated):
0.2737629235389973 - Multiscale Entropy:
0.6690400524585065 - Non-autonomous:
false - Period:
3.3505 - Pesin entropy:
0.21876911249150574
References
Sprott (1994). Some simple chaotic flows. Physical Review E (1994).
Original code from the dysts Python package
class SprottS(DynSys):
@staticjit
def _rhs(x, y, z, t):
xdot = -x - 4 * y
ydot = x + z ** 2
zdot = 1 + x
return xdot, ydot, zdotChaoticDynamicalSystemLibrary.SprottTorus — Function SprottTorus()A multiattractor system that goes to a torus or a complex attractor depending on the initial conditions.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.759693065535405 - Lyapunov spectrum (estimated):
Any[0.29656066211909027, 0.0005468818242604863, -0.3910853761095065] - Maximum Lyapunov exponent (estimated):
0.1056964344650892 - Multiscale Entropy:
0.9562901894463037 - Non-autonomous:
false - Period:
13.607 - Pesin entropy:
0.29710937347161515
References
Sprott Physics Letters A 2014
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.StickSlipOscillator — Function StickSlipOscillator()A weakly forced (quasiautonomous) oscillator with dynamics similar to stick-slip friction. The parameter gamma controls the transition to chaos.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
5.682155291949877 - Lyapunov spectrum (estimated):
Any[0.07073329226101453, 3.356854711815694e-5, -0.02131392884593247] - Maximum Lyapunov exponent (estimated):
0.06406131604734494 - Multiscale Entropy:
0.9213029740441252 - Non-autonomous:
true - Period:
1.6129 - Pesin entropy:
0.07108101456222432
References
Awrejcewicz, Jan, and M. M. Holicke (1999). Int J of Bifurcation and Chaos.
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.SwingingAtwood — Function SwingingAtwood()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
Stats
- Embedding dimension:
4 - Hamiltonian:
true - Kaplan-Yorke dimension:
4.0198847313975445 - Lyapunov spectrum (estimated):
Any[7.735006558021491, 3.0380875684439133, -3.002075505122432, -7.664246463289054] - Maximum Lyapunov exponent (estimated):
1.0111284961954359 - Non-autonomous:
false - Period:
0.3417647058823529 - Pesin entropy:
10.773094126465404
References
Tufillaro, Nicholas B.; Abbott, Tyler A.; Griffiths, David J. (1984). Swinging Atwood's Machine. American Journal of Physics. 52 (10): 895–903.
Original code from the dysts Python package
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, pthChaoticDynamicalSystemLibrary.Thomas — Function Thomas()A cyclically-symmetric attractor correspondng to a frictionally-damped particle traversing a 3D lattice of forces
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1271136075295507 - Lyapunov spectrum (estimated):
Any[0.7589685797630259, 0.057355308262307496, -6.421950974462397] - Maximum Lyapunov exponent (estimated):
0.6324054000339867 - Multiscale Entropy:
0.9921951854111759 - Non-autonomous:
false - Period:
4.969 - Pesin entropy:
0.8163238880253334
References
Thomas, Rene (1999). Deterministic chaos seen in terms of feedback circuits: Analysis, synthesis, labyrinth chaos. Int. J. Bifurc. Chaos.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Torus — Function Torus()A minimal quasiperiodic flow on a torus. All lyapunov exponents and related quantities are zero
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0 - Lyapunov spectrum (estimated):
Any[0.0, 0.0, 0.0] - Maximum Lyapunov exponent (estimated):
0.00817284128815307 - Multiscale Entropy:
0.47330913201518593 - Non-autonomous:
false - Period:
6.36 - Pesin entropy:
0.0
References
See, for example, Strogatz (1994). Nonlinear Dynamics and Chaos.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.Tsucs2 — Function Tsucs2()A named attractor related to the DequanLi attractor
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.315349160163322 - Lyapunov spectrum (estimated):
Any[0.6414001783252772, -0.22409536897391863, -1.3233103558456687] - Maximum Lyapunov exponent (estimated):
0.13621488344499086 - Multiscale Entropy:
0.3913632586715302 - Non-autonomous:
false - Period:
0.34526 - Pesin entropy:
0.6414001783252772
References
Pan, Zhou, Li (2013). Synchronization of Three-Scroll Unified Chaotic System (TSUCS) and its hyper-chaotic system using active pinning control
Original code from the dysts Python package
class Tsucs2(DequanLi):
passChaoticDynamicalSystemLibrary.TurchinHanski — Function TurchinHanski()
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.Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
1.2053069221786739 - Lyapunov spectrum (estimated):
Any[0.03719830596656144, -0.181183885924572, -2.522759887828014] - Maximum Lyapunov exponent (estimated):
0.12906862565697674 - Multiscale Entropy:
0.4989636261373046 - Non-autonomous:
true - Period:
4.40529411764706 - Pesin entropy:
0.03719830596656144
References
Turchin, Hanski. The American Naturalist 1997. Turchin, Hanski. Ecology 2000
Original code from the dysts Python package
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)ChaoticDynamicalSystemLibrary.VallisElNino — Function VallisElNino()Atmospheric temperature fluctuations with annual forcing.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1205065379188333 - Lyapunov spectrum (estimated):
Any[0.6561566154431996, 0.022689184568283626, -5.6332694618503885] - Maximum Lyapunov exponent (estimated):
0.5477586276153029 - Multiscale Entropy:
0.9058707360850027 - Non-autonomous:
false - Period:
2.2087 - Pesin entropy:
0.6788458000114831
References
Vallis GK. Conceptual models of El Nio and the southern oscillation. J Geophys Res 1988
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.WangSun — Function WangSun()A four-scroll attractor
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0595560098996604 - Lyapunov spectrum (estimated):
Any[0.07990874520682271, -0.001043918775422804, -1.3240808432405] - Maximum Lyapunov exponent (estimated):
0.06735463002480017 - Multiscale Entropy:
0.9045422097501858 - Non-autonomous:
false - Period:
26.958 - Pesin entropy:
0.07994326076367073
References
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.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.WindmiReduced — Function WindmiReduced()Energy transfer into the ionosphere and magnetosphere by the solar wind. The parameter vsw controls the onset of chaos.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0947817139683895 - Lyapunov spectrum (estimated):
Any[0.15595238514031914, 9.695760899839663e-5, -1.6450480911820564] - Maximum Lyapunov exponent (estimated):
0.403521000622694 - Multiscale Entropy:
0.5896070173085494 - Non-autonomous:
false - Period:
4.6733 - Pesin entropy:
0.15635149449218705
References
Smith, Thiffeault, Horton. J Geophys Res. 2000. Horton, Weigel, Sprott. Chaos 2001.
Original code from the dysts Python package
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, pdotChaoticDynamicalSystemLibrary.YuWang — Function YuWang()A temperature-compensation circuit with an operational amplifier
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.1703721122420614 - Lyapunov spectrum (estimated):
Any[2.459880656234634, -0.07297917814211805, -14.00993065520751] - Maximum Lyapunov exponent (estimated):
1.8525516537708415 - Multiscale Entropy:
0.6340382196367295 - Non-autonomous:
false - Period:
1.3366 - Pesin entropy:
2.459880656234634
References
Yu, Wang (2012). A novel three dimension autonomous chaotic system with a quadratic exponential nonlinear term. Eng Techn & Applied Science Research.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.YuWang2 — Function YuWang2()An alternative temperature-compensation circuit with an operational amplifier
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.0619881661890873 - Lyapunov spectrum (estimated):
Any[0.802715215563475, 0.007966964664720393, -13.078014115524866] - Maximum Lyapunov exponent (estimated):
1.1576066800869989 - Multiscale Entropy:
0.9335570471768684 - Non-autonomous:
false - Period:
0.39265 - Pesin entropy:
0.8106827804626555
References
Yu, Wang (2012). A novel three dimension autonomous chaotic system with a quadratic exponential nonlinear term. Eng Techn & Applied Science Research.
Original code from the dysts Python package
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, zdotChaoticDynamicalSystemLibrary.ZhouChen — Function ZhouChen()A feedback circuit model.
Stats
- Embedding dimension:
3 - Hamiltonian:
false - Kaplan-Yorke dimension:
2.045920730005392 - Lyapunov spectrum (estimated):
Any[0.5917259125455694, 0.005203946388490041, -12.999237688229242] - Maximum Lyapunov exponent (estimated):
0.6828000288089435 - Multiscale Entropy:
0.7337896982114851 - Non-autonomous:
false - Period:
0.87518 - Pesin entropy:
0.5969734164748293
References
Zhou, Chen (2004). A simple smooth chaotic system with a 3-layer attractor. Int J Bifurcat Chaos, 2004
Original code from the dysts Python package
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