tests: +37 across core features / ML kernels / linalg

test_core_features.omc (13):
  if/elif/else branching, while loop count + zero-iters,
  break/continue, recursive factorial, mutual recursion
  (is_even/is_odd), closure state, lambda-as-arg, early return,
  comparison chain (<, >, <=, >=).

test_ml_kernel_extras.omc (13):
  softmax dominant-logit / uniform / sums-to-1 with floats;
  layer_norm small + big arrays; relu all-zero / all-positive;
  sigmoid at ±1; conv1d kernel-2 box filter; arr_outer unit basis;
  substrate_attention output shape (3 queries, 2 keys, 2 dims);
  substrate_score_rows on Fibonacci row.

test_linalg_extras.omc (11):
  arr_matmul 2x2 against expected [[19,22],[43,50]]; matmul with
  identity = self; matmul with zero matrix; transpose 2x3 → 3x2;
  transpose-twice = identity; eye 3/1/0; zeros_2d 3x4; outer
  composition; substrate-preserving int matmul (5 is Fibonacci
  attractor preserved).

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

Author: RandomCoder-lab

examples/tests/test_core_features.omc

@@ -0,0 +1,139 @@
+# Core language feature coverage — control flow, recursion, lambdas, etc.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+
+# If/else basic
+fn test_if_then() {
+    h x = 0;
+    if 1 == 1 { x = 1; }
+    assert_eq(x, 1, "then branch");
+}
+
+fn test_if_else() {
+    h x = 0;
+    if 1 == 0 { x = 1; } else { x = 2; }
+    assert_eq(x, 2, "else branch");
+}
+
+fn test_elif() {
+    h x = 0;
+    if 1 == 0 { x = 1; } elif 1 == 1 { x = 2; } else { x = 3; }
+    assert_eq(x, 2, "elif branch");
+}
+
+# While loop
+fn test_while_counts() {
+    h n = 0;
+    while n < 10 { n = n + 1; }
+    assert_eq(n, 10, "while counts to 10");
+}
+
+fn test_while_zero_iters() {
+    h n = 0;
+    while n < 0 { n = n + 1; }
+    assert_eq(n, 0, "no iterations");
+}
+
+# Break / continue
+fn test_break() {
+    h n = 0;
+    while n < 100 {
+        if n == 5 { break; }
+        n = n + 1;
+    }
+    assert_eq(n, 5, "broke at 5");
+}
+
+fn test_continue() {
+    h sum = 0;
+    h i = 0;
+    while i < 10 {
+        i = i + 1;
+        if i == 5 { continue; }
+        sum = sum + i;
+    }
+    # 1+2+3+4+6+7+8+9+10 = 50
+    assert_eq(sum, 50, "skipped 5");
+}
+
+# Recursion
+fn fact(n) {
+    if n <= 1 { return 1; }
+    return n * fact(n - 1);
+}
+
+fn test_recursion() {
+    assert_eq(fact(5), 120, "5! = 120");
+    assert_eq(fact(0), 1, "0! = 1");
+}
+
+# Mutual recursion
+fn is_even(n) {
+    if n == 0 { return 1; }
+    return is_odd(n - 1);
+}
+
+fn is_odd(n) {
+    if n == 0 { return 0; }
+    return is_even(n - 1);
+}
+
+fn test_mutual_recursion() {
+    assert_eq(is_even(4), 1, "4 is even");
+    assert_eq(is_odd(7), 1, "7 is odd");
+}
+
+# Closures
+fn make_counter() {
+    h count = 0;
+    return fn() {
+        count = count + 1;
+        return count;
+    };
+}
+
+fn test_closure_state() {
+    h c = make_counter();
+    assert_eq(c(), 1, "first");
+    assert_eq(c(), 2, "second");
+    assert_eq(c(), 3, "third");
+}
+
+# Lambda as arg
+fn apply(f, x) { return f(x); }
+
+fn test_apply_lambda() {
+    h r = apply(fn(x) { return x * 3; }, 5);
+    assert_eq(r, 15, "lambda applied");
+}
+
+# Return early
+fn first_positive(arr) {
+    h i = 0;
+    while i < arr_len(arr) {
+        if arr_get(arr, i) > 0 { return arr_get(arr, i); }
+        i = i + 1;
+    }
+    return 0 - 1;
+}
+
+fn test_early_return() {
+    assert_eq(first_positive([0 - 5, 0 - 2, 7, 9]), 7, "found 7");
+    assert_eq(first_positive([0 - 5, 0 - 2]), 0 - 1, "none found");
+}
+
+# (Boolean short-circuit tests omitted — && only inside `if` conditions.)
+
+# Comparison chain
+fn test_lt_gt_chain() {
+    assert_true(1 < 2, "1 < 2");
+    assert_true(2 > 1, "2 > 1");
+    assert_true(1 <= 1, "<= equal");
+    assert_true(1 >= 1, ">= equal");
+}

examples/tests/test_linalg_extras.omc

