chore(test): add test suite in tests/ folder and development tools

Author: Tarawally

projects/arithmetica-lucis/prototype/mobius-caustic-solver/.gitignore

@@ -0,0 +1,3 @@
+*.log
+node_modules/
+.DS_Store

projects/arithmetica-lucis/prototype/mobius-caustic-solver/.tool-versions

@@ -0,0 +1 @@
+python 3.14.0t

projects/arithmetica-lucis/prototype/mobius-caustic-solver/server.js

@@ -0,0 +1,84 @@
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+const PORT = 8088;
+const LOG_FILE = path.join(__dirname, "app.log");
+const MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+};
+
+const server = http.createServer((req, res) => {
+  console.log(`${req.method} ${req.url}`);
+
+  // CORS headers
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  // File Logging Endpoint
+  if (req.method === "POST" && req.url === "/log") {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      fs.appendFile(LOG_FILE, body + "\n", (err) => {
+        if (err) {
+          console.error("Error writing to log file:", err);
+          res.writeHead(500);
+          res.end("Internal Server Error");
+        } else {
+          res.writeHead(200);
+          res.end("Log captured");
+        }
+      });
+    });
+    return;
+  }
+
+  // Static File Serving
+  let filePath = "." + req.url;
+  if (filePath === "./") {
+    filePath = "./index.html";
+  }
+
+  const extname = String(path.extname(filePath)).toLowerCase();
+  const contentType = MIME_TYPES[extname] || "application/octet-stream";
+
+  fs.readFile(filePath, (error, content) => {
+    if (error) {
+      if (error.code === "ENOENT") {
+        res.writeHead(404);
+        res.end("404 Not Found");
+      } else {
+        res.writeHead(500);
+        res.end(
+          "Sorry, check with the site admin for error: " + error.code + " ..\n"
+        );
+      }
+    } else {
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content, "utf-8");
+    }
+  });
+});
+
+server.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}/`);
+  console.log(`Logs will be written to ${LOG_FILE}`);
+});

projects/arithmetica-lucis/prototype/mobius-caustic-solver/tests/test_analytic_logic.js

@@ -0,0 +1,194 @@
+import { Complex } from "./src/core/complex.js";
+import { Geodesic } from "./src/geometry/geodesic.js";
+import { Solver } from "./src/physics/solver.js";
+import { Mobius } from "./src/core/mobius.js";
+
+function assert(condition, message) {
+  if (!condition) {
+    console.error(`❌ FAIL: ${message}`);
+    process.exit(1);
+  } else {
+    console.log(`✅ PASS: ${message}`);
+  }
+}
+
+console.log("=== Running Analytic Logic Tests ===");
+
+// --- Mock Scene ---
+const scene = {
+  mirrors: [],
+  sources: [],
+};
+
+// --- Test 1: Interval Splitting Logic ---
+// Scenario: Beam [-15, 45] (Width 60), Mirror [0, 90] (Front of it)
+// Expect:
+// 1. Fragment [-15, 0] (Miss)
+// 2. Fragment [0, 45] (Hit)
+// (Since beam ends at 45, it doesn't see the 45-90 mirror part)
+
+function testIntervalLogic() {
+  console.log("\n[Logic] Interval Visualization");
+
+  const solver = new Solver(scene);
+  const source = new Complex(0, 0);
+
+  // Beam: -15 deg to 45 deg on Unit Circle
+  const p1 = new Complex(
+    Math.cos((-15 * Math.PI) / 180),
+    Math.sin((-15 * Math.PI) / 180)
+  );
+  const p2 = new Complex(
+    Math.cos((45 * Math.PI) / 180),
+    Math.sin((45 * Math.PI) / 180)
+  );
+
+  // Mirror: 0 deg to 90 deg
+  const m1 = new Complex(Math.cos(0), Math.sin(0));
+  const m2 = new Complex(Math.cos(Math.PI / 2), Math.sin(Math.PI / 2));
+  const mirror = new Geodesic(m1, m2);
+
+  scene.mirrors = [mirror];
+  solver.buildIndex(); // Build Spatial Index
+
+  const fragments = solver.computeVisibilityIntervals(source, p1, p2);
+
+  console.log(`Fragments: ${fragments.length}`);
+  let hits = 0;
+  let misses = 0;
+
+  for (const f of fragments) {
+    const isHit = f.mirror !== null;
+    if (isHit) hits++;
+    else misses++;
+    // console.log(`Frag: ${f.pStart.toString()} -> ${f.pEnd.toString()} | Hit: ${isHit}`);
+  }
+
+  // Expect 2 (Miss then Hit).
+  // Wait, Solver output order depends on sort.
+  // [0, 60] range.
+  // Mirror is relative [15, 75]? (Start is -15, Mirror starts at 0. diff is 15).
+  // Overlap is significant.
+
+  if (hits === 1 && misses >= 1) {
+    console.log("✅ PASS: Correctly split into Hit and Miss");
+  } else {
+    console.log(
+      `❌ FAIL: Expected 1 Hit, >=1 Miss. Got ${hits} Hits, ${misses} Misses`
+    );
+    console.log("Fragments:", fragments);
+  }
+}
+
+function testSpatialGrid() {
+  console.log("\n[Logic] Spatial Grid Query");
+  const solver = new Solver(scene);
+  const source = new Complex(0, 0);
+
+  // Create 4 mirrors in 4 quadrants
+  const m1 = new Geodesic(new Complex(0.9, 0.9), new Complex(0.8, 0.8)); // Q1
+  const m2 = new Geodesic(new Complex(-0.9, 0.9), new Complex(-0.8, 0.8)); // Q2
+  const m3 = new Geodesic(new Complex(-0.9, -0.9), new Complex(-0.8, -0.8)); // Q3
+  const m4 = new Geodesic(new Complex(0.9, -0.9), new Complex(0.8, -0.8)); // Q4
+
+  scene.mirrors = [m1, m2, m3, m4];
+  solver.buildIndex();
+
+  // Query Q1 wedge
+  const p1 = new Complex(1, 0);
+  const p2 = new Complex(0, 1);
+  const queryResults = solver.grid.query(source, p1, p2);
+
+  // Should find m1
+  const foundM1 = queryResults.includes(m1);
+  const foundM3 = queryResults.includes(m3); // Opposite side
+
+  if (foundM1 && !foundM3) {
+    console.log("✅ PASS: Spatial Grid correctly filters quadrant");
+  } else {
+    console.log(
+      `❌ FAIL: Grid logic flawed. Found M1=${foundM1}, Found M3=${foundM3}`
+    );
+  }
+}
+
+testIntervalLogic();
+testSpatialGrid();
+
+// The original "TEST 1: Interval Splitting (Proposed Logic)" block is replaced by the new testIntervalLogic() function.
+// The following comments and structure are from the original file, but the actual test logic is now in testIntervalLogic().
+// This section is kept for context if it was intended to be a separate test, but the new instruction implies replacement.
+// If the original block was meant to be a *different* test, it would need to be re-added as a separate function.
+// Given the instruction to "Add 'Spatial Grid' and 'Splitting' test cases" and the provided code for `testIntervalLogic`,
+// it's assumed `testIntervalLogic` is the new, improved version of the "Interval Splitting" test.
+
+/*
+// TEST 1: Interval Splitting (Proposed Logic)
+{
+  console.log("\n[Logic] Interval Visualization");
+  const scene = { mirrors: [] };
+  // Mirror covering [0, PI/2] roughly (First Quadrant)
+  // Geodesic from (1,0) to (0,1) approximates this? No.
+  // We need a mirror that subtends an angle AT THE SOURCE.
+  // Source = Origin.
+  // Mirror = Geodesic from (1,0) to (0,1)?
+  // Tangent at (0,0) for Geodesic((1,0), (0,1))?
+  // Center of that geodesic is (1,1). Radius 1.
+  // Passes through (1,0) and (0,1).
+  // It effectively blocks the first quadrant?
+  // Let's use a simpler "Ideal" interval test if we can access the interval logic directly.
+  // But we test the public API: `solver.solve()`.
+
+  const m1 = new Complex(1, 0); // 0 deg
+  const m2 = new Complex(0, 1); // 90 deg
+  const mirror = new Geodesic(m1, m2);
+  scene.mirrors.push(mirror);
+
+  const solver = new Solver(scene);
+
+  // Beam source at origin.
+  // Beam targets: p1 at -15 deg, p2 at +45 deg.
+  // Cover [-15, 45] degrees.
+  // Mirror effectively covers [0, 90] degrees (First Quadrant).
+  // Overlap should be [0, 45].
+  // Split should happen at 0 degrees.
+  // Resulting Segments from `solve`:
+  // 1. [-15, 0] -> Miss
+  // 2. [0, 45] -> Hit Mirror
+
+  const source = {
+    origin: new Complex(0, 0),
+    p1: new Complex(0.96, -0.25), // ~ -15 deg
+    p2: new Complex(0.707, 0.707), // ~ 45 deg
+  };
+
+  try {
+    const segments = solver.solve(source);
+
+    // Expected: At least 2 segments at depth 0 (or processed).
+    // If the solver is recursive, 'segments' contains the LEAF nodes.
+    // So we expect:
+    // 1 segment that ends at the boundary (Miss).
+    // 1 segment that ends at the mirror (Hit).
+    // (And reflected segments).
+
+    const misses = segments.filter((s) => s.terminator === null);
+    const hits = segments.filter((s) => s.terminator !== null);
+
+    console.log(
+      `Segs: ${segments.length}, Hits: ${hits.length}, Misses: ${misses.length}`
+    );
+
+    // With OLD logic: it might split adaptively into many small segments near 0.
+    // With NEW logic: Exact split. 1 Hit, 1 Miss.
+
+    assert(hits.length >= 1, "Should detect hit portion");
+    assert(misses.length >= 1, "Should detect miss portion");
+
+    // Strict check for Analytic Solver (Future):
+    // assert(hits.length === 1 && misses.length === 1, "Exact Analytic Split");
+  } catch (e) {
+    console.log("Solver execution failed: " + e.message);
+  }
+}
+*/

projects/arithmetica-lucis/prototype/mobius-caustic-solver/tests/test_core.js

@@ -0,0 +1,105 @@
+import { Complex } from "./src/core/complex.js";
+import { Mobius } from "./src/core/mobius.js";
+
+function assert(condition, message) {
+  if (!condition) {
+    console.error(`❌ FAIL: ${message}`);
+    process.exit(1);
+  } else {
+    console.log(`✅ PASS: ${message}`);
+  }
+}
+
+function assertClose(a, b, epsilon = 1e-6, message = "Value check") {
+  if (Math.abs(a - b) > epsilon) {
+    console.error(`❌ FAIL: ${message} (Expected ${a}, Got ${b})`);
+    process.exit(1);
+  } else {
+    console.log(`✅ PASS: ${message}`);
+  }
+}
+
+console.log("=== Running Core Tests (Complex, Mobius) ===");
+
+// --- COMPLEX TESTS ---
+{
+  console.log("\n[Complex] Arithmetic");
+  const c1 = new Complex(1, 2);
+  const c2 = new Complex(3, 4);
+
+  // Add
+  const sum = new Complex();
+  Complex.add(sum, c1, c2);
+  assert(sum.re === 4 && sum.im === 6, "Complex Addition");
+
+  // Mul
+  // (1+2i)*(3+4i) = 3 + 4i + 6i - 8 = -5 + 10i
+  const prod = new Complex();
+  Complex.mul(prod, c1, c2);
+  assert(prod.re === -5 && prod.im === 10, "Complex Multiplication");
+
+  // Div
+  // (1+2i)/(3+4i) = (1+2i)(3-4i)/25 = (3 -4i +6i +8)/25 = (11 + 2i)/25 = 0.44 + 0.08i
+  const div = new Complex();
+  Complex.div(div, c1, c2);
+  assertClose(div.re, 0.44, 1e-9, "Complex Division Re");
+  assertClose(div.im, 0.08, 1e-9, "Complex Division Im");
+}
+
+// --- MOBIUS TESTS ---
+{
+  console.log("\n[Mobius] Transform Logic");
+  // Identity
+  const id = new Mobius();
+  const z = new Complex(10, -5);
+  const out = new Complex();
+  id.apply(out, z);
+  assert(out.re === 10 && out.im === -5, "Identity Transform");
+
+  // Inverse
+  // M(z) = z + 1 (Translation) -> [[1, 1], [0, 1]]
+  const trans = new Mobius(
+    new Complex(1, 0),
+    new Complex(1, 0),
+    new Complex(0, 0),
+    new Complex(1, 0)
+  );
+  const inv = trans.inverse();
+  // Inv(z) should be z - 1
+  // Inv Matrix: [[1, -1], [0, 1]]
+  // (1*z - 1) / 1 = z - 1
+  inv.apply(out, z); // 10 - 5i -> 9 - 5i
+  assert(out.re === 9 && out.im === -5, "Inverse Translation");
+
+  // Compose
+  // T1(z) = z + 1. T2(z) = 2z.
+  // T2(T1(z)) = 2(z+1) = 2z + 2.
+  // Matrix Mul: [[2,0],[0,1]] * [[1,1],[0,1]] = [[2,2],[0,1]]
+  const scale = new Mobius(
+    new Complex(2, 0),
+    new Complex(0, 0),
+    new Complex(0, 0),
+    new Complex(1, 0)
+  );
+  const comp = scale.compose(trans);
+  console.log(
+    `Comp Matrix: A=${comp.a.toString()}, B=${comp.b.toString()}, C=${comp.c.toString()}, D=${comp.d.toString()}`
+  );
+  comp.apply(out, new Complex(1, 0)); // (2(1)+2)/1 = 4
+  assertClose(out.re, 4, 1e-9, "Composition T2(T1(z))");
+
+  // Normalize
+  // M = [[2,0],[0,2]]. Det = 4. Sqrt(Det)=2.
+  // Norm = [[1,0],[0,1]].
+  const unNorm = new Mobius(
+    new Complex(2, 0),
+    new Complex(0, 0),
+    new Complex(0, 0),
+    new Complex(2, 0)
+  );
+  unNorm.normalize();
+  assertClose(unNorm.a.re, 1.0, 1e-9, "Normalize A");
+  assertClose(unNorm.d.re, 1.0, 1e-9, "Normalize D");
+}
+
+console.log("=== Core Tests Passed ===");