@rotifer/playground 0.5.0-alpha.2 → 0.7.0

package/genes/particle-barneshut/index.ts

@@ -0,0 +1,486 @@
+interface Particle {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  mass: number;
+}
+
+interface ParticleInput {
+  particles?: Particle[];
+  preset?: "solar" | "binary" | "cluster" | "collision";
+  count?: number;
+  steps?: number;
+  dt?: number;
+  G?: number;
+  softening?: number;
+  seed?: number;
+}
+
+interface ParticleOutput {
+  particles: Particle[];
+  steps_computed: number;
+  total_energy: number;
+  interactions_computed: number;
+}
+
+interface QuadNode {
+  cx: number;
+  cy: number;
+  mass: number;
+  x: number;
+  y: number;
+  size: number;
+  children: (QuadNode | null)[];
+  particleIdx: number;
+  particleIndices?: number[];
+}
+
+const MIN_CELL_SIZE = 1e-10;
+
+function mulberry32(seed: number): () => number {
+  let s = seed | 0;
+  return () => {
+    s = (s + 0x6d2b79f5) | 0;
+    let t = Math.imul(s ^ (s >>> 15), 1 | s);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function generatePreset(
+  preset: "solar" | "binary" | "cluster" | "collision",
+  count: number,
+  seed: number
+): Particle[] {
+  const rng = mulberry32(seed);
+  const G = 1.0;
+
+  switch (preset) {
+    case "solar": {
+      const particles: Particle[] = [];
+      const M_central = 100;
+      particles.push({ x: 0, y: 0, vx: 0, vy: 0, mass: M_central });
+
+      const nOrbiters = Math.min(count - 1, 63);
+      for (let i = 0; i < nOrbiters; i++) {
+        const r = 2 + rng() * 8;
+        const theta = rng() * 2 * Math.PI;
+        const x = r * Math.cos(theta);
+        const y = r * Math.sin(theta);
+        const v = Math.sqrt((G * M_central) / r);
+        const vx = -v * Math.sin(theta);
+        const vy = v * Math.cos(theta);
+        const mass = 0.1 + rng() * 0.9;
+        particles.push({ x, y, vx, vy, mass });
+      }
+      return particles;
+    }
+
+    case "binary": {
+      const particles: Particle[] = [];
+      const m1 = 50;
+      const m2 = 50;
+      const d = 4;
+      const r1 = (d * m2) / (m1 + m2);
+      const r2 = (d * m1) / (m1 + m2);
+      const omega = Math.sqrt((G * (m1 + m2)) / (d * d * d));
+      const v1 = omega * r1;
+      const v2 = omega * r2;
+
+      particles.push({ x: -r1, y: 0, vx: 0, vy: -v1, mass: m1 });
+      particles.push({ x: r2, y: 0, vx: 0, vy: v2, mass: m2 });
+
+      const nDebris = Math.min(count - 2, 62);
+      for (let i = 0; i < nDebris; i++) {
+        const r = 6 + rng() * 4;
+        const theta = rng() * 2 * Math.PI;
+        const x = r * Math.cos(theta);
+        const y = r * Math.sin(theta);
+        const v = Math.sqrt((G * (m1 + m2)) / r) * (0.8 + rng() * 0.4);
+        const vx = -v * Math.sin(theta);
+        const vy = v * Math.cos(theta);
+        const mass = 0.1 + rng() * 0.5;
+        particles.push({ x, y, vx, vy, mass });
+      }
+      return particles;
+    }
+
+    case "cluster": {
+      const particles: Particle[] = [];
+      const radius = 5;
+      for (let i = 0; i < count; i++) {
+        const r = radius * Math.sqrt(rng());
+        const theta = rng() * 2 * Math.PI;
+        const x = r * Math.cos(theta);
+        const y = r * Math.sin(theta);
+        const vMax = 0.3;
+        const vx = (rng() - 0.5) * 2 * vMax;
+        const vy = (rng() - 0.5) * 2 * vMax;
+        const mass = 0.5 + rng() * 1.5;
+        particles.push({ x, y, vx, vy, mass });
+      }
+      return particles;
+    }
+
+    case "collision": {
+      const particles: Particle[] = [];
+      const half = Math.floor(count / 2);
+      const sep = 10;
+      const vApproach = 1.5;
+
+      for (let i = 0; i < half; i++) {
+        const x = -sep + (rng() - 0.5) * 4;
+        const y = (rng() - 0.5) * 4;
+        const vx = vApproach + (rng() - 0.5) * 0.4;
+        const vy = (rng() - 0.5) * 0.4;
+        const mass = 0.5 + rng() * 1.5;
+        particles.push({ x, y, vx, vy, mass });
+      }
+      for (let i = 0; i < count - half; i++) {
+        const x = sep + (rng() - 0.5) * 4;
+        const y = (rng() - 0.5) * 4;
+        const vx = -vApproach + (rng() - 0.5) * 0.4;
+        const vy = (rng() - 0.5) * 0.4;
+        const mass = 0.5 + rng() * 1.5;
+        particles.push({ x, y, vx, vy, mass });
+      }
+      return particles;
+    }
+
+    default:
+      return generatePreset("cluster", count, seed);
+  }
+}
+
+function createEmptyNode(x: number, y: number, size: number): QuadNode {
+  return {
+    cx: 0,
+    cy: 0,
+    mass: 0,
+    x,
+    y,
+    size,
+    children: [null, null, null, null],
+    particleIdx: -1,
+  };
+}
+
+function getQuadrant(px: number, py: number, cx: number, cy: number): number {
+  if (px < cx) {
+    return py < cy ? 0 : 2;
+  }
+  return py < cy ? 1 : 3;
+}
+
+function insertParticle(
+  node: QuadNode,
+  particles: Particle[],
+  idx: number
+): void {
+  const p = particles[idx];
+  const half = node.size / 2;
+
+  if (half < MIN_CELL_SIZE) {
+    if (node.particleIdx >= 0) {
+      node.particleIndices = [node.particleIdx];
+      node.particleIdx = -1;
+    }
+    if (!node.particleIndices) node.particleIndices = [];
+    node.particleIndices.push(idx);
+    return;
+  }
+
+  if (node.particleIdx >= 0) {
+    const existing = particles[node.particleIdx];
+    const q = getQuadrant(existing.x, existing.y, node.x, node.y);
+    const child = createEmptyNode(
+      node.x + (q === 0 || q === 2 ? -half / 2 : half / 2),
+      node.y + (q < 2 ? -half / 2 : half / 2),
+      half
+    );
+    insertParticle(child, particles, node.particleIdx);
+    node.children[q] = child;
+    node.particleIdx = -1;
+  }
+
+  const q = getQuadrant(p.x, p.y, node.x, node.y);
+  let child = node.children[q];
+
+  if (child === null) {
+    child = createEmptyNode(
+      node.x + (q === 0 || q === 2 ? -half / 2 : half / 2),
+      node.y + (q < 2 ? -half / 2 : half / 2),
+      half
+    );
+    child.particleIdx = idx;
+    child.cx = p.x;
+    child.cy = p.y;
+    child.mass = p.mass;
+    node.children[q] = child;
+  } else {
+    insertParticle(child, particles, idx);
+  }
+}
+
+function computeCenterOfMass(node: QuadNode, particles: Particle[]): void {
+  if (node.particleIdx >= 0) {
+    const p = particles[node.particleIdx];
+    node.cx = p.x;
+    node.cy = p.y;
+    node.mass = p.mass;
+    return;
+  }
+
+  if (node.particleIndices && node.particleIndices.length > 0) {
+    let totalMass = 0;
+    let sumX = 0;
+    let sumY = 0;
+    for (const i of node.particleIndices) {
+      const p = particles[i];
+      totalMass += p.mass;
+      sumX += p.x * p.mass;
+      sumY += p.y * p.mass;
+    }
+    if (totalMass > 0) {
+      node.cx = sumX / totalMass;
+      node.cy = sumY / totalMass;
+    }
+    node.mass = totalMass;
+    return;
+  }
+
+  let totalMass = 0;
+  let sumX = 0;
+  let sumY = 0;
+
+  for (const c of node.children) {
+    if (c !== null) {
+      computeCenterOfMass(c, particles);
+      totalMass += c.mass;
+      sumX += c.cx * c.mass;
+      sumY += c.cy * c.mass;
+    }
+  }
+
+  if (totalMass > 0) {
+    node.cx = sumX / totalMass;
+    node.cy = sumY / totalMass;
+  }
+  node.mass = totalMass;
+}
+
+const THETA = 0.5;
+
+function computeForce(
+  node: QuadNode,
+  particles: Particle[],
+  idx: number,
+  G: number,
+  softening: number,
+  ax: Float64Array,
+  ay: Float64Array,
+  interactions: { count: number }
+): void {
+  const p = particles[idx];
+  const dx = node.cx - p.x;
+  const dy = node.cy - p.y;
+  const rSq = dx * dx + dy * dy + softening * softening;
+  const r = Math.sqrt(rSq);
+
+  if (node.particleIdx >= 0) {
+    if (node.particleIdx === idx) return;
+    const factor = (G * node.mass) / Math.pow(rSq, 1.5);
+    ax[idx] += factor * dx;
+    ay[idx] += factor * dy;
+    interactions.count += 1;
+    return;
+  }
+
+  if (node.particleIndices && node.particleIndices.length > 0) {
+    for (const j of node.particleIndices) {
+      if (j === idx) continue;
+      const pj = particles[j];
+      const dxj = pj.x - p.x;
+      const dyj = pj.y - p.y;
+      const rSqj = dxj * dxj + dyj * dyj + softening * softening;
+      const factor = (G * pj.mass) / Math.pow(rSqj, 1.5);
+      ax[idx] += factor * dxj;
+      ay[idx] += factor * dyj;
+      interactions.count += 1;
+    }
+    return;
+  }
+
+  const ratio = node.size / (r + 1e-10);
+
+  if (ratio < THETA) {
+    const factor = (G * node.mass) / Math.pow(rSq, 1.5);
+    ax[idx] += factor * dx;
+    ay[idx] += factor * dy;
+    interactions.count += 1;
+    return;
+  }
+
+  for (const c of node.children) {
+    if (c !== null && c.mass > 0) {
+      computeForce(c, particles, idx, G, softening, ax, ay, interactions);
+    }
+  }
+}
+
+function computeTotalEnergy(
+  particles: Particle[],
+  G: number,
+  softening: number
+): number {
+  let kinetic = 0;
+  let potential = 0;
+  const n = particles.length;
+
+  for (let i = 0; i < n; i++) {
+    const p = particles[i];
+    kinetic += 0.5 * p.mass * (p.vx * p.vx + p.vy * p.vy);
+  }
+
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const pi = particles[i];
+      const pj = particles[j];
+      const dx = pj.x - pi.x;
+      const dy = pj.y - pi.y;
+      const rSq = dx * dx + dy * dy + softening * softening;
+      const r = Math.sqrt(rSq);
+      potential -= (G * pi.mass * pj.mass) / r;
+    }
+  }
+
+  return kinetic + potential;
+}
+
+export async function express(input: ParticleInput): Promise<ParticleOutput> {
+  const count = Math.max(2, Math.min(2048, input.count ?? 64));
+  const steps = Math.max(1, Math.min(10000, input.steps ?? 100));
+  const dt = input.dt ?? 0.01;
+  const G = input.G ?? 1.0;
+  const softening = input.softening ?? 0.01;
+  const seed = input.seed ?? 42;
+
+  let particles: Particle[];
+
+  if (input.particles && input.particles.length > 0) {
+    particles = input.particles.map((p) => ({
+      x: p.x,
+      y: p.y,
+      vx: p.vx,
+      vy: p.vy,
+      mass: p.mass,
+    }));
+  } else {
+    const preset = input.preset ?? "cluster";
+    particles = generatePreset(preset, count, seed);
+  }
+
+  const n = particles.length;
+  const ax = new Float64Array(n);
+  const ay = new Float64Array(n);
+  let interactionsComputed = 0;
+  const margin = 0.1;
+
+  for (let stepIdx = 0; stepIdx < steps; stepIdx++) {
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+
+    for (let i = 0; i < n; i++) {
+      const p = particles[i];
+      if (p.x < minX) minX = p.x;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.y > maxY) maxY = p.y;
+    }
+
+    const size = Math.max(maxX - minX, maxY - minY, 1) / 2 + margin;
+    const root = createEmptyNode(
+      (minX + maxX) / 2,
+      (minY + maxY) / 2,
+      size
+    );
+
+    for (let i = 0; i < n; i++) {
+      insertParticle(root, particles, i);
+    }
+    computeCenterOfMass(root, particles);
+
+    ax.fill(0);
+    ay.fill(0);
+    const interactions = { count: 0 };
+
+    for (let i = 0; i < n; i++) {
+      computeForce(root, particles, i, G, softening, ax, ay, interactions);
+    }
+    interactionsComputed += interactions.count;
+
+    for (let i = 0; i < n; i++) {
+      const p = particles[i];
+      p.vx += 0.5 * dt * ax[i];
+      p.vy += 0.5 * dt * ay[i];
+    }
+
+    for (let i = 0; i < n; i++) {
+      const p = particles[i];
+      p.x += dt * p.vx;
+      p.y += dt * p.vy;
+    }
+
+    minX = Infinity;
+    maxX = -Infinity;
+    minY = Infinity;
+    maxY = -Infinity;
+
+    for (let i = 0; i < n; i++) {
+      const p = particles[i];
+      if (p.x < minX) minX = p.x;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.y > maxY) maxY = p.y;
+    }
+
+    const size2 = Math.max(maxX - minX, maxY - minY, 1) / 2 + margin;
+    const root2 = createEmptyNode(
+      (minX + maxX) / 2,
+      (minY + maxY) / 2,
+      size2
+    );
+
+    for (let i = 0; i < n; i++) {
+      insertParticle(root2, particles, i);
+    }
+    computeCenterOfMass(root2, particles);
+
+    ax.fill(0);
+    ay.fill(0);
+    const interactions2 = { count: 0 };
+
+    for (let i = 0; i < n; i++) {
+      computeForce(root2, particles, i, G, softening, ax, ay, interactions2);
+    }
+    interactionsComputed += interactions2.count;
+
+    for (let i = 0; i < n; i++) {
+      const p = particles[i];
+      p.vx += 0.5 * dt * ax[i];
+      p.vy += 0.5 * dt * ay[i];
+    }
+  }
+
+  const totalEnergy = computeTotalEnergy(particles, G, softening);
+
+  return {
+    particles,
+    steps_computed: steps,
+    total_energy: totalEnergy,
+    interactions_computed: interactionsComputed,
+  };
+}

