Hyperchaotic four-dimensional Rössler flow

Rössler's four-dimensional flow, hyperchaotic with two positive Lyapunov exponents for its defaults.

• Name: hyperchaotic_rossler
• Field: mathematics/dynamical_systems
• Formalism: ordinary differential equations
• References: Rössler 1979; Dilão 2023

Select this system

from skcomplex.systems import create_simulation, create_system, describe

system = create_system('hyperchaotic_rossler')
entry = describe('hyperchaotic_rossler')
trajectory = create_simulation('hyperchaotic_rossler').prepare().run().trajectory_

Factory

@register_system(
    field='mathematics/dynamical_systems',
    tags=('chaos', 'ode', 'hyperchaos', 'strange attractor'),
    references=('Rössler 1979', 'Dilão 2023'),
    defaults={'until': 300.0, 'dt': 0.05},
)
def hyperchaotic_rossler(
    x: float = -10.0,
    y: float = -6.0,
    z: float = 0.0,
    w: float = 10.0,
    *,
    a: float = 0.25,
    b: float = 3.0,
    c: float = 0.05,
    d: float = 0.5,
) -> System:
    """Return Rössler's four-dimensional flow, hyperchaotic with two positive Lyapunov exponents for its defaults.

    The flow `x' = -(y + z)`, `y' = x + a y + w`, `z' = b + x z`, `w' = c w - d z` stretches the attractor in two
    directions at once, with the exponents near 0.11 and 0.02 for the parameters of Dilão (2023, Exercise 4.18).

    Args:
        x:
            The initial first coordinate.

        y:
            The initial second coordinate.

        z:
            The initial third coordinate.

        w:
            The initial fourth coordinate.

        a:
            The feedback of the second coordinate on itself.

        b:
            The constant drive of the third coordinate.

        c:
            The growth of the fourth coordinate.

        d:
            The damping of the fourth coordinate by the third.

    Returns:
        system:
            The system, with the states `rossler.x`, `rossler.y`, `rossler.z`, and `rossler.w`.

    Examples:
        >>> from skcomplex.systems.mathematics.dynamical_systems import hyperchaotic_rossler
        >>> hyperchaotic_rossler(c=0.1).elements[0].c
        0.1
    """
    return System(elements=[HyperchaoticRosslerElement('rossler', x=x, y=y, z=z, w=w, a=a, b=b, c=c, d=d)])

Components

Elements:

• HyperchaoticRosslerElement, from Element

class HyperchaoticRosslerElement(Element):
    """Rössler's four-dimensional flow `x' = -(y + z)`, `y' = x + a y + w`, `z' = b + x z`, `w' = c w - d z`.

    Args:
        label:
            The label of the element.

        visual:
            How the element is drawn, or `None` for `default_visual_`.

        x:
            The initial first coordinate.

        y:
            The initial second coordinate.

        z:
            The initial third coordinate.

        w:
            The initial fourth coordinate.

        a:
            The feedback of the second coordinate on itself.

        b:
            The constant drive of the third coordinate.

        c:
            The growth of the fourth coordinate.

        d:
            The damping of the fourth coordinate by the third.

    Examples:
        >>> from skcomplex.systems.mathematics.dynamical_systems import HyperchaoticRosslerElement
        >>> HyperchaoticRosslerElement('rossler', b=2.0).b
        2.0
    """

    def __init__(
        self,
        label: str,
        visual: VisualSpec | None = None,
        *,
        x: Annotated[object, StateSpec()] = -10.0,
        y: Annotated[object, StateSpec()] = -6.0,
        z: Annotated[object, StateSpec()] = 0.0,
        w: Annotated[object, StateSpec()] = 10.0,
        a: Annotated[object, ParameterSpec()] = 0.25,
        b: Annotated[object, ParameterSpec()] = 3.0,
        c: Annotated[object, ParameterSpec()] = 0.05,
        d: Annotated[object, ParameterSpec()] = 0.5,
    ) -> None:
        super().__init__(label, visual=visual)
        self.x = x
        self.y = y
        self.z = z
        self.w = w
        self.a = a
        self.b = b
        self.c = c
        self.d = d

    def _get_laws(self, s: SimpleNamespace) -> list[BaseLaw]:
        """Return the rates of the four coordinates.

        Args:
            s:
                The namespace of the symbols the laws can use.

        Returns:
            laws:
                The laws of the element.
        """
        return [
            RateLaw(s.x, -(s.y + s.z)),
            RateLaw(s.y, s.x + s.a * s.y + s.w),
            RateLaw(s.z, s.b + s.x * s.z),
            RateLaw(s.w, s.c * s.w - s.d * s.z),
        ]

Equations

rossler.x: diff(x_rossler(t), t) == -y_rossler(t) - z_rossler(t)
rossler.y: diff(y_rossler(t), t) == a_rossler*y_rossler(t) + w_rossler(t) + x_rossler(t)
rossler.z: diff(z_rossler(t), t) == x_rossler(t)*z_rossler(t) + b_rossler
rossler.w: diff(w_rossler(t), t) == c_rossler*w_rossler(t) - d_rossler*z_rossler(t)