ChaoticDynamicalSystemLibrary.AizawaFunction
   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, zdot
ChaoticDynamicalSystemLibrary.AnishchenkoAstakhovFunction
   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.ArneodoFunction
   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, zdot
ChaoticDynamicalSystemLibrary.ArnoldBeltramiChildressFunction
   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.ArnoldWebFunction
   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.AtmosphericRegimeFunction
   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, zdot
ChaoticDynamicalSystemLibrary.BeerRNNFunction
   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 Xdot
ChaoticDynamicalSystemLibrary.BelousovZhabotinskyFunction
   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 * t0
ChaoticDynamicalSystemLibrary.BickleyJetFunction
   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.BlasiusFunction
   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, zdot
ChaoticDynamicalSystemLibrary.BlinkingRotletFunction
   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

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.BlinkingVortexFunction
   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):
pass
ChaoticDynamicalSystemLibrary.BoualiFunction
   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):
pass
ChaoticDynamicalSystemLibrary.Bouali2Function
   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, zdot
ChaoticDynamicalSystemLibrary.BurkeShawFunction
   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, zdot
ChaoticDynamicalSystemLibrary.CaTwoPlusFunction
   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.CaTwoPlusQuasiperiodicFunction
   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):
pass
ChaoticDynamicalSystemLibrary.CellCycleFunction
   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, x2dot
ChaoticDynamicalSystemLibrary.CellularNeuralNetworkFunction
   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.ChenFunction
   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, zdot
ChaoticDynamicalSystemLibrary.ChenLeeFunction
   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, zdot
ChaoticDynamicalSystemLibrary.ChuaFunction
   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, zdot
ChaoticDynamicalSystemLibrary.CircadianRhythmFunction
   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. 2000

Original 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.CoevolvingPredatorPreyFunction
   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
-((a1 * k1 * x * alpha * delta) / (1 + b1 * alpha))
- d1 * (-2 * k2 * alpha * delta ** 2 + 4 * k4 * alpha ** 3 * delta ** 4)
)
return xdot, ydot, alphadot
ChaoticDynamicalSystemLibrary.ColpittsFunction
   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.CoulletFunction
   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):
pass
ChaoticDynamicalSystemLibrary.DadrasFunction
   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, zdot
ChaoticDynamicalSystemLibrary.DequanLiFunction
   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, zdot
ChaoticDynamicalSystemLibrary.DoubleGyreFunction
   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.DoublePendulumFunction
   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_dot
ChaoticDynamicalSystemLibrary.DuffingFunction
   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.ExcitableCellFunction
   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, cdot
ChaoticDynamicalSystemLibrary.FinanceFunction
   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, zdot
ChaoticDynamicalSystemLibrary.FluidTrampolineFunction
   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.ForcedBrusselatorFunction
   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.ForcedFitzHughNagumoFunction
   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.ForcedVanDerPolFunction
   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.GenesioTesiFunction
   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, zdot
ChaoticDynamicalSystemLibrary.GuckenheimerHolmesFunction
   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, zdot
ChaoticDynamicalSystemLibrary.HadleyFunction
   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, zdot
ChaoticDynamicalSystemLibrary.HalvorsenFunction
   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, zdot
ChaoticDynamicalSystemLibrary.HastingsPowellFunction
   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, zdot
ChaoticDynamicalSystemLibrary.HenonHeilesFunction
   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, pydot
ChaoticDynamicalSystemLibrary.HindmarshRoseFunction
   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, zdot
ChaoticDynamicalSystemLibrary.HopfieldFunction
   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 Xdot
ChaoticDynamicalSystemLibrary.HyperBaoFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperCaiFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperJhaFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperLorenzFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperLuFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperPangFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperQiFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperRosslerFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperWangFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperXuFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperYanFunction
   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, wdot
ChaoticDynamicalSystemLibrary.HyperYangChenFunction
   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, wdot
ChaoticDynamicalSystemLibrary.IsothermalChemicalFunction
   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, gammadot
