Add 22 new builtins: math, stats, substrate primitives + 25 tests

Part of the 200+ optimization campaign. Three groups:

MATH (10 mods):
- log2, log10 — base-2 and base-10 logarithms
- asin, acos, atan, atan2 — inverse trig functions
- hypot(a, b) — Euclidean distance helper
- lerp(a, b, t) — linear interpolation primitive

ARRAY STATS (9 mods):
- arr_mean — arithmetic mean as float
- arr_variance — population variance (divides by N)
- arr_stddev — sqrt of variance
- arr_median — even-length avg of two middle elements
- arr_harmonic_mean — n / sum(1/x_i)
- arr_geometric_mean — log-sum exp form (overflow-safe)
- arr_sum_sq — sum of squared elements
- arr_norm — L2 norm of array as vector
- arr_dot(a, b) — dot product

SUBSTRATE PRIMITIVES (5 mods):
- attractor_distance(n) — distance to nearest Fibonacci attractor
- nearest_attractor(n) — sign-preserving nearest attractor
- largest_attractor_at_most(n) — greedy chunk size helper
- crt_residues(pos, moduli) — exposes the E2 CRT-PE construction
  directly to OMC code
- hbit_tension(value) — same as attractor_distance, named to
  match the experiments-paper vocabulary

All 22 are registered in is_known_builtin and HEAL_BUILTIN_NAMES.
Compiler infer_type tags them in the right return-type table so
the JIT type-specialization picks DivFloat/MulFloat etc. when
the math composes float operands.

TESTS: 25-test suite in examples/tests/test_new_builtins.omc
covering each new builtin against a known-good value or
small-tolerance approximation. All 25 pass.

DISCOVERED: OMC parser doesn't support scientific-notation float
literals (1e-9 is misparsed as int(1) + call(e, -9)). Filed as
followup task to add the lexer rule.

Workspace: 149 omnimcode-core unit tests + 25 new OMC builtin
tests pass. The harmonic library tests (18) still pass too.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/tests/test_new_builtins.omc

