Ikeda delay equation

The Ikeda delay equation x' = a sin x(t - tau) in the form of Dilão (2023, Exercise 6.4).

• Name: ikeda
• Field: mathematics/dynamical_systems
• Formalism: ordinary differential equations
• References: Ikeda and Matsumoto 1987; Dilão 2023

Select this system

from skcomplex.systems import create_simulation, create_system, describe

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

Factory

@register_system(
    field='mathematics/dynamical_systems',
    tags=('delay', 'dde', 'hopf bifurcation', 'oscillation'),
    references=('Ikeda and Matsumoto 1987', 'Dilão 2023'),
    defaults={'until': 100.0, 'dt': 0.1},
)
def ikeda(x: float = 2.0, *, a: float = 1.0, tau: float = 2.0) -> System:
    """Return the Ikeda delay equation `x' = a sin x(t - tau)` in the form of Dilão (2023, Exercise 6.4).

    The rest points `x = k π` alternate in stability for `a > 0`: those of odd `k` attract while `a tau < π / 2`, and
    lose stability to an oscillation in a Hopf bifurcation at `a tau = π / 2`. The history before the start is the
    initial value.

    Args:
        x:
            The initial value, also its history.

        a:
            The gain of the delayed feedback.

        tau:
            The delay.

    Returns:
        system:
            The system, with the state `ikeda.x`.

    Examples:
        >>> from skcomplex.systems.mathematics.dynamical_systems import ikeda
        >>> ikeda(tau=1.0).elements[0].tau
        1.0
    """
    return System(elements=[IkedaElement('ikeda', x=x, a=a, tau=tau)])

Components

Elements:

• IkedaElement, from Element

class IkedaElement(Element):
    """Ikeda delay equation `x' = a sin x(t - tau)`, which oscillates about its stable rest point once `a tau > π / 2`.

    Args:
        label:
            The label of the element.

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

        x:
            The initial value, also its history.

        a:
            The gain of the delayed feedback.

        tau:
            The delay.

    Examples:
        >>> from skcomplex.systems.mathematics.dynamical_systems import IkedaElement
        >>> IkedaElement('ikeda', tau=2.0).tau
        2.0
    """

    def __init__(
        self,
        label: str,
        visual: VisualSpec | None = None,
        *,
        x: Annotated[float, StateSpec()] = 2.0,
        a: Annotated[float, ParameterSpec()] = 1.0,
        tau: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 2.0,
    ) -> None:
        super().__init__(label, visual=visual)
        self.x = x
        self.a = a
        self.tau = tau

    def _get_laws(self, s: SimpleNamespace) -> list[BaseLaw]:
        """Return the delayed feedback of the state.

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

        Returns:
            laws:
                The laws of the element.
        """
        return [RateLaw(s.x, s.a * sin(delayed(s.x, s.tau)))]

Equations

ikeda.x: diff(x_ikeda(t), t) == a_ikeda*sin(x_ikeda(t - tau_ikeda))