ChaoticDynamicalSystemLibrary.ItikBanksTumorFunction
   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, zdot
ChaoticDynamicalSystemLibrary.JerkCircuitFunction
   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, zdot
ChaoticDynamicalSystemLibrary.KawczynskiStrizhakFunction
   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, zdot
ChaoticDynamicalSystemLibrary.LaserFunction
   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, zdot
ChaoticDynamicalSystemLibrary.LidDrivenCavityFlowFunction
   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.LiuChenFunction
   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):
pass
ChaoticDynamicalSystemLibrary.LorenzFunction
   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.Lorenz84Function
   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, zdot
ChaoticDynamicalSystemLibrary.Lorenz96Function
   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 Xdot
ChaoticDynamicalSystemLibrary.LorenzBoundedFunction
   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, zdot
ChaoticDynamicalSystemLibrary.LorenzCoupledFunction
   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, z2dot
ChaoticDynamicalSystemLibrary.LorenzStenfloFunction
   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, wdot
ChaoticDynamicalSystemLibrary.LuChenFunction
   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, zdot
ChaoticDynamicalSystemLibrary.LuChenChengFunction
   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, zdot
ChaoticDynamicalSystemLibrary.MacArthurFunction
   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.MooreSpiegelFunction
   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, zdot
ChaoticDynamicalSystemLibrary.MultiChuaFunction
   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]))

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.NewtonLiepnikFunction
   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, zdot
ChaoticDynamicalSystemLibrary.NoseHooverFunction
   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, zdot
ChaoticDynamicalSystemLibrary.NuclearQuadrupoleFunction
   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, p2dot
ChaoticDynamicalSystemLibrary.OscillatingFlowFunction
   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.PanXuZhouFunction
   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):
pass
ChaoticDynamicalSystemLibrary.PehlivanWeiFunction
   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, zdot
ChaoticDynamicalSystemLibrary.QiFunction
   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, wdot
ChaoticDynamicalSystemLibrary.QiChenFunction
   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, zdot
ChaoticDynamicalSystemLibrary.RabinovichFabrikantFunction
   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.RayleighBenardFunction
   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, zdot
ChaoticDynamicalSystemLibrary.RikitakeDynamoFunction
   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, zdot
ChaoticDynamicalSystemLibrary.RosslerFunction
   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, zdot
ChaoticDynamicalSystemLibrary.RucklidgeFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SakaryaFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SaltonSeaFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SanUmSrisuchinwongFunction
   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, zdot
ChaoticDynamicalSystemLibrary.ShimizuMoriokaFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottAFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottBFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottCFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottDFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottEFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottFFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottGFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottHFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottIFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottJFunction
   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.SprottJerkFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottKFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottLFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottMFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottMoreFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottNFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottOFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottPFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottQFunction
   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.SprottRFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottSFunction
   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, zdot
ChaoticDynamicalSystemLibrary.SprottTorusFunction
   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, zdot
ChaoticDynamicalSystemLibrary.StickSlipOscillatorFunction
   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.SwingingAtwoodFunction
   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, pth
ChaoticDynamicalSystemLibrary.ThomasFunction
   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, zdot
ChaoticDynamicalSystemLibrary.TorusFunction
   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, zdot
ChaoticDynamicalSystemLibrary.Tsucs2Function
   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):
pass
ChaoticDynamicalSystemLibrary.TurchinHanskiFunction
   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.VallisElNinoFunction
   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, zdot
ChaoticDynamicalSystemLibrary.WangSunFunction
   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, zdot
ChaoticDynamicalSystemLibrary.WindmiReducedFunction
   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, pdot
ChaoticDynamicalSystemLibrary.YuWangFunction
   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, zdot
ChaoticDynamicalSystemLibrary.YuWang2Function
   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, zdot
ChaoticDynamicalSystemLibrary.ZhouChenFunction
   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