package/genes/particle-barneshut/phenotype.json

@@ -0,0 +1,137 @@
+{
+  "domain": "sim.particle",
+  "description": "N-body gravitational simulation using Barnes-Hut quadtree approximation. Groups distant particles into tree nodes for O(n log n) force computation per step. Balances accuracy and speed via configurable opening angle theta.",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "particles": {
+        "type": "array",
+        "description": "Initial particle states. Ignored if preset is provided.",
+        "items": {
+          "type": "object",
+          "properties": {
+            "x": {
+              "type": "number"
+            },
+            "y": {
+              "type": "number"
+            },
+            "vx": {
+              "type": "number"
+            },
+            "vy": {
+              "type": "number"
+            },
+            "mass": {
+              "type": "number"
+            }
+          },
+          "required": [
+            "x",
+            "y",
+            "vx",
+            "vy",
+            "mass"
+          ]
+        }
+      },
+      "preset": {
+        "type": "string",
+        "description": "Preset particle configuration",
+        "enum": [
+          "solar",
+          "binary",
+          "cluster",
+          "collision"
+        ]
+      },
+      "count": {
+        "type": "number",
+        "description": "Number of particles for preset generation",
+        "default": 64,
+        "minimum": 2,
+        "maximum": 2048
+      },
+      "steps": {
+        "type": "number",
+        "description": "Number of simulation steps",
+        "default": 100,
+        "minimum": 1,
+        "maximum": 10000
+      },
+      "dt": {
+        "type": "number",
+        "description": "Time step size",
+        "default": 0.01
+      },
+      "G": {
+        "type": "number",
+        "description": "Gravitational constant",
+        "default": 1
+      },
+      "softening": {
+        "type": "number",
+        "description": "Softening parameter to prevent singularity at close range",
+        "default": 0.01
+      },
+      "seed": {
+        "type": "number",
+        "description": "Random seed for preset generation (deterministic output)"
+      }
+    },
+    "required": []
+  },
+  "outputSchema": {
+    "type": "object",
+    "properties": {
+      "particles": {
+        "type": "array",
+        "description": "Final particle states after simulation",
+        "items": {
+          "type": "object",
+          "properties": {
+            "x": {
+              "type": "number"
+            },
+            "y": {
+              "type": "number"
+            },
+            "vx": {
+              "type": "number"
+            },
+            "vy": {
+              "type": "number"
+            },
+            "mass": {
+              "type": "number"
+            }
+          }
+        }
+      },
+      "steps_computed": {
+        "type": "number",
+        "description": "Actual number of simulation steps computed"
+      },
+      "total_energy": {
+        "type": "number",
+        "description": "Total system energy (kinetic + potential) at final state"
+      },
+      "interactions_computed": {
+        "type": "number",
+        "description": "Total pairwise force evaluations across all steps"
+      }
+    },
+    "required": [
+      "particles",
+      "steps_computed",
+      "total_energy",
+      "interactions_computed"
+    ]
+  },
+  "dependencies": [],
+  "version": "0.1.0",
+  "author": "rotifer-team",
+  "fidelity": "Native",
+  "transparency": "Open",
+  "ir_hash": "391614d239e64ad94d257ec59c079a1a060d0143b28f6edd8ec255858f961d1c"
+}