@@ -0,0 +1,179 @@
+# =============================================================================
+# Tests for the optimization-campaign builtins (math + stats + substrate).
+# =============================================================================
+# Validates the new builtins added in the 200+ optimization campaign:
+#   - Math: log2, log10, asin, acos, atan, atan2, hypot, lerp
+#   - Stats: arr_mean, arr_variance, arr_stddev, arr_median,
+#            arr_harmonic_mean, arr_geometric_mean, arr_sum_sq,
+#            arr_norm, arr_dot
+#   - Substrate: attractor_distance, nearest_attractor,
+#                largest_attractor_at_most, crt_residues, hbit_tension
+#
+# Each test asserts an exact known-good value or a small-tolerance
+# approximation. Run with: omnimcode-standalone --test test_new_builtins.omc
+# =============================================================================
+
+# ---------- Assertion helpers (mirroring test_harmonic_libs.omc) ----------
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        error(concat_many("FAIL ", msg, ": expected ", expected, " got ", actual));
+    }
+}
+
+fn assert_true(cond, msg) {
+    if cond != 1 { error(concat_many("FAIL ", msg, ": expected truthy")); }
+}
+
+# ---------- Math builtins ----------
+
+fn approx_eq(a, b, tol) {
+    h diff = a - b;
+    if diff < 0.0 { diff = 0.0 - diff; }
+    return diff < tol;
+}
+
+fn test_log2() {
+    h r = log2(8.0);
+    assert_true(approx_eq(r, 3.0, 0.000000001), "log2(8) should be 3.0");
+}
+
+fn test_log10() {
+    h r = log10(1000.0);
+    assert_true(approx_eq(r, 3.0, 0.000000001), "log10(1000) should be 3.0");
+}
+
+fn test_asin() {
+    h r = asin(1.0);
+    h pi_half = pi() / 2.0;
+    assert_true(approx_eq(r, pi_half, 0.000000001), "asin(1) should be pi/2");
+}
+
+fn test_acos() {
+    h r = acos(0.0);
+    h pi_half = pi() / 2.0;
+    assert_true(approx_eq(r, pi_half, 0.000000001), "acos(0) should be pi/2");
+}
+
+fn test_atan() {
+    h r = atan(1.0);
+    h pi_quarter = pi() / 4.0;
+    assert_true(approx_eq(r, pi_quarter, 0.000000001), "atan(1) should be pi/4");
+}
+
+fn test_atan2() {
+    h r = atan2(1.0, 1.0);
+    h pi_quarter = pi() / 4.0;
+    assert_true(approx_eq(r, pi_quarter, 0.000000001), "atan2(1, 1) should be pi/4");
+}
+
+fn test_hypot() {
+    h r = hypot(3.0, 4.0);
+    assert_true(approx_eq(r, 5.0, 0.000000001), "hypot(3, 4) should be 5");
+}
+
+fn test_lerp_endpoints() {
+    h r0 = lerp(10.0, 20.0, 0.0);
+    h r1 = lerp(10.0, 20.0, 1.0);
+    assert_true(approx_eq(r0, 10.0, 0.000000001), "lerp(a, b, 0) = a");
+    assert_true(approx_eq(r1, 20.0, 0.000000001), "lerp(a, b, 1) = b");
+}
+
+fn test_lerp_midpoint() {
+    h r = lerp(10.0, 20.0, 0.5);
+    assert_true(approx_eq(r, 15.0, 0.000000001), "lerp midpoint should be 15");
+}
+
+# ---------- Array stats ----------
+
+fn test_arr_mean() {
+    h r = arr_mean([1, 2, 3, 4, 5]);
+    assert_true(approx_eq(r, 3.0, 0.000000001), "arr_mean([1..5]) should be 3");
+}
+
+fn test_arr_variance() {
+    # population variance of [2, 4, 4, 4, 5, 5, 7, 9] is 4
+    h r = arr_variance([2, 4, 4, 4, 5, 5, 7, 9]);
+    assert_true(approx_eq(r, 4.0, 0.000000001), "variance of textbook example is 4");
+}
+
+fn test_arr_stddev() {
+    h r = arr_stddev([2, 4, 4, 4, 5, 5, 7, 9]);
+    assert_true(approx_eq(r, 2.0, 0.000000001), "stddev should be sqrt(4) = 2");
+}
+
+fn test_arr_median_odd() {
+    h r = arr_median([7, 1, 5, 3, 9]);
+    assert_true(approx_eq(r, 5.0, 0.000000001), "median of odd-length set");
+}
+
+fn test_arr_median_even() {
+    h r = arr_median([1, 2, 3, 4]);
+    assert_true(approx_eq(r, 2.5, 0.000000001), "median of even-length set is mean of middle two");
+}
+
+fn test_arr_harmonic_mean() {
+    # H([1, 2, 4]) = 3 / (1/1 + 1/2 + 1/4) = 3 / 1.75 ≈ 1.7142857...
+    h r = arr_harmonic_mean([1, 2, 4]);
+    assert_true(approx_eq(r, 1.7142857142857142, 0.000000001), "harmonic mean of [1,2,4]");
+}
+
+fn test_arr_geometric_mean() {
+    # G([2, 8]) = sqrt(16) = 4
+    h r = arr_geometric_mean([2, 8]);
+    assert_true(approx_eq(r, 4.0, 0.000000001), "geometric mean of [2, 8] is 4");
+}
+
+fn test_arr_sum_sq() {
+    h r = arr_sum_sq([1, 2, 3]);
+    assert_true(approx_eq(r, 14.0, 0.000000001), "sum of squares 1+4+9 = 14");
+}
+
+fn test_arr_norm() {
+    h r = arr_norm([3, 4]);
+    assert_true(approx_eq(r, 5.0, 0.000000001), "L2 norm of [3, 4] is 5");
+}
+
+fn test_arr_dot() {
+    h r = arr_dot([1, 2, 3], [4, 5, 6]);
+    assert_true(approx_eq(r, 32.0, 0.000000001), "dot product 1*4 + 2*5 + 3*6 = 32");
+}
+
+# ---------- Substrate primitives ----------
+
+fn test_attractor_distance_zero() {
+    # 89 IS a Fibonacci attractor → distance 0
+    assert_eq(attractor_distance(89), 0, "89 is on attractor");
+}
+
+fn test_attractor_distance_nonzero() {
+    # 100 nearest attractor is 89 (dist 11) or 144 (dist 44) → 11
+    assert_eq(attractor_distance(100), 11, "100 → 89, dist 11");
+}
+
+fn test_nearest_attractor() {
+    assert_eq(nearest_attractor(100), 89, "100 nearest = 89");
+    assert_eq(nearest_attractor(0 - 100), 0 - 89, "-100 nearest = -89 (sign preserved)");
+    assert_eq(nearest_attractor(89), 89, "exact attractor returns itself");
+}
+
+fn test_largest_attractor_at_most() {
+    assert_eq(largest_attractor_at_most(100), 89, "largest <= 100 is 89");
+    assert_eq(largest_attractor_at_most(89), 89, "largest <= 89 is 89");
+    assert_eq(largest_attractor_at_most(0), 0, "largest <= 0 is 0");
+}
+
+fn test_crt_residues() {
+    # CRT-PE construction from experiment 10
+    h r = crt_residues(42, [5, 8, 13, 21]);
+    assert_eq(arr_get(r, 0), 2, "42 % 5 = 2");
+    assert_eq(arr_get(r, 1), 2, "42 % 8 = 2");
+    assert_eq(arr_get(r, 2), 3, "42 % 13 = 3");
+    assert_eq(arr_get(r, 3), 0, "42 % 21 = 0");
+}
+
+fn test_hbit_tension() {
+    # Same as attractor_distance — different name for the same primitive.
+    assert_eq(hbit_tension(89), 0, "on-attractor tension is 0");
+    assert_eq(hbit_tension(100), 11, "off-attractor tension matches distance");
+}

