INDEX OF PLATES

// FORMA — PL. 01 · LISSAJOUS FIGURE — Nathaniel Bowditch, 1815 · Jules Lissajous, 1857
//   x(u) = A·sin(a·u + δ)
//   y(u) = B·sin(b·u)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=lissajous

float p_a     = 3;         // 1 .. 12  · a — horizontal frequency
float p_b     = 4;         // 1 .. 12  · b — vertical frequency
float p_delta = 0.6;       // 0 .. 3.14  · δ — phase offset

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// One closed period of the figure: u over 2π at unit amplitude. Integer
// frequencies close the curve; the phase δ tilts it out of degeneracy.
int forma_n = 1600;

float TAU = 6.28318530718;
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float u = float(i) / float(forma_n) * TAU;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(sin(p_a * u + p_delta), -sin(p_b * u), 0.0));
    // colour sweeps the bright lobe of the ramp along the curve
    float uu = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * uu));
    addvertex(0, prim, pt);
}

// FORMA — PL. 02 · RHODONEA — Guido Grandi, c. 1723
//   r(θ) = cos(k·θ),  k = n/d
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=rose

float p_n = 5;         // 1 .. 13  · n — numerator
float p_d = 4;         // 1 .. 13  · d — denominator

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// r = cos(k·θ) with k = n/d closes after d full turns of θ, tracing every
// petal exactly once — the same span the plate walks.
int forma_n = 4000;

int   nn = int(p_n), dd = int(p_d);
float k = float(nn) / float(dd);
float turns = 6.28318530718 * float(dd);
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float th = float(i) / float(forma_n) * turns;
    float r  = cos(k * th);
    // canvas y runs down; negated so the curve sits as the plate shows it
    int pt = addpoint(0, set(r * cos(th), -r * sin(th), 0.0));
    // colour sweeps the bright lobe of the ramp along the curve
    float u = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 03 · EPITROCHOID — Albrecht Dürer, 1525 · Ptolemaic tradition
//   x(θ) = (R+r)·cos θ − h·cos(((R+r)/r)·θ)
//   y(θ) = (R+r)·sin θ − h·sin(((R+r)/r)·θ)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=epitrochoid

float p_R = 8;         // 1 .. 14  · R — fixed circle
float p_r = 3;         // 1 .. 14  · r — rolling circle
float p_h = 5;         // 1 .. 14  · h — pen offset

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// The pen closes after r full turns of the rolling contact — θ spans 2π·r,
// tracing every loop of the figure once, as the plate does.
int forma_n = 5000;

float TAU = 6.28318530718;
int   rr = int(rint(p_r));
float ratio = (p_R + p_r) / p_r;
float turns = TAU * float(rr);
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float th = float(i) / float(forma_n) * turns;
    float x = (p_R + p_r) * cos(th) - p_h * cos(ratio * th);
    float y = (p_R + p_r) * sin(th) - p_h * sin(ratio * th);
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    // colour sweeps the bright lobe of the ramp along the curve
    float u = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 04 · SUPERFORMULA — Johan Gielis, 2003
//   r(φ) = ( |cos(mφ/4)/a|^n₂ + |sin(mφ/4)/b|^n₃ )^(−1/n₁)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=superformula

float p_m  = 7;         // 1 .. 20  · m — rotational symmetry
float p_n1 = 0.6;       // 0.2 .. 8  · n₁
float p_n2 = 1.7;       // 0.2 .. 8  · n₂
float p_n3 = 1.7;       // 0.2 .. 8  · n₃
float p_a  = 1;         // 0.2 .. 3  · a — first semi-axis
float p_b  = 1;         // 0.2 .. 3  · b — second semi-axis

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// Gielis's operator in polar form, one closed sweep of φ. a and b are the
// semi-axes the published operator divides by; unequal values are where the
// stretched starfish and diatom forms live. A non-finite r (n₁ near zero at
// a cusp) plots as the origin, exactly as the plate treats it.
int forma_n = 2400;

float TAU = 6.28318530718;
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float phi = float(i) / float(forma_n) * TAU;
    float ta = pow(abs(cos(p_m * phi / 4.0) / p_a), p_n2);
    float tb = pow(abs(sin(p_m * phi / 4.0) / p_b), p_n3);
    float r = pow(ta + tb, -1.0 / p_n1);
    if (!isfinite(r)) r = 0.0;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(r * cos(phi), -r * sin(phi), 0.0));
    // colour sweeps the bright lobe of the ramp along the curve
    float u = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 05 · HARMONOGRAPH — Hugh Blackburn, 1844
//   x(t) = Σ Aᵢ·sin(fᵢ·t + φᵢ)·e^(−dᵢ·t)
//   y(t) = Σ Aⱼ·sin(fⱼ·t + φⱼ)·e^(−dⱼ·t)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=harmonograph

float p_f1 = 2.01;      // 1 .. 8  · f₁
float p_f2 = 3;         // 1 .. 8  · f₂
float p_f3 = 3.01;      // 1 .. 8  · f₃
float p_f4 = 2;         // 1 .. 8  · f₄
float p_d  = 0.006;     // 0.001 .. 0.03  · damping

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// Two damped sines per axis at unit amplitude, the second pendulum damped
// 1.4× harder — the plate's own ratio. The path is open: a harmonograph
// spirals inward as the pendulums die, it never closes.
int   forma_n  = 12000;
float forma_dt = 0.06;

int prim = addprim(0, "polyline");
for (int i = 0; i < forma_n; i++){
    float u  = float(i) * forma_dt;
    float e1 = exp(-p_d * u);
    float e2 = exp(-p_d * 1.4 * u);
    float x = sin(p_f1 * u) * e1 + sin(p_f2 * u) * e2;
    float y = sin(p_f3 * u) * e1 + sin(p_f4 * u) * e2;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    // colour sweeps the bright lobe of the ramp along the path
    float uu = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * uu));
    addvertex(0, prim, pt);
}

// FORMA — PL. 06 · PHYLLOTAXIS — Helmut Vogel, 1979 · after Kepler and Bravais
//   θ(n) = n · 137.508°
//   r(n) = c · nᵏ,  k = ½ for equal area
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=phyllotaxis

float p_angle = 137.508;   // 137 .. 138  · divergence angle (°)
float p_n     = 1400;      // 200 .. 3000  · floret count
float p_expo  = 0.5;       // 0.3 .. 0.8  · k — radial exponent

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// Vogel's spiral as a point cloud: floret i sits at angle i·137.508° and
// radius (i/n)^k, so the disc fills the unit circle. k = ½ is the equal-area
// packing; below it the florets crowd the rim, above it the centre — the
// whole disc restructures. pscale mirrors the plate's growing floret size.
int nf = int(p_n);
float ga = radians(p_angle);
for (int i = 1; i <= nf; i++){
    float u  = float(i) / float(nf);
    float th = float(i) * ga;
    float r  = pow(u, p_expo);
    // canvas y runs down; negated so the spiral winds as the plate shows it
    int pt = addpoint(0, set(r * cos(th), -r * sin(th), 0.0));
    // the full ramp, as the plate sweeps it — the dark mid-radius ring is
    // the palette's own trough reading as contour on a dense disc
    setpointattrib(0, "Cd", pt, forma_ramp(u));
    setpointattrib(0, "pscale", pt, (0.6 + 1.6 * u) / 150.0);
}