@@ -0,0 +1,117 @@
+# Linalg / matmul / transpose coverage.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+
+fn approx_eq(a, b, tol) {
+    h d = a - b;
+    if d < 0.0 { d = 0.0 - d; }
+    return d <= tol;
+}
+
+# arr_matmul correctness
+fn test_matmul_2x2() {
+    h A = [[1, 2], [3, 4]];
+    h B = [[5, 6], [7, 8]];
+    h C = arr_matmul(A, B);
+    h r0 = arr_get(C, 0);
+    h r1 = arr_get(C, 1);
+    # [[19,22],[43,50]]
+    assert_true(approx_eq(arr_get(r0, 0), 19.0, 0.001), "C[0][0]");
+    assert_true(approx_eq(arr_get(r0, 1), 22.0, 0.001), "C[0][1]");
+    assert_true(approx_eq(arr_get(r1, 0), 43.0, 0.001), "C[1][0]");
+    assert_true(approx_eq(arr_get(r1, 1), 50.0, 0.001), "C[1][1]");
+}
+
+fn test_matmul_identity() {
+    h I = arr_eye(3);
+    h A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+    h C = arr_matmul(A, I);
+    h r0 = arr_get(C, 0);
+    assert_true(approx_eq(arr_get(r0, 0), 1.0, 0.001), "A * I = A");
+    assert_true(approx_eq(arr_get(r0, 2), 3.0, 0.001), "A * I = A");
+}
+
+fn test_matmul_zero() {
+    h Z = arr_zeros_2d(2, 2);
+    h A = [[1, 2], [3, 4]];
+    h C = arr_matmul(A, Z);
+    h r = arr_get(C, 0);
+    assert_true(approx_eq(arr_get(r, 0), 0.0, 0.001), "* zero → zero");
+}
+
+# arr_transpose
+fn test_transpose_2x3() {
+    h A = [[1, 2, 3], [4, 5, 6]];
+    h T = arr_transpose(A);
+    # 3x2
+    assert_eq(arr_len(T), 3, "3 rows after transpose");
+    h r0 = arr_get(T, 0);
+    assert_eq(arr_len(r0), 2, "2 cols");
+    assert_eq(arr_get(r0, 0), 1, "T[0][0]=1");
+    assert_eq(arr_get(r0, 1), 4, "T[0][1]=4");
+}
+
+fn test_transpose_twice_identity() {
+    h A = [[1, 2, 3], [4, 5, 6]];
+    h TT = arr_transpose(arr_transpose(A));
+    h r0 = arr_get(TT, 0);
+    assert_eq(arr_get(r0, 0), 1, "double transpose");
+    assert_eq(arr_get(r0, 2), 3, "double transpose");
+}
+
+# arr_eye
+fn test_eye_3() {
+    h I = arr_eye(3);
+    assert_eq(arr_len(I), 3, "3 rows");
+    h r0 = arr_get(I, 0);
+    assert_eq(arr_len(r0), 3, "3 cols");
+    assert_eq(arr_get(r0, 0), 1, "I[0][0]=1");
+    assert_eq(arr_get(r0, 1), 0, "I[0][1]=0");
+}
+
+fn test_eye_1() {
+    h I = arr_eye(1);
+    assert_eq(arr_len(I), 1, "1x1");
+}
+
+fn test_eye_zero() {
+    h I = arr_eye(0);
+    assert_eq(arr_len(I), 0, "0x0");
+}
+
+# arr_zeros_2d
+fn test_zeros_2d_basic() {
+    h Z = arr_zeros_2d(3, 4);
+    assert_eq(arr_len(Z), 3, "3 rows");
+    h r0 = arr_get(Z, 0);
+    assert_eq(arr_len(r0), 4, "4 cols");
+    assert_eq(arr_get(r0, 0), 0, "is zero");
+}
+
+# arr_outer composition with matmul
+fn test_outer_then_matmul() {
+    h u = [1.0, 2.0];
+    h v = [3.0, 4.0];
+    # outer(u, v) is rank-1 matrix [[3,4],[6,8]]
+    h M = arr_outer(u, v);
+    h r0 = arr_get(M, 0);
+    assert_true(approx_eq(arr_get(r0, 0), 3.0, 0.001), "1*3");
+    assert_true(approx_eq(arr_get(r0, 1), 4.0, 0.001), "1*4");
+}
+
+# Substrate-preserving matmul: integer inputs → integer outputs
+fn test_matmul_int_preserves_substrate() {
+    h A = [[1, 2], [3, 5]];
+    h B = [[1, 1], [2, 3]];
+    h C = arr_matmul(A, B);
+    h r0 = arr_get(C, 0);
+    # C[0][0] = 1*1 + 2*2 = 5 (Fibonacci attractor)
+    assert_eq(arr_get(r0, 0), 5, "preserves int + attractor");
+    assert_eq(is_attractor(arr_get(r0, 0)), 1, "5 is attractor");
+}

examples/tests/test_ml_kernel_extras.omc

