@rotifer/playground 0.8.0 → 0.8.5

package/genes/particle-spatial/README.md

@@ -1,53 +0,0 @@
-# particle-spatial
-
-Spatial hash grid N-body simulation — a pure-computation Native Gene for the Rotifer Protocol.
-
-## Algorithm
-
-Partitions space into a uniform grid of fixed-size cells. For each particle, only computes gravitational forces from particles in the same cell and 8 neighboring cells (3×3 neighborhood). Long-range forces beyond the cell neighborhood are ignored.
-
-Cell size is adaptive: `cellSize = max(2ε, 2 × √(area / n))`, scaling with the average inter-particle spacing and bounded by the softening parameter.
-
-Integration uses the symplectic leapfrog (kick-drift-kick) scheme.
-
-This approach trades long-range gravitational accuracy for raw speed — achieving near-O(n) performance when particles are roughly uniformly distributed. It's better suited for short-range-dominated systems (collisions, dense clusters) than for orbital mechanics where long-range gravity dominates.
-
-## Usage
-
-```bash
-# Cluster preset (good fit for spatial hashing)
-rotifer run particle-spatial --input '{"preset": "cluster", "count": 256}'
-
-# Collision (where short-range forces dominate)
-rotifer run particle-spatial --input '{"preset": "collision", "count": 512, "steps": 300}'
-
-# Solar system (less accurate due to missing long-range forces)
-rotifer run particle-spatial --input '{"preset": "solar"}'
-```
-
-## 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 neighbor-cell force evaluations
-
-## Fitness Characteristics
-
-| Metric | Expected |
-|--------|----------|
-| Success Rate | 1.0 (deterministic, no failure mode) |
-| Accuracy | Low-medium (only short-range interactions, misses distant forces) |
-| Complexity | ~O(n × steps) for uniform distributions |
-| Interactions | Depends on particle clustering — much fewer than n² |
-| Best For | Large N with short-range dominated interactions (collisions, dense clusters) |
-| Weakness | Poor for orbital/long-range gravity (solar, binary) |

package/genes/particle-spatial/index.ts

@@ -1,352 +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;
-}
-
-function buildGrid(
-  particles: Particle[],
-  cellSize: number
-): Map<string, number[]> {
-  const grid = new Map<string, number[]>();
-  for (let i = 0; i < particles.length; i++) {
-    const p = particles[i];
-    const cx = Math.floor(p.x / cellSize);
-    const cy = Math.floor(p.y / cellSize);
-    const key = `${cx},${cy}`;
-    let cell = grid.get(key);
-    if (!cell) {
-      cell = [];
-      grid.set(key, cell);
-    }
-    cell.push(i);
-  }
-  return grid;
-}
-
-function computeForcesSpatial(
-  particles: Particle[],
-  grid: Map<string, number[]>,
-  cellSize: number,
-  ax: Float64Array,
-  ay: Float64Array,
-  G: number,
-  softening: number
-): number {
-  const n = particles.length;
-  let interactions = 0;
-
-  for (let i = 0; i < n; i++) {
-    const pi = particles[i];
-    const cx = Math.floor(pi.x / cellSize);
-    const cy = Math.floor(pi.y / cellSize);
-
-    for (let dx = -1; dx <= 1; dx++) {
-      for (let dy = -1; dy <= 1; dy++) {
-        const key = `${cx + dx},${cy + dy}`;
-        const cell = grid.get(key);
-        if (!cell) continue;
-
-        for (const j of cell) {
-          if (j === i) continue;
-          const pj = particles[j];
-          const ddx = pj.x - pi.x;
-          const ddy = pj.y - pi.y;
-          const rSq = ddx * ddx + ddy * ddy + softening * softening;
-          const rSoft = Math.pow(rSq, 1.5);
-          const factor = G / rSoft;
-
-          ax[i] += factor * pj.mass * ddx;
-          ay[i] += factor * pj.mass * ddy;
-          interactions++;
-        }
-      }
-    }
-  }
-
-  return interactions;
-}
-
-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;
-
-  for (let stepIdx = 0; stepIdx < steps; stepIdx++) {
-    let minX = particles[0].x;
-    let maxX = particles[0].x;
-    let minY = particles[0].y;
-    let maxY = particles[0].y;
-
-    for (let i = 1; 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 w = Math.max(maxX - minX, softening * 4);
-    const h = Math.max(maxY - minY, softening * 4);
-    const area = w * h;
-    const cellSize = Math.max(softening * 2, Math.sqrt(area / n) * 2);
-
-    const grid = buildGrid(particles, cellSize);
-
-    ax.fill(0);
-    ay.fill(0);
-    interactionsComputed += computeForcesSpatial(
-      particles,
-      grid,
-      cellSize,
-      ax,
-      ay,
-      G,
-      softening
-    );
-
-    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 = particles[0].x;
-    maxX = particles[0].x;
-    minY = particles[0].y;
-    maxY = particles[0].y;
-    for (let i = 1; 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 w2 = Math.max(maxX - minX, softening * 4);
-    const h2 = Math.max(maxY - minY, softening * 4);
-    const area2 = w2 * h2;
-    const cellSize2 = Math.max(softening * 2, Math.sqrt(area2 / n) * 2);
-
-    const grid2 = buildGrid(particles, cellSize2);
-
-    ax.fill(0);
-    ay.fill(0);
-    interactionsComputed += computeForcesSpatial(
-      particles,
-      grid2,
-      cellSize2,
-      ax,
-      ay,
-      G,
-      softening
-    );
-
-    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-spatial/phenotype.json

@@ -1,137 +0,0 @@
-{
-  "domain": "sim.particle",
-  "description": "N-body gravitational simulation using spatial hash grid. Partitions particles into cells based on bounding box; each particle interacts only with neighbors in its 3x3 cell neighborhood. Reduces pairwise evaluations for spatially clustered distributions.",
-  "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/performance-optimizer/.cloud-manifest.json

@@ -1,6 +0,0 @@
-{
-  "cloud_id": "fb63a8d2-4c60-493f-8ccb-a91d8997a0fb",
-  "owner": "Rotifer Protocol",
-  "version": "0.1.0",
-  "published_at": "2026-03-17T14:13:22.120Z"
-}

package/genes/performance-optimizer/.gene-manifest.json

@@ -1,8 +0,0 @@
-{
-  "geneId": "6a4c87cfeb6420cf1b9bed5f282e808d2b277dc7f8baff6580b219a944ebfddd",
-  "name": "performance-optimizer",
-  "domain": "code.performance",
-  "fidelity": "Wrapped",
-  "wrappedAt": "2026-02-24T13:23:32.820Z",
-  "fromSkill": "../.cursor/skills/performance-optimizer/SKILL.md"
-}