@rotifer/playground 0.8.0 → 0.8.5

package/genes/particle-barneshut/phenotype.json

@@ -1,137 +0,0 @@
-{
-  "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

@@ -1,6 +0,0 @@
-{
-  "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

@@ -1,12 +0,0 @@
-{
-  "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

@@ -1,55 +0,0 @@
-# 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 |

package/genes/particle-brute/index.ts

@@ -1,277 +0,0 @@
-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;
-}
-
-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 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 pairsPerStep = (n * (n - 1)) / 2;
-  let interactionsComputed = 0;
-
-  const ax = new Float64Array(n);
-  const ay = new Float64Array(n);
-
-  for (let stepIdx = 0; stepIdx < steps; stepIdx++) {
-    ax.fill(0);
-    ay.fill(0);
-
-    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 rSoft = Math.pow(rSq, 1.5);
-        const factor = G / rSoft;
-
-        const axij = factor * pj.mass * dx;
-        const ayij = factor * pj.mass * dy;
-
-        ax[i] += axij;
-        ay[i] += ayij;
-        ax[j] -= factor * pi.mass * dx;
-        ay[j] -= factor * pi.mass * dy;
-      }
-    }
-    interactionsComputed += pairsPerStep;
-
-    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;
-    }
-
-    ax.fill(0);
-    ay.fill(0);
-
-    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 rSoft = Math.pow(rSq, 1.5);
-        const factor = G / rSoft;
-
-        const axij = factor * pj.mass * dx;
-        const ayij = factor * pj.mass * dy;
-
-        ax[i] += axij;
-        ay[i] += ayij;
-        ax[j] -= factor * pi.mass * dx;
-        ay[j] -= factor * pi.mass * dy;
-      }
-    }
-    interactionsComputed += pairsPerStep;
-
-    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-brute/phenotype.json

@@ -1,137 +0,0 @@
-{
-  "domain": "sim.particle",
-  "description": "N-body gravitational simulation using brute-force all-pairs direct summation. Computes exact O(n^2) pairwise interactions per step — maximum accuracy baseline. Supports preset configurations (solar system, binary star, galaxy cluster, collision).",
-  "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-spatial/.cloud-manifest.json

@@ -1,6 +0,0 @@
-{
-  "cloud_id": "a29c1488-8591-40e9-bc9e-5edbafdd66b3",
-  "owner": "Rotifer Protocol",
-  "version": "0.1.0",
-  "published_at": "2026-03-17T14:13:20.276Z"
-}

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

@@ -1,12 +0,0 @@
-{
-  "geneId": "91f0c58c3342d9853eef2747aa91cf59e23f80a5426be2ce9200a1e44a0de113",
-  "name": "particle-spatial",
-  "domain": "sim.particle",
-  "compiledAt": "2026-03-14T09:13:54.298Z",
-  "fidelity": "Native",
-  "wasmAvailable": true,
-  "irHash": "391614d239e64ad94d257ec59c079a1a060d0143b28f6edd8ec255858f961d1c",
-  "totalSize": 1322156,
-  "codeSectionSize": 956115,
-  "durationMs": 5868
-}