omnimcode-core/src/compiler.rs

@@ -151,6 +151,9 @@ impl Compiler {
                         | "pow_int" | "square" | "cube" | "sign" | "to_int"
                         | "int" | "classify_resonance" | "safe_add" | "safe_sub"
                         | "safe_mul"
+                        // Substrate primitives — int returns
+                        | "attractor_distance" | "nearest_attractor"
+                        | "largest_attractor_at_most" | "hbit_tension"
                         // 2026-05-14 stdlib expansion (ints)
                         | "str_index_of" | "str_starts_with" | "str_ends_with"
                         | "file_exists" | "write_file" | "gcd" | "lcm"
@@ -159,8 +162,14 @@ impl Compiler {
                         | "random_int" | "random_seed"
                         // test runner ints
                         | "test_failure_count" | "test_record_failure" => Some("int"),
-                        "pow" | "sqrt" | "log" | "exp" | "sin" | "cos" | "tan"
+                        "pow" | "sqrt" | "log" | "log2" | "log10"
+                        | "exp" | "sin" | "cos" | "tan" | "asin" | "acos"
+                        | "atan" | "atan2" | "hypot" | "lerp"
                         | "tanh" | "erf" | "sigmoid" | "frac" | "clamp"
+                        | "arr_mean" | "arr_variance" | "arr_stddev"
+                        | "arr_median" | "arr_harmonic_mean"
+                        | "arr_geometric_mean" | "arr_sum_sq"
+                        | "arr_norm" | "arr_dot"
                         | "pi" | "e" | "phi" | "tau" | "phi_inv" | "phi_sq"
                         | "phi_squared" | "sqrt_2" | "sqrt_5" | "ln_2"
                         | "to_float" | "float" | "interfere"