// FORMA — PL. 07 · LORENZ ATTRACTOR — Edward Lorenz, 1963
//   ẋ = σ(y − x)
//   ẏ = x(ρ − z) − y
//   ż = xy − βz
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=lorenz

float p_sigma = 10;        // 4 .. 20  · σ — Prandtl
float p_rho   = 28;        // 14 .. 60  · ρ — Rayleigh
float p_beta  = 2.667;     // 0.5 .. 5  · β — geometry

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Euler integration matching the plate: dt = 0.005, 18000 steps, the first
// 400 discarded — the walk toward the attractor is not the attractor.
int   forma_steps = 18000;
int   forma_skip  = 400;
float forma_dt    = 0.005;

// Lorenz's z is conventionally the vertical; mapped onto Houdini's y-up.
float x = 0.1, y = 0.0, z = 0.0;
int prim = addprim(0, "polyline");
for (int i = 0; i < forma_steps; i++){
    float dx = p_sigma * (y - x);
    float dy = x * (p_rho - z) - y;
    float dz = x * y - p_beta * z;
    x += dx * forma_dt;  y += dy * forma_dt;  z += dz * forma_dt;
    if (i <= forma_skip) continue;
    int pt = addpoint(0, set(x, z, y));
    // colour sweeps the bright lobe of the ramp along the path
    float u = float(i - forma_skip) / float(forma_steps - forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 08 · DE JONG MAP — Peter de Jong, popularised 1980s
//   xₙ₊₁ = sin(a·yₙ) − cos(b·xₙ)
//   yₙ₊₁ = sin(c·xₙ) − cos(d·yₙ)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=dejong

float p_a = 1.641;     // -3 .. 3  · a
float p_b = 1.902;     // -3 .. 3  · b
float p_c = 0.316;     // -3 .. 3  · c
float p_d = 1.525;     // -3 .. 3  · d

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The exposure replayed as a point cloud: iterate from (0.1, 0.1) and discard
// the first 20 landings, as the plate's expose() does — the walk toward the
// attractor is not the attractor.
int forma_pts  = 120000;
int forma_skip = 20;

float x = 0.1, y = 0.1;
for (int i = 0; i < forma_pts + forma_skip; i++){
    float nx = sin(p_a * y) - cos(p_b * x);
    float ny = sin(p_c * x) - cos(p_d * y);
    x = nx;  y = ny;
    if (i < forma_skip) continue;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    // colour sweeps the bright lobe of the ramp across the exposure
    float u = float(i) / float(forma_pts + forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 09 · CLIFFORD MAP — Clifford A. Pickover
//   xₙ₊₁ = sin(a·yₙ) + c·cos(a·xₙ)
//   yₙ₊₁ = sin(b·xₙ) + d·cos(b·yₙ)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=clifford

float p_a = -1.4;      // -3 .. 3  · a
float p_b = 1.6;       // -3 .. 3  · b
float p_c = 1;         // -2 .. 2  · c
float p_d = 0.7;       // -2 .. 2  · d

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The exposure replayed as a point cloud: iterate from (0.1, 0.1) and discard
// the first 20 landings, as the plate's expose() does.
int forma_pts  = 120000;
int forma_skip = 20;

float x = 0.1, y = 0.1;
for (int i = 0; i < forma_pts + forma_skip; i++){
    float nx = sin(p_a * y) + p_c * cos(p_a * x);
    float ny = sin(p_b * x) + p_d * cos(p_b * y);
    x = nx;  y = ny;
    if (i < forma_skip) continue;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts + forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 10 · THOMAS ATTRACTOR — René Thomas, 1999
//   ẋ = sin y − b·x
//   ẏ = sin z − b·y
//   ż = sin x − b·z
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=thomas

float p_b = 0.19;      // 0.05 .. 0.35  · b — dissipation

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Euler integration matching the plate: dt = 0.02, 30000 steps from
// (1.1, 1.2, −0.6). Thomas is cyclically symmetric in x, y and z, so the
// axes carry over to Houdini's unchanged.
int   forma_steps = 30000;
float forma_dt    = 0.02;

float x = 1.1, y = 1.2, z = -0.6;
int prim = addprim(0, "polyline");
for (int i = 0; i < forma_steps; i++){
    float dx = sin(y) - p_b * x;
    float dy = sin(z) - p_b * y;
    float dz = sin(x) - p_b * z;
    x += dx * forma_dt;  y += dy * forma_dt;  z += dz * forma_dt;
    int pt = addpoint(0, set(x, y, z));
    // colour sweeps the bright lobe of the ramp along the path
    float u = float(i) / float(forma_steps);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 11 · HÉNON MAP — Michel Hénon, 1976
//   xₙ₊₁ = 1 − a·xₙ² + yₙ
//   yₙ₊₁ = b·xₙ
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=henon

float p_a = 1.4;       // 1 .. 1.42  · a
float p_b = 0.3;       // 0.1 .. 0.4  · b

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The exposure replayed as a point cloud: iterate from (0.1, 0.1) and discard
// the first 20 landings, as the plate's expose() does. The attractor is a
// thin crescent — covering little of its box is its published shape.
int forma_pts  = 120000;
int forma_skip = 20;

float x = 0.1, y = 0.1;
for (int i = 0; i < forma_pts + forma_skip; i++){
    float nx = 1.0 - p_a * x * x + y;
    float ny = p_b * x;
    x = nx;  y = ny;
    if (i < forma_skip) continue;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts + forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 12 · IKEDA MAP — Kensuke Ikeda, 1979
//   tₙ = 0.4 − 6/(1 + xₙ² + yₙ²)
//   xₙ₊₁ = 1 + u(xₙ·cos tₙ − yₙ·sin tₙ)
//   yₙ₊₁ = u(xₙ·sin tₙ + yₙ·cos tₙ)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=ikeda

float p_u = 0.9;       // 0.6 .. 0.9  · u — dissipation

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The exposure replayed as a point cloud: iterate from (0.1, 0.1) and discard
// the first 20 landings, as the plate's expose() does.
int forma_pts  = 120000;
int forma_skip = 20;

float x = 0.1, y = 0.1;
for (int i = 0; i < forma_pts + forma_skip; i++){
    float tn = 0.4 - 6.0 / (1.0 + x * x + y * y);
    float nx = 1.0 + p_u * (x * cos(tn) - y * sin(tn));
    float ny = p_u * (x * sin(tn) + y * cos(tn));
    x = nx;  y = ny;
    if (i < forma_skip) continue;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts + forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 38 · GUMOWSKI–MIRA MAP — Igor Gumowski & Christian Mira, 1980
//   G(x) = μx + 2(1−μ)x²/(1+x²)
//   xₙ₊₁ = yₙ + α·yₙ(1 − σ·yₙ²) + G(xₙ)
//   yₙ₊₁ = −xₙ + G(xₙ₊₁)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=mira

float p_m     = -0.496;    // -0.85 .. 0.35  · μ — nonlinearity
float p_a     = 0.008;     // 0 .. 0.02  · α — dissipation
float p_sigma = 0.05;      // 0 .. 0.12  · σ — cubic term
float p_run   = 700;       // 100 .. 3000  · orbit length per seed

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Nearly conservative: each start owns its own island chain rather than
// falling onto one attractor, so the figure is many short orbits from
// scattered seeds superposed — which is what the published pictures are.
int forma_pts = 120000;

float x = 0.0, y = 0.0;
int   run = int(p_run) + 1, si = 0;   // force a seed on the first step
for (int i = 0; i < forma_pts; i++){
    if (++run > int(p_run)){
        run = 0;
        // deterministic scattered restarts, mirroring the plate's seeded rng
        float rad = 0.5 + 11.0 * random(si * 2);
        float th  = 6.28318530718 * random(si * 2 + 1);
        x = rad * cos(th);  y = rad * sin(th);
        si++;
    }
    float gx = p_m * x + 2.0 * (1.0 - p_m) * x * x / (1.0 + x * x);
    float nx = y + p_a * y * (1.0 - p_sigma * y * y) + gx;
    float gn = p_m * nx + 2.0 * (1.0 - p_m) * nx * nx / (1.0 + nx * nx);
    float ny = -x + gn;      // the old x — the map reads it before it moves
    x = nx;  y = ny;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 39 · HOPALONG — Barry Martin, 1986
//   xₙ₊₁ = yₙ − sign(xₙ)·√|b·xₙ − c|
//   yₙ₊₁ = a − xₙ
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=hopalong

float p_a = 2;         // -10 .. 10  · a
float p_b = 1;         // 0.05 .. 3  · b
float p_c = 0;         // 0 .. 8  · c

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The plate measures the orbit's extent to size its window, then replays the
// same orbit; geometry needs no window, so this is the orbit itself — one
// deterministic walk from the origin, growing ring by ring.
int forma_pts = 220000;

float x = 0.0, y = 0.0;
for (int i = 0; i < forma_pts; i++){
    float nx = y - sign(x) * sqrt(abs(p_b * x - p_c));
    y = p_a - x;
    x = nx;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 40 · CHIRIKOV STANDARD MAP — Boris Chirikov, 1969
//   pₙ₊₁ = pₙ + K·sin θₙ  (mod 2π)
//   θₙ₊₁ = θₙ + pₙ₊₁  (mod 2π)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=standard

float p_K   = 0.972;     // 0.1 .. 2.6  · K — kick strength
float p_run = 400;       // 50 .. 2000  · orbit length per seed

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Area-preserving, so there is no attractor to fall onto — every start keeps
// its own orbit forever. Short runs from scattered seeds are the honest
// rendering: islands close into rings, chaos arrives as speckle.
int forma_pts = 120000;

float TAU = 6.28318530718;
float th = 0.0, pn = 0.0;
int   run = int(p_run) + 1, si = 0;   // force a seed on the first step
for (int i = 0; i < forma_pts; i++){
    if (++run > int(p_run)){
        run = 0;
        // deterministic scattered restarts, mirroring the plate's seeded rng
        th = TAU * random(si * 2);
        pn = TAU * random(si * 2 + 1);
        si++;
    }
    pn = pn + p_K * sin(th);
    pn = pn - TAU * floor(pn / TAU);
    th = th + pn;
    th = th - TAU * floor(th / TAU);
    // canvas y runs down; flipped within the torus square to match the plate
    int pt = addpoint(0, set(th, TAU - pn, 0.0));
    float u = float(i) / float(forma_pts);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 41 · RÖSSLER ATTRACTOR — Otto Rössler, 1976
//   ẋ = −y − z
//   ẏ = x + a·y
//   ż = b + z(x − c)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=rossler

float p_a = 0.2;       // 0.1 .. 0.32  · a — spiral gain
float p_b = 0.2;       // 0.1 .. 1  · b — lift
float p_c = 5.7;       // 4.5 .. 8.5  · c — fold

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Euler integration matching the plate: dt = 0.015, 30000 steps from
// (0.1, 0, 0), the first 600 discarded as transient. The same guard as the
// plate: constants jittered onto an escaping transient fold back to the
// start rather than filling the path with infinities.
int   forma_steps = 30000;
int   forma_skip  = 600;
float forma_dt    = 0.015;

// Rössler's z is the fold's lift, conventionally vertical; mapped onto
// Houdini's y-up.
float x = 0.1, y = 0.0, z = 0.0;
int prim = addprim(0, "polyline");
for (int i = 0; i < forma_steps; i++){
    float dx = -y - z;
    float dy = x + p_a * y;
    float dz = p_b + z * (x - p_c);
    x += dx * forma_dt;  y += dy * forma_dt;  z += dz * forma_dt;
    if (!isfinite(x + y + z) || abs(x) > 400.0){ x = 0.1; y = 0.0; z = 0.0; }
    if (i <= forma_skip) continue;
    int pt = addpoint(0, set(x, z, y));
    // colour sweeps the bright lobe of the ramp along the path
    float u = float(i - forma_skip) / float(forma_steps - forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 43 · MAURER ROSE — Peter M. Maurer, 1987
//   rose: r = sin(n·θ)
//   walk: θₖ = k·d°,  k = 0 … 360
//   join consecutive walk points with chords
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=maurer

float p_n = 6;         // 2 .. 8  · n — rose harmonic
float p_d = 71;        // 1 .. 179  · d — stride (deg)

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// Two layers, as the plate draws them: the rose itself faint underneath, so
// the walk reads as chords of something — then the Maurer walk, 360 strides
// of d° joined point to point. Alpha carries the plate's own layering.
int forma_rose = 720;

float TAU = 6.28318530718;
int   n = int(rint(p_n));
// the rose, faint
int under = addprim(0, "polyline");
for (int i = 0; i <= forma_rose; i++){
    float th = float(i) / float(forma_rose) * TAU;
    float r  = sin(float(n) * th);
    // canvas y runs down; negated so the petals sit as the plate shows them
    int pt = addpoint(0, set(r * cos(th), -r * sin(th), 0.0));
    setpointattrib(0, "Cd", pt, forma_ramp(0.95));
    setpointattrib(0, "Alpha", pt, 0.14);
    addvertex(0, under, pt);
}
// the walk: closed after 360 strides, since 360·d° is a whole number of turns
int walk = addprim(0, "polyline");
for (int k = 0; k <= 360; k++){
    float th = float(k) * p_d * TAU / 360.0;
    float r  = sin(float(n) * th);
    int pt = addpoint(0, set(r * cos(th), -r * sin(th), 0.0));
    // colour runs along the walk inside the bright lobe of the ramp
    float u = float(k) / 360.0;
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    setpointattrib(0, "Alpha", pt, 1.0);
    addvertex(0, walk, pt);
}

// FORMA — PL. 44 · CARDIOID CHORD ENVELOPE — Luigi Cremona, 1862 · string-art tradition
//   N points on a circle: Pₖ = e^(2πik/N)
//   chord: Pₖ → P₍m·k mod N₎
//   envelope: an epicycloid with m − 1 cusps
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=cremona

float p_m   = 2;         // 2 .. 8  · m — multiplier
float p_n   = 200;       // 80 .. 320  · N — points
float p_off = 0;         // 0 .. 80  · shift — k·m + s

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// String art on N nails: chord k → m·k + s for every k. The envelope is
// never drawn — the eye finds it where neighbouring chords crowd. A
// non-integer m lets the family slide between the classic figures; the
// additive shift s is a second family from the same nails.
int forma_circ = 128;

float TAU = 6.28318530718;
int n = int(rint(p_n));
// the nail circle, faint, as the plate strokes it
int circ = addprim(0, "polyline");
for (int i = 0; i <= forma_circ; i++){
    float th = float(i) / float(forma_circ) * TAU;
    int pt = addpoint(0, set(cos(th), -sin(th), 0.0));
    setpointattrib(0, "Cd", pt, forma_ramp(0.95));
    setpointattrib(0, "Alpha", pt, 0.22);
    addvertex(0, circ, pt);
}
// the chords — one two-point polyline each, colour running along k inside
// the bright lobe of the ramp
for (int k = 1; k <= n; k++){
    float a0 = float(k) * TAU / float(n);
    float a1 = (float(k) * p_m + p_off) % float(n) * TAU / float(n);
    vector col = forma_ramp(0.84 + 0.2 * float(k) / float(n));
    int chord = addprim(0, "polyline");
    // canvas y runs down; negated so the cusps sit as the plate shows them
    int pa = addpoint(0, set(cos(a0), -sin(a0), 0.0));
    int pb = addpoint(0, set(cos(a1), -sin(a1), 0.0));
    setpointattrib(0, "Cd", pa, col);
    setpointattrib(0, "Cd", pb, col);
    setpointattrib(0, "Alpha", pa, 0.38);
    setpointattrib(0, "Alpha", pb, 0.38);
    addvertex(0, chord, pa);
    addvertex(0, chord, pb);
}

// FORMA — PL. 45 · EULER SPIRAL — Leonhard Euler, 1744 · Alfred Cornu, 1874
//   κ(s) = sᵏ⁻¹,  k = 2 is the Euler spiral
//   x(s) = ∫₀ˢ cos(uᵏ/k) du
//   y(s) = ∫₀ˢ sin(uᵏ/k) du
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=clothoid

float p_len  = 4.6;       // 2.5 .. 7  · arc length
float p_expo = 2;         // 1.2 .. 4  · k — curvature exponent

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// The generalised Fresnel pair integrated with midpoint steps: curvature
// grows as s^(k−1), and k = 2 is the classic Euler spiral. The second arm is
// the first rotated half a turn — exact at k = 2, where the integrand pair
// is odd, and kept as the figure's symmetry elsewhere.
int forma_n = 1100;

float ds = p_len / float(forma_n);
float hx[], hy[];
float x = 0.0, y = 0.0;
for (int i = 0; i <= forma_n; i++){
    push(hx, x);  push(hy, y);
    float s = (float(i) + 0.5) * ds;
    x += cos(pow(s, p_expo) / p_expo) * ds;
    y += sin(pow(s, p_expo) / p_expo) * ds;
}
// second arm first, reversed, so the polyline runs end to end through zero
int prim = addprim(0, "polyline");
int total = 2 * forma_n + 1;
for (int i = 0; i < total; i++){
    int   j = i - forma_n;                       // −n … n
    float sgn = j < 0 ? -1.0 : 1.0;
    int   a = abs(j);
    // canvas y runs down; negated so the spiral winds as the plate shows it
    int pt = addpoint(0, set(sgn * hx[a], -sgn * hy[a], 0.0));
    // colour sweeps the bright lobe of the ramp along the curve
    float u = float(i) / float(total - 1);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 60 · DOUBLE PENDULUM — Classical Lagrangian mechanics · after Euler and Lagrange
//   two rods, two bobs, one pivot
//   θ̈₁, θ̈₂ from the Euler–Lagrange equations
//   no closed form — the motion must be integrated
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=pendulum

float p_mass   = 1;         // 0.3 .. 2  · m₂ / m₁
float p_len    = 1;         // 0.5 .. 1.5  · l₂ / l₁
float p_launch = 0.55;      // 0.2 .. 0.95  · launch angle (× π)

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// The Euler–Lagrange equations for two rods under RK4, m₁ = l₁ = 1, and the
// second bob's trail emitted as the path. In a chaotic system the launch
// angle is the parameter: low energy gives a lazy lissajous trail, high
// enough gives full flips.
int   forma_steps = 6000;    // dt = 0.01, recording every second step
float forma_dt    = 0.01;
float forma_g     = 9.81;

vector4 forma_deriv(vector4 st; float m2, l2, g){
    float a1 = st.x, a2 = st.y, w1 = st.z, w2 = st.w;
    float d = a1 - a2;
    float den = 2.0 + m2 - m2 * cos(2.0 * d);
    float dw1 = (-g * (2.0 + m2) * sin(a1) - m2 * g * sin(a1 - 2.0 * a2)
                 - 2.0 * sin(d) * m2 * (w2 * w2 * l2 + w1 * w1 * cos(d))) / den;
    float dw2 = (2.0 * sin(d) * (w1 * w1 * (1.0 + m2) + g * (1.0 + m2) * cos(a1)
                 + w2 * w2 * l2 * m2 * cos(d))) / (l2 * den);
    return set(w1, w2, dw1, dw2);
}

vector4 st = set(3.14159265359 * p_launch, 3.14159265359 * 0.95, 0.0, 0.0);
int prim = addprim(0, "polyline");
for (int i = 0; i < forma_steps; i++){
    vector4 k1 = forma_deriv(st, p_mass, p_len, forma_g);
    vector4 k2 = forma_deriv(st + k1 * forma_dt / 2.0, p_mass, p_len, forma_g);
    vector4 k3 = forma_deriv(st + k2 * forma_dt / 2.0, p_mass, p_len, forma_g);
    vector4 k4 = forma_deriv(st + k3 * forma_dt, p_mass, p_len, forma_g);
    st += (k1 + 2.0 * k2 + 2.0 * k3 + k4) * forma_dt / 6.0;
    if (!isfinite(st.x) || !isfinite(st.y)) break;
    if (i % 2 == 0) continue;
    // the tip in world terms: rods hang downward, Houdini y-up
    float tx = sin(st.x) + p_len * sin(st.y);
    float ty = -(cos(st.x) + p_len * cos(st.y));
    int pt = addpoint(0, set(tx, ty, 0.0));
    // colour sweeps the bright lobe of the ramp along the trail
    float u = float(i) / float(forma_steps);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 61 · THREE-BODY FIGURE-EIGHT — Cristopher Moore, 1993 · Chenciner & Montgomery, 2000
//   ẍᵢ = Σⱼ (xⱼ − xᵢ)/|xⱼ − xᵢ|³
//   three equal masses, one shared orbit
//   x₁(t) = x₂(t + T/3) = x₃(t + 2T/3)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=threebody

float p_speed = 0.8;       // 0.2 .. 2  · orbit rate
float p_tail  = 0.5;       // 0.1 .. 0.9  · comet length

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// Simó's initial conditions for the figure-eight, one full period under RK4.
// The curve is shared: bodies 2 and 3 ride the same points a third of a lap
// apart, so one closed polyline is the whole choreography.
// waived: speed, tail — they pace the plate's comet, and geometry has no clock
int   forma_n = 3000;
float forma_T = 6.32591398;

function float[] forma_accel(float s0[]){
    float d[];
    resize(d, 12);
    for (int i = 0; i < 3; i++){ d[i * 2] = s0[6 + i * 2]; d[i * 2 + 1] = s0[7 + i * 2]; }
    for (int i = 0; i < 3; i++){
        float ax = 0.0, ay = 0.0;
        for (int j = 0; j < 3; j++){
            if (i == j) continue;
            float dx = s0[j * 2] - s0[i * 2], dy = s0[j * 2 + 1] - s0[i * 2 + 1];
            float r = sqrt(dx * dx + dy * dy);
            ax += dx / (r * r * r);  ay += dy / (r * r * r);
        }
        d[6 + i * 2] = ax;  d[7 + i * 2] = ay;
    }
    return d;
}
function float[] forma_step(float a[]; float b[]; float sc){
    float o[];
    resize(o, 12);
    for (int i = 0; i < 12; i++) o[i] = a[i] + b[i] * sc;
    return o;
}

float st[] = { 0.97000436, -0.24308753, -0.97000436, 0.24308753, 0.0, 0.0,
               0.46620368, 0.43236573, 0.46620368, 0.43236573,
               -0.93240737, -0.86473146 };
float dt = forma_T / float(forma_n);
int prim = addprim(0, "polyline");
for (int i = 0; i < forma_n; i++){
    float k1[] = forma_accel(st);
    float k2[] = forma_accel(forma_step(st, k1, dt / 2.0));
    float k3[] = forma_accel(forma_step(st, k2, dt / 2.0));
    float k4[] = forma_accel(forma_step(st, k3, dt));
    for (int j = 0; j < 12; j++)
        st[j] += (k1[j] + 2.0 * k2[j] + 2.0 * k3[j] + k4[j]) * dt / 6.0;
    // canvas y runs down; negated so the eight lies as the plate shows it
    int pt = addpoint(0, set(st[0], -st[1], 0.0));
    // colour sweeps the bright lobe of the ramp around the lap
    float u = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 69 · WEIERSTRASS FUNCTION — Karl Weierstrass, 1872 · G. H. Hardy, 1916
//   W(x) = Σ aⁿ cos(bⁿ π x)
//   0 < a < 1, b odd integer, ab > 1 + 3π/2  (Weierstrass, 1872)
//   0 < a < 1, b real, ab ≥ 1  (Hardy, 1916)
//   continuous everywhere · differentiable nowhere
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=weierstrass

float p_a = 0.55;      // 0.34 .. 0.68  · a — amplitude ratio
float p_b = 5;         // 3 .. 9  · b — frequency ratio

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// Continuous everywhere, differentiable nowhere. Depth is bounded by what
// the samples can hold: bⁿ stays under a quarter of the sample count so the
// top term still renders as oscillation rather than aliasing into noise the
// mathematics never contained — the plate's own ceiling.
int forma_n = 1600;

int terms = max(2, int(floor(1.0 + log(float(forma_n) / 4.0) / log(p_b))));
// Σ|aⁿ| — normalising by it keeps every (a, b) on the same amplitude
float norm = (1.0 - pow(p_a, terms)) / (1.0 - p_a);
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float x = float(i) / float(forma_n) * 2.0 - 1.0;
    float y = 0.0;
    for (int k = 0; k < terms; k++)
        y += pow(p_a, k) * cos(pow(p_b, k) * 3.14159265359 * x);
    // the graph is drawn y-up already; no flip needed
    int pt = addpoint(0, set(x, y / norm, 0.0));
    // colour sweeps the bright lobe of the ramp along the graph
    float u = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 70 · TAKAGI CURVE — Teiji Takagi, 1901
//   T(x) = Σ wⁿ s(2ⁿ x)
//   s(x) = distance from x to the nearest integer
//   w = ½ is the blancmange
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=takagi

float p_w = 0.5;       // 0.4 .. 0.8  · w — term weight

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// The blancmange at full depth: ten tent-map terms, which is the sample
// floor — 2¹⁰ oscillations across 1400 samples is where the top term stops
// rendering as shape. The plate reveals the terms one by one; the geometry
// is the finished pathology.
int forma_n   = 1400;
int forma_top = 10;

// peak of Σ wⁿ·s(2ⁿx) is bounded by Σ wⁿ/2; normalising keeps every weight
// on the same baseline
float norm = (1.0 - pow(p_w, forma_top)) / (1.0 - p_w) * 0.5;
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float x = float(i) / float(forma_n);
    float y = 0.0;
    for (int k = 0; k < forma_top; k++){
        float sx = x * pow(2.0, k);      // VEX has no shift operator
        y += pow(p_w, k) * abs(sx - rint(sx));
    }
    // the graph is drawn y-up already; no flip needed
    int pt = addpoint(0, set(x, y / norm, 0.0));
    // colour sweeps the bright lobe of the ramp along the graph
    float u = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 73 · GIBBS PHENOMENON — Henry Wilbraham, 1848 · J. Willard Gibbs, 1899 · named by Maxime Bôcher, 1906
//   fₙ(x) = (4/π) Σₖ₌₁ⁿ sin((2k−1)x)/(2k−1)
//   peak → (2/π)·Si(π) ≈ 1.178980
//   overshoot → 0.0894899 of the jump
//   it never dies — it only narrows
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=gibbs

float p_terms  = 24;        // 1 .. 48  · n — odd harmonics
float p_cycles = 2;         // 1 .. 4  · cycles shown

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// The square wave faint underneath — the structure the sums are chasing —
// and the partial sum over it, normalised so the square sits at ±1. The
// horns overshoot by design: ~8.9% of the jump, and adding terms only
// narrows them. It never dies. Alpha carries the plate's own layering.
int forma_n = 1200;

float TAU = 6.28318530718;
int terms = max(1, int(rint(p_terms)));
// the target square wave, faint
int under = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float x = p_cycles * TAU * float(i) / float(forma_n);
    float s = sin(x);
    float sq = s == 0.0 ? 1.0 : sign(s);
    int pt = addpoint(0, set(float(i) / float(forma_n), sq, 0.0));
    setpointattrib(0, "Cd", pt, forma_ramp(0.95));
    setpointattrib(0, "Alpha", pt, 0.16);
    addvertex(0, under, pt);
}
// the partial sum — the graph is drawn y-up already; no flip needed
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    float x = p_cycles * TAU * float(i) / float(forma_n);
    float y = 0.0;
    for (int k = 1; k <= terms; k++)
        y += sin(float(2 * k - 1) * x) / float(2 * k - 1);
    int pt = addpoint(0, set(float(i) / float(forma_n), y * 4.0 / 3.14159265359, 0.0));
    setpointattrib(0, "Cd", pt, forma_ramp(0.94));
    setpointattrib(0, "Alpha", pt, 1.0);
    addvertex(0, prim, pt);
}

// FORMA — PL. 74 · RECAMÁN SEQUENCE — Bernardo Recamán Santos, 1991 · via N. J. A. Sloane
//   a₀ = s
//   aₙ = aₙ₋₁ − n   if positive and unvisited
//   aₙ = aₙ₋₁ + n   otherwise
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=recaman

float p_n     = 85;        // 40 .. 140  · strides
float p_start = 0;         // 0 .. 40  · s — start at

// The plate's own colour: FORMA's CURVES accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.11 + 0.1196 * cos(6.28318530718 * (t + 0)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.05)),
    0.2453 + 0.2667 * cos(6.28318530718 * (t + 0.1)));
}

// Subtract when you can, add when you must: the sequence on the raw integer
// line, each stride a semicircle, sides alternating — Numberphile's
// rendering, credited as such on the plate. Coordinates are the integers
// themselves; scale to taste. Alpha carries the faint number line.
int forma_arc = 24;   // segments per semicircle

int n = int(rint(p_n)), start = int(rint(p_start));
int seen[], seq[];
push(seen, start);  push(seq, start);
int a = start, hi = start;
for (int k = 1; k <= n; k++){
    int back = a - k;
    if (back > 0 && find(seen, back) < 0) a = back;
    else                                  a = a + k;
    push(seen, a);  push(seq, a);
    hi = max(hi, a);
}
// the number line, faint
int base = addprim(0, "polyline");
int b0 = addpoint(0, set(0.0, 0.0, 0.0));
int b1 = addpoint(0, set(float(hi), 0.0, 0.0));
setpointattrib(0, "Cd", b0, forma_ramp(0.95));
setpointattrib(0, "Cd", b1, forma_ramp(0.95));
setpointattrib(0, "Alpha", b0, 0.2);
setpointattrib(0, "Alpha", b1, 0.2);
addvertex(0, base, b0);
addvertex(0, base, b1);
// the strides — one semicircle each, sides alternating
for (int k = 1; k <= n; k++){
    float x1 = float(seq[k - 1]), x2 = float(seq[k]);
    float cx = (x1 + x2) / 2.0, r = abs(x2 - x1) / 2.0;
    float up  = k % 2 == 1 ? 1.0 : -1.0;     // Houdini y-up: odd strides arc up
    float dir = x2 > x1 ? 1.0 : -1.0;
    vector col = forma_ramp(0.84 + 0.2 * float(k) / float(n));
    int prim = addprim(0, "polyline");
    for (int i = 0; i <= forma_arc; i++){
        float th = 3.14159265359 * float(i) / float(forma_arc);
        int pt = addpoint(0, set(cx - dir * r * cos(th), up * r * sin(th), 0.0));
        setpointattrib(0, "Cd", pt, col);
        setpointattrib(0, "Alpha", pt, 0.62);
        addvertex(0, prim, pt);
    }
}

// FORMA — PL. 75 · UEDA ATTRACTOR — Yoshisuke Ueda, 1961
//   ẍ + k·ẋ + x³ = B·cos t
//   the Poincaré section: (x, ẋ) sampled once per drive period
//   k = 0.05, B = 7.5 is Ueda’s own set
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=ueda

float p_k = 0.05;      // 0.02 .. 0.078  · k — damping
float p_B = 7.5;       // 6.95 .. 8.05  · B — drive

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The Poincaré section of the driven Duffing oscillator: integrate one drive
// period of 2π, keep one point, repeat. RK4 rather than Euler — the cubic
// restoring term is stiff enough near the turning points that a first-order
// step drifts off the sheet and draws a band fatter than the system has.
// 32 substeps a period and 200 settle periods, as the plate measured.
int forma_sec    = 30000;   // section points
int forma_settle = 200;     // drive periods of transient to discard
int forma_sub    = 32;      // RK4 substeps per period

vector2 forma_f(float tt, xx, yy, k, B){
    return set(yy, -k * yy - xx * xx * xx + B * cos(tt));
}

float x = 0.1, y = 0.1;
float dt = 6.28318530718 / float(forma_sub);
for (int n = 0; n < forma_sec + forma_settle; n++){
    // VEX floats are 32-bit: a running clock loses the drive phase by the
    // thousandth period, smearing the section. The drive is 2π-periodic, so
    // the phase restarts at zero each period — exact by construction.
    float tt = 0.0;
    for (int i = 0; i < forma_sub; i++){
        vector2 a = forma_f(tt, x, y, p_k, p_B);
        vector2 b = forma_f(tt + dt / 2.0, x + a.x * dt / 2.0, y + a.y * dt / 2.0, p_k, p_B);
        vector2 c = forma_f(tt + dt / 2.0, x + b.x * dt / 2.0, y + b.y * dt / 2.0, p_k, p_B);
        vector2 d = forma_f(tt + dt, x + c.x * dt, y + c.y * dt, p_k, p_B);
        x += dt / 6.0 * (a.x + 2.0 * b.x + 2.0 * c.x + d.x);
        y += dt / 6.0 * (a.y + 2.0 * b.y + 2.0 * c.y + d.y);
        tt += dt;
    }
    // the walk onto the attractor is not the attractor
    if (n < forma_settle) continue;
    // canvas y runs down; negated so the section sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(n - forma_settle) / float(forma_sec);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 76 · VAN DER POL OSCILLATOR — Balthasar van der Pol, 1926
//   ẍ − μ(1 − x²)ẋ + x = 0
//   drawn as the phase portrait (x, ẋ)
//   μ → 0 a circle · μ large a relaxation oscillation
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=vanderpol

float p_mu = 1.6;       // 0.2 .. 6  · μ — nonlinearity

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The limit cycle in the phase plane (x, ẋ): settle 120 time units onto the
// cycle, then record from one upward crossing of ẋ = 0 to the next, so the
// loop closes on a real point of the orbit rather than wherever recording
// happened to stop. Decimated, as the plate is, so the polyline carries the
// cycle rather than the integrator's step count.
int   forma_settle = 60000;
int   forma_max    = 40000;
int   forma_n      = 900;
float forma_dt     = 0.002;

float x = 2.0, y = 0.0;
for (int i = 0; i < forma_settle; i++){
    float dy = p_mu * (1.0 - x * x) * y - x;
    x += y * forma_dt;  y += dy * forma_dt;
}
// walk to an upward crossing of ẋ = 0
for (int i = 0; i < forma_max; i++){
    float py = y, dy = p_mu * (1.0 - x * x) * y - x;
    x += y * forma_dt;  y += dy * forma_dt;
    if (py < 0.0 && y >= 0.0) break;
}
// record one full cycle, crossing to crossing
float rx[], ry[];
push(rx, x);  push(ry, y);
for (int i = 0; i < forma_max; i++){
    float py = y, dy = p_mu * (1.0 - x * x) * y - x;
    x += y * forma_dt;  y += dy * forma_dt;
    push(rx, x);  push(ry, y);
    if (i > 200 && py < 0.0 && y >= 0.0) break;
}
// the phase plane is drawn ẋ-up already; no flip needed
int last = len(rx) - 1;
int prim = addprim(0, "polyline");
for (int i = 0; i <= forma_n; i++){
    int j = min(last, int(rint(float(i) / float(forma_n) * float(last))));
    int pt = addpoint(0, set(rx[j], ry[j], 0.0));
    float u = float(i) / float(forma_n);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 77 · CHUA’S CIRCUIT — Leon O. Chua, 1983 · simulated by Takashi Matsumoto
//   ẋ = α(y − x − f(x))
//   ẏ = x − y + z
//   ż = −β·y
//   f(x) = m₁x + ½(m₀ − m₁)(|x+1| − |x−1|)
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=chua

float p_alpha = 15.6;      // 8.5 .. 18  · α — C₂/C₁
float p_beta  = 28;        // 20 .. 36  · β — inductance
float p_m0    = -1.143;    // -1.35 .. -0.95  · m₀ — inner slope
float p_m1    = -0.714;    // -0.85 .. -0.58  · m₁ — outer slope

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Euler integration matching the plate: dt = 0.0025, 30000 steps from
// (0.7, 0, 0), the first 3000 discarded as transient. Axes are the published
// state unchanged — note the plate scales y sixfold for display, because y
// runs an order thinner than x and z; scale to taste.
int   forma_steps = 30000;
int   forma_skip  = 3000;
float forma_dt    = 0.0025;

float x = 0.7, y = 0.0, z = 0.0;
int prim = addprim(0, "polyline");
for (int i = 0; i < forma_steps; i++){
    // Chua's diode: three straight segments, and the middle one is the
    // negative resistance that makes the whole thing go
    float fx = p_m1 * x + 0.5 * (p_m0 - p_m1) * (abs(x + 1.0) - abs(x - 1.0));
    float dx = p_alpha * (y - x - fx);
    float dy = x - y + z;
    float dz = -p_beta * y;
    x += dx * forma_dt;  y += dy * forma_dt;  z += dz * forma_dt;
    if (!isfinite(x) || !isfinite(z)) break;
    if (i <= forma_skip) continue;
    int pt = addpoint(0, set(x, y, z));
    // colour sweeps the bright lobe of the ramp along the path
    float u = float(i - forma_skip) / float(forma_steps - forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 78 · LANGFORD ATTRACTOR — William F. Langford, 1984
//   ẋ = (z − b)x − d·y
//   ẏ = d·x + (z − b)y
//   ż = c + a·z − z³/3 − (x² + y²)(1 + e·z) + f·z·x³
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=langford

float p_a = 0.95;      // 0.8 .. 1.05  · a — z gain
float p_b = 0.7;       // 0.55 .. 0.85  · b — radius
float p_c = 0.6;       // 0.45 .. 0.75  · c — lift
float p_d = 3.5;       // 2.6 .. 4.4  · d — rotation
float p_e = 0.25;      // 0.18 .. 0.32  · e — coupling
float p_f = 0.1;       // 0.04 .. 0.16  · f — fold

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Euler integration matching the plate: dt = 0.004, 34000 steps from
// (0.1, 0, 0), the first 4000 discarded as transient. The system rotates
// about its z axis, conventionally vertical; mapped onto Houdini's y-up.
int   forma_steps = 34000;
int   forma_skip  = 4000;
float forma_dt    = 0.004;

float x = 0.1, y = 0.0, z = 0.0;
int prim = addprim(0, "polyline");
for (int i = 0; i < forma_steps; i++){
    float dx = (z - p_b) * x - p_d * y;
    float dy = p_d * x + (z - p_b) * y;
    float dz = p_c + p_a * z - z * z * z / 3.0
             - (x * x + y * y) * (1.0 + p_e * z) + p_f * z * x * x * x;
    x += dx * forma_dt;  y += dy * forma_dt;  z += dz * forma_dt;
    if (!isfinite(x) || !isfinite(z)) break;
    if (i <= forma_skip) continue;
    int pt = addpoint(0, set(x, z, y));
    // colour sweeps the bright lobe of the ramp along the path
    float u = float(i - forma_skip) / float(forma_steps - forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
    addvertex(0, prim, pt);
}

// FORMA — PL. 79 · GINGERBREADMAN MAP — Robert L. Devaney, 1984
//   xₙ₊₁ = 1 − yₙ + |xₙ|
//   yₙ₊₁ = xₙ
//   area-preserving · piecewise linear
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=gingerbread

float p_run    = 150;       // 30 .. 500  · orbit length
float p_spread = 6;         // 2 .. 9  · seed spread

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Area-preserving, so no orbit ever shows more than its own region —
// the figure is the union of many short orbits from scattered seeds,
// the same treatment mira and the standard map need for the same reason.
int forma_pts = 120000;

float x = 0.0, y = 0.0;
int   run = int(p_run) + 1, si = 0;   // force a seed on the first step
for (int i = 0; i < forma_pts; i++){
    if (++run > int(p_run)){
        run = 0;
        // deterministic scattered restarts, mirroring the plate's seeded rng
        x = 1.0 + (random(si * 2) - 0.5) * p_spread;
        y = 1.0 + (random(si * 2 + 1) - 0.5) * p_spread;
        si++;
    }
    float nx = 1.0 - y + abs(x);
    y = x;
    x = nx;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 80 · ZASLAVSKY WEB MAP — George M. Zaslavsky and colleagues, 1986
//   uₙ₊₁ = (uₙ + K·sin vₙ)·cos α + vₙ·sin α
//   vₙ₊₁ = −(uₙ + K·sin vₙ)·sin α + vₙ·cos α
//   α = 2π/q
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=zaslavsky

float p_q   = 5;         // 3 .. 8  · q — fold symmetry
float p_K   = 1;         // 0.4 .. 2.2  · K — kick strength
float p_run = 240;       // 60 .. 600  · orbit length

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Area-preserving again, and again the figure is the union of many orbits
// rather than any one of them: the stochastic web appears where the kicked
// rotation's chaotic layer threads between the islands.
int forma_pts = 120000;

float alpha = 6.28318530718 / rint(p_q);
float ca = cos(alpha), sa = sin(alpha);
float u = 0.0, v = 0.0;
int   run = int(p_run) + 1, si = 0;   // force a seed on the first step
for (int i = 0; i < forma_pts; i++){
    if (++run > int(p_run)){
        run = 0;
        // deterministic scattered restarts, mirroring the plate's seeded rng
        u = (random(si * 2) - 0.5) * 7.0;
        v = (random(si * 2 + 1) - 0.5) * 7.0;
        si++;
    }
    float w = u + p_K * sin(v);
    float nu = w * ca + v * sa;
    float nv = -w * sa + v * ca;
    u = nu;  v = nv;
    // canvas y runs down; negated so the web sits as the plate shows it
    int pt = addpoint(0, set(u, -v, 0.0));
    float uu = float(i) / float(forma_pts);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * uu));
}

// FORMA — PL. 81 · TINKERBELL MAP — origin unrecorded · documented by Nusse & Yorke, 1994
//   xₙ₊₁ = xₙ² − yₙ² + a·xₙ + b·yₙ
//   yₙ₊₁ = 2·xₙ·yₙ + c·xₙ + d·yₙ
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=tinkerbell

float p_a = 0.9;       // 0.84 .. 0.902  · a
float p_b = -0.596;    // -0.6 .. -0.584  · b
float p_c = 2;         // 1.89 .. 2.002  · c
float p_d = 0.5;       // 0.48 .. 0.502  · d

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// The exposure replayed as a point cloud, from the plate's own start
// (−0.72, −0.64). Outside a |x|, |y| < 4 box the orbit is on its way to
// infinity, not on the attractor — the plate reseeds rather than drawing
// the escape, and so does this.
int forma_pts  = 120000;
int forma_skip = 20;

float x = -0.72, y = -0.64;
for (int i = 0; i < forma_pts + forma_skip; i++){
    float nx = x * x - y * y + p_a * x + p_b * y;
    float ny = 2.0 * x * y + p_c * x + p_d * y;
    if (abs(nx) >= 4.0 || abs(ny) >= 4.0){ x = -0.72; y = -0.64; continue; }
    x = nx;  y = ny;
    if (i < forma_skip) continue;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts + forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}

// FORMA — PL. 82 · SPROTT QUADRATIC MAP — Julien Clinton Sprott, 1993
//   xₙ₊₁ = a₀ + a₁x + a₂x² + a₃xy + a₄y + a₅y²
//   yₙ₊₁ = a₆ + a₇x + a₈x² + a₉xy + a₁₀y + a₁₁y²
//   twelve coefficients, each a letter A–Y over −1.2 … 1.2
// Paste into a Detail Wrangle (Run Over: Detail), no inputs needed.
// Written from the published mathematics, not adapted from any code.
// Defaults are the published values; comments give the measured live range.
// https://forma-gen.com/#plate=sprott

float p_code = 0;         // 0 .. 11  · coefficient code

// The plate's own colour: FORMA's ATTRACTORS accent as a cosine ramp,
// brightest near t = 0 and t = 1, near-black around t = 0.5.
vector forma_ramp(float t){
  return set(
    0.0956 + 0.1039 * cos(6.28318530718 * (t + 0)),
    0.4041 + 0.4392 * cos(6.28318530718 * (t + 0.05)),
    0.46 + 0.5 * cos(6.28318530718 * (t + 0.1)));
}

// Sprott's own encoding: one letter per coefficient, A–Y across −1.2 to 1.2
// in steps of 0.1. Decoding the letters here rather than storing numbers
// keeps the constant and the paper's name for each attractor as the same
// thing. All twelve passed Sprott's acceptance test — bounded orbit,
// positive largest Lyapunov exponent — before they were listed.
int forma_pts  = 120000;
int forma_skip = 20;

string forma_codes[] = {
    "GLXOESFTTPSV", "MCRBIPOPHTBN", "VBWNBDELYHUL", "FIRCDERRPVLD",
    "QFFVSLMJJCCR", "LUFBBFISGJYS", "EJYDREGLYQPV", "HIYIWHOKNVCG",
    "MSSSRRPADDSO", "OIHVGHAHGYRK", "RALLTIOBDULT", "WJJFXGXHTRPG" };
string code = forma_codes[int(p_code) % 12];
float A[];
for (int i = 0; i < 12; i++)
    push(A, float(ord(code[i]) - 65) * 0.1 - 1.2);

float x = 0.05, y = 0.05;
for (int i = 0; i < forma_pts + forma_skip; i++){
    float nx = A[0] + A[1] * x + A[2] * x * x + A[3] * x * y + A[4] * y + A[5] * y * y;
    float ny = A[6] + A[7] * x + A[8] * x * x + A[9] * x * y + A[10] * y + A[11] * y * y;
    // a jittered code's escape goes back to the start, not into the cloud
    if (!isfinite(nx) || !isfinite(ny) || abs(nx) > 1e5 || abs(ny) > 1e5){
        x = 0.05;  y = 0.05;  continue;
    }
    x = nx;  y = ny;
    if (i < forma_skip) continue;
    // canvas y runs down; negated so the figure sits as the plate shows it
    int pt = addpoint(0, set(x, -y, 0.0));
    float u = float(i) / float(forma_pts + forma_skip);
    setpointattrib(0, "Cd", pt, forma_ramp(0.8 + 0.3 * u));
}