Simple Harmonic Motion

Math essence

For every cell (i, j): a = -k*x - c*v (and optionally -coupling * laplacian(x)). Integrate via semi-implicit Euler: v += a*dt; x += v*dt with dt = 0.05. Every impulse_period steps, v[centre, centre] += impulse. Render reads x as colour amplitude and v as motion depth.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/akten_quayola/SimpleHarmonicMotion/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


class SimpleHarmonicMotion:
    """Simple Harmonic Motion — Memo Akten, 2011–ongoing.

    A grid of damped harmonic oscillators.  Each cell carries a 1D oscillator
    of state ``(x, v)`` obeying  ``a = -k*x - c*v``  with spring constant
    ``k = 1`` and damping ``c`` in (0, 1).  Every step integrates a fixed
    impulse at the centre of the grid — Akten's recurring metaphor for
    "complex behaviour emerging from very simple, fully deterministic rules".

    The render maps the displacement ``x`` of every oscillator onto a
    perceptually-tuned gradient: zero displacement = warm bone, max
    displacement = deep indigo, min = pale ember.  The grid is bilinearly
    upsampled and lightly tone-mapped so a 100×100 cell field becomes a
    crisp square artwork.

    Akten writes (memo.tv/works/simple-harmonic-motion):  "A number of agents
    are created and assigned a simple behaviour … on their own each agent
    is monotonous … however the interaction of the different agent's
    behaviours create complex, rich, evolving behaviours and compositions".
    """

    family: ClassVar[str] = "akten_quayola"
    sketch: ClassVar[str] = "SimpleHarmonicMotion"

    def __init__(
        self,
        grid_n: int = 100,
        dim: int = 512,
        spring_k: float = 1.0,
        damping_c: float = 0.04,
        impulse: float = 0.6,
        impulse_period: int = 8,
        coupling: float = 0.18,
        seed: int | None = None,
        background: tuple[int, int, int] = (16, 12, 24),
        **_,
    ) -> None:
        self.grid_n = int(grid_n)
        self.dim = int(dim)
        self.spring_k = float(spring_k)
        self.damping_c = float(damping_c)
        self.impulse = float(impulse)
        self.impulse_period = max(1, int(impulse_period))
        self.coupling = float(np.clip(coupling, 0.0, 1.0))
        self.bg_color = np.array(background, dtype=np.float32)
        self.reset(seed=seed)

    def reset(self, seed: int | None = None) -> None:
        self.rng = np.random.default_rng(seed)
        self.x = self.rng.normal(scale=0.4, size=(self.grid_n, self.grid_n)).astype(np.float32)
        self.v = self.rng.normal(scale=0.2, size=(self.grid_n, self.grid_n)).astype(np.float32)
        self.t = 0
        self.phase = self.rng.uniform(0.0, np.pi * 2.0, size=(self.grid_n, self.grid_n)).astype(np.float32)