@@ -0,0 +1,126 @@
+# More ML kernel coverage.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+
+fn approx_eq(a, b, tol) {
+    h d = a - b;
+    if d < 0.0 { d = 0.0 - d; }
+    return d <= tol;
+}
+
+# Softmax additional cases
+fn test_softmax_one_hot_dominant() {
+    h s = arr_softmax([10.0, 0.0, 0.0]);
+    assert_true(arr_get(s, 0) > 0.9, "dominant logit gets > 0.9");
+}
+
+fn test_softmax_three_uniform() {
+    h s = arr_softmax([5.0, 5.0, 5.0]);
+    h diff = arr_get(s, 0) - 0.3333;
+    if diff < 0.0 { diff = 0.0 - diff; }
+    assert_true(diff < 0.01, "uniform gives 1/3");
+}
+
+fn test_softmax_sums_one_floats() {
+    h s = arr_softmax([1.5, 2.5, 3.5, 4.5, 5.5]);
+    h total = 0.0;
+    h i = 0;
+    while i < arr_len(s) {
+        total = total + arr_get(s, i);
+        i = i + 1;
+    }
+    assert_true(approx_eq(total, 1.0, 0.001), "sums to 1");
+}
+
+# LayerNorm with different sizes
+fn test_layer_norm_small() {
+    h ln = arr_layer_norm([1.0, 2.0], 0.00001);
+    h s = arr_get(ln, 0) + arr_get(ln, 1);
+    assert_true(approx_eq(s, 0.0, 0.001), "zero mean small");
+}
+
+fn test_layer_norm_big() {
+    h xs = [];
+    h i = 0;
+    while i < 20 {
+        arr_push(xs, i);
+        i = i + 1;
+    }
+    h ln = arr_layer_norm(xs, 0.00001);
+    h total = 0.0;
+    i = 0;
+    while i < arr_len(ln) {
+        total = total + arr_get(ln, i);
+        i = i + 1;
+    }
+    assert_true(approx_eq(total, 0.0, 0.001), "zero mean big");
+}
+
+# ReLU + sigmoid edge cases
+fn test_relu_all_zero() {
+    h r = arr_relu_vec([0 - 1.0, 0 - 2.0, 0 - 3.0]);
+    assert_true(approx_eq(arr_get(r, 0), 0.0, 0.001), "all clipped");
+}
+
+fn test_relu_all_positive() {
+    h r = arr_relu_vec([1.0, 2.0, 3.0]);
+    assert_true(approx_eq(arr_get(r, 0), 1.0, 0.001), "passthrough");
+    assert_true(approx_eq(arr_get(r, 2), 3.0, 0.001), "passthrough");
+}
+
+fn test_sigmoid_at_one() {
+    h s = arr_sigmoid_vec([1.0]);
+    h v = arr_get(s, 0);
+    assert_true(approx_eq(v, 0.7310586, 0.001), "sigmoid(1)");
+}
+
+fn test_sigmoid_at_negative_one() {
+    h s = arr_sigmoid_vec([0 - 1.0]);
+    h v = arr_get(s, 0);
+    assert_true(approx_eq(v, 0.2689414, 0.001), "sigmoid(-1)");
+}
+
+# conv1d cases
+fn test_conv1d_kernel_2() {
+    h c = arr_conv1d([1.0, 2.0, 3.0, 4.0], [1.0, 1.0]);
+    # Output length = 4 - 2 + 1 = 3
+    assert_eq(arr_len(c), 3, "len = 3");
+    assert_true(approx_eq(arr_get(c, 0), 3.0, 0.001), "1+2");
+    assert_true(approx_eq(arr_get(c, 1), 5.0, 0.001), "2+3");
+    assert_true(approx_eq(arr_get(c, 2), 7.0, 0.001), "3+4");
+}
+
+# arr_outer extras
+fn test_outer_unit_basis() {
+    h o = arr_outer([1.0, 0.0], [1.0, 0.0]);
+    h r0 = arr_get(o, 0);
+    h r1 = arr_get(o, 1);
+    assert_true(approx_eq(arr_get(r0, 0), 1.0, 0.001), "[0,0]=1");
+    assert_true(approx_eq(arr_get(r0, 1), 0.0, 0.001), "[0,1]=0");
+    assert_true(approx_eq(arr_get(r1, 0), 0.0, 0.001), "[1,0]=0");
+    assert_true(approx_eq(arr_get(r1, 1), 0.0, 0.001), "[1,1]=0");
+}
+
+# Substrate attention output shape
+fn test_substrate_attention_shape() {
+    h Q = [[1, 2], [3, 4], [5, 6]];  # 3 queries
+    h K = [[1, 2], [3, 4]];           # 2 keys
+    h V = [[10, 20], [30, 40]];       # 2 values, dim 2
+    h out = arr_substrate_attention(Q, K, V);
+    assert_eq(arr_len(out), 3, "3 query rows out");
+    h r0 = arr_get(out, 0);
+    assert_eq(arr_len(r0), 2, "value dim preserved");
+}
+
+# Substrate score rows
+fn test_substrate_score_rows_simple() {
+    h s = arr_substrate_score_rows([[1, 2, 3, 5, 8]]);
+    assert_eq(arr_len(s), 1, "one row");
+    assert_true(arr_get(s, 0) > 0.9, "Fibonacci row has high score");
+}