package/genes/particle-brute/.cloud-manifest.json

@@ -0,0 +1,6 @@
+{
+  "cloud_id": "30e35b9b-a377-4a2b-a7eb-fce16f379941",
+  "owner": "Rotifer Protocol",
+  "version": "0.1.0",
+  "published_at": "2026-03-17T14:13:16.873Z"
+}

package/genes/particle-brute/.compile-result.json

@@ -0,0 +1,12 @@
+{
+  "geneId": "0ec8e0410da37367e5a3fbacdfbb53e44f22da0741bc538eeef819d728a4305c",
+  "name": "particle-brute",
+  "domain": "sim.particle",
+  "compiledAt": "2026-03-14T09:13:33.395Z",
+  "fidelity": "Native",
+  "wasmAvailable": true,
+  "irHash": "391614d239e64ad94d257ec59c079a1a060d0143b28f6edd8ec255858f961d1c",
+  "totalSize": 1295630,
+  "codeSectionSize": 956115,
+  "durationMs": 6609
+}

package/genes/particle-brute/README.md

@@ -0,0 +1,55 @@
+# particle-brute
+
+Brute-force N-body gravitational simulation — a pure-computation Native Gene for the Rotifer Protocol.
+
+## Algorithm
+
+All-pairs direct summation with O(n²) complexity per step. For each pair of particles (i, j), computes the exact gravitational force using Newton's law with a softening parameter to prevent singularities:
+
+```
+F = G × m_i × m_j × r̂ / (|r|² + ε²)^(3/2)
+```
+
+Integration uses the symplectic leapfrog (kick-drift-kick) scheme for energy conservation.
+
+This is the **accuracy baseline** — every pairwise interaction is computed exactly, making it ideal for validating approximation-based algorithms like Barnes-Hut or spatial hashing.
+
+## Usage
+
+```bash
+# Solar system preset (64 particles, 100 steps)
+rotifer run particle-brute --input '{"preset": "solar"}'
+
+# Cluster collision (128 particles, 500 steps)
+rotifer run particle-brute --input '{"preset": "collision", "count": 128, "steps": 500}'
+
+# Custom particles
+rotifer run particle-brute --input '{"particles": [{"x":0,"y":0,"vx":0,"vy":0,"mass":100}, {"x":5,"y":0,"vx":0,"vy":4.47,"mass":1}]}'
+```
+
+## Presets
+
+| Preset | Description |
+|--------|-------------|
+| `solar` | Central massive body + orbiting lighter bodies with circular velocities |
+| `binary` | Two equal-mass stars in mutual orbit + debris ring |
+| `cluster` | Random particles in a disk with small random velocities |
+| `collision` | Two groups of particles approaching head-on |
+
+## Output
+
+- `particles` — final positions and velocities of all particles
+- `steps_computed` — number of simulation steps executed
+- `total_energy` — total system energy (kinetic + potential) for conservation validation
+- `interactions_computed` — total force evaluations (n(n-1)/2 × 2 × steps for kick-drift-kick)
+
+## Fitness Characteristics
+
+| Metric | Expected |
+|--------|----------|
+| Success Rate | 1.0 (deterministic, no failure mode) |
+| Accuracy | Exact (machine-precision pairwise forces) |
+| Complexity | O(n² × steps) |
+| Interactions | n(n-1) × steps |
+| Best For | Small N (≤256), accuracy benchmarks |
+| Weakness | Scales poorly for large N |