redscript-mc 2.5.0 → 2.6.2

package/src/stdlib/linalg.mcrs

@@ -0,0 +1,260 @@
+// linalg.mcrs — Double-precision linear algebra for RedScript.
+//
+// Provides 2D/3D vector operations, 2×2 matrix arithmetic, and
+// 2×2 linear system solving, all in IEEE 754 double precision.
+//
+// DEPENDENCIES:
+//   import "stdlib/math_hp"   (for double_sqrt, double_add, double_sub,
+//                               double_mul, double_div)
+//
+// USAGE EXAMPLE:
+//   import "stdlib/linalg"
+//   import "stdlib/math_hp"
+//
+//   // Normalize a 3D direction vector
+//   fn aim_dir(dx: double, dy: double, dz: double) {
+//       let nx: double = vec3d_normalize_x(dx, dy, dz);
+//       let ny: double = vec3d_normalize_y(dx, dy, dz);
+//       let nz: double = vec3d_normalize_z(dx, dy, dz);
+//   }
+//
+//   // Solve Ax = b for rotation matrix inverse
+//   //   [cos θ  -sin θ] [x]   [bx]
+//   //   [sin θ   cos θ] [y] = [by]
+//   fn rotate_inv(c: double, s: double, bx: double, by: double) {
+//       let ns: double = double_sub(0.0d, s);
+//       let x: double = solve2d_x(c, ns, s, c, bx, by);
+//       let y: double = solve2d_y(c, ns, s, c, bx, by);
+//   }
+
+module library;
+
+// ─── 2D Vector ────────────────────────────────────────────────────────────────
+
+// vec2d_dot(ax, ay, bx, by): dot product of 2D vectors a and b.
+fn vec2d_dot(ax: double, ay: double, bx: double, by: double): double {
+    let t0: double = ax * bx;
+    let t1: double = ay * by;
+    return t0 + t1;
+}
+
+// vec2d_length(x, y): Euclidean length of 2D vector.
+fn vec2d_length(x: double, y: double): double {
+    let xx: double = x * x;
+    let yy: double = y * y;
+    let s: double = xx + yy;
+    return double_sqrt(s) as double;
+}
+
+// vec2d_dist(ax, ay, bx, by): Euclidean distance between two 2D points.
+fn vec2d_dist(ax: double, ay: double, bx: double, by: double): double {
+    let dx: double = ax - bx;
+    let dy: double = ay - by;
+    return vec2d_length(dx, dy);
+}
+
+// _vec2d_len_sq_fx(x, y): squared length as ×10000 fixed int (for zero-check).
+fn _vec2d_len_sq_fx(x: double, y: double): int {
+    let xx: double = x * x;
+    let yy: double = y * y;
+    let sq: double = xx + yy;
+    return sq as int;
+}
+
+// vec2d_normalize_x(x, y): x component of the unit vector.
+//   Returns 0.0 if the vector has zero length.
+fn vec2d_normalize_x(x: double, y: double): double {
+    let sq_fx: int = _vec2d_len_sq_fx(x, y);
+    if (sq_fx == 0) {
+        return 0.0d;
+    }
+    let len: double = vec2d_length(x, y);
+    return x / len;
+}
+
+// vec2d_normalize_y(x, y): y component of the unit vector.
+//   Returns 0.0 if the vector has zero length.
+fn vec2d_normalize_y(x: double, y: double): double {
+    let sq_fx: int = _vec2d_len_sq_fx(x, y);
+    if (sq_fx == 0) {
+        return 0.0d;
+    }
+    let len: double = vec2d_length(x, y);
+    return y / len;
+}
+
+// ─── 3D Vector ────────────────────────────────────────────────────────────────
+
+// vec3d_dot(ax,ay,az, bx,by,bz): dot product of 3D vectors a and b.
+fn vec3d_dot(ax: double, ay: double, az: double, bx: double, by: double, bz: double): double {
+    let t0: double = ax * bx;
+    let t1: double = ay * by;
+    let t2: double = az * bz;
+    let s: double = t0 + t1;
+    return s + t2;
+}
+
+// vec3d_length(x, y, z): Euclidean length of 3D vector.
+fn vec3d_length(x: double, y: double, z: double): double {
+    let xx: double = x * x;
+    let yy: double = y * y;
+    let zz: double = z * z;
+    let s: double = xx + yy;
+    let s2: double = s + zz;
+    return double_sqrt(s2) as double;
+}
+
+// vec3d_dist(ax,ay,az, bx,by,bz): Euclidean distance between two 3D points.
+fn vec3d_dist(ax: double, ay: double, az: double, bx: double, by: double, bz: double): double {
+    let dx: double = ax - bx;
+    let dy: double = ay - by;
+    let dz: double = az - bz;
+    return vec3d_length(dx, dy, dz);
+}
+
+// vec3d_cross_x: x component of cross product a × b.
+fn vec3d_cross_x(ax: double, ay: double, az: double, bx: double, by: double, bz: double): double {
+    let t0: double = ay * bz;
+    let t1: double = az * by;
+    return t0 - t1;
+}
+
+// vec3d_cross_y: y component of cross product a × b.
+fn vec3d_cross_y(ax: double, ay: double, az: double, bx: double, by: double, bz: double): double {
+    let t0: double = az * bx;
+    let t1: double = ax * bz;
+    return t0 - t1;
+}
+
+// vec3d_cross_z: z component of cross product a × b.
+fn vec3d_cross_z(ax: double, ay: double, az: double, bx: double, by: double, bz: double): double {
+    let t0: double = ax * by;
+    let t1: double = ay * bx;
+    return t0 - t1;
+}
+
+// _vec3d_len_sq_fx(x, y, z): squared length as ×10000 fixed int (for zero-check).
+fn _vec3d_len_sq_fx(x: double, y: double, z: double): int {
+    let xx: double = x * x;
+    let yy: double = y * y;
+    let zz: double = z * z;
+    let s: double = xx + yy;
+    let sq: double = s + zz;
+    return sq as int;
+}
+
+// vec3d_normalize_x(x, y, z): x component of the unit vector.
+//   Returns 0.0 if the vector has zero length.
+fn vec3d_normalize_x(x: double, y: double, z: double): double {
+    let sq_fx: int = _vec3d_len_sq_fx(x, y, z);
+    if (sq_fx == 0) {
+        return 0.0d;
+    }
+    let len: double = vec3d_length(x, y, z);
+    return x / len;
+}
+
+// vec3d_normalize_y(x, y, z): y component of the unit vector.
+//   Returns 0.0 if the vector has zero length.
+fn vec3d_normalize_y(x: double, y: double, z: double): double {
+    let sq_fx: int = _vec3d_len_sq_fx(x, y, z);
+    if (sq_fx == 0) {
+        return 0.0d;
+    }
+    let len: double = vec3d_length(x, y, z);
+    return y / len;
+}
+
+// vec3d_normalize_z(x, y, z): z component of the unit vector.
+//   Returns 0.0 if the vector has zero length.
+fn vec3d_normalize_z(x: double, y: double, z: double): double {
+    let sq_fx: int = _vec3d_len_sq_fx(x, y, z);
+    if (sq_fx == 0) {
+        return 0.0d;
+    }
+    let len: double = vec3d_length(x, y, z);
+    return z / len;
+}
+
+// ─── 2×2 Matrix ───────────────────────────────────────────────────────────────
+//
+// Row-major layout:
+//   [ a  b ]   a = m[0,0]  b = m[0,1]
+//   [ c  d ]   c = m[1,0]  d = m[1,1]
+
+// mat2d_det(a,b,c,d): determinant of a 2×2 matrix.
+fn mat2d_det(a: double, b: double, c: double, d: double): double {
+    let t0: double = a * d;
+    let t1: double = b * c;
+    return t0 - t1;
+}
+
+// mat2d_mul_r0c0: element [0,0] of matrix product M0 × M1.
+fn mat2d_mul_r0c0(a0: double, b0: double, c0: double, d0: double, a1: double, b1: double, c1: double, d1: double): double {
+    let t0: double = a0 * a1;
+    let t1: double = b0 * c1;
+    return t0 + t1;
+}
+
+// mat2d_mul_r0c1: element [0,1] of matrix product M0 × M1.
+fn mat2d_mul_r0c1(a0: double, b0: double, c0: double, d0: double, a1: double, b1: double, c1: double, d1: double): double {
+    let t0: double = a0 * b1;
+    let t1: double = b0 * d1;
+    return t0 + t1;
+}
+
+// mat2d_mul_r1c0: element [1,0] of matrix product M0 × M1.
+fn mat2d_mul_r1c0(a0: double, b0: double, c0: double, d0: double, a1: double, b1: double, c1: double, d1: double): double {
+    let t0: double = c0 * a1;
+    let t1: double = d0 * c1;
+    return t0 + t1;
+}
+
+// mat2d_mul_r1c1: element [1,1] of matrix product M0 × M1.
+fn mat2d_mul_r1c1(a0: double, b0: double, c0: double, d0: double, a1: double, b1: double, c1: double, d1: double): double {
+    let t0: double = c0 * b1;
+    let t1: double = d0 * d1;
+    return t0 + t1;
+}
+
+// mat2d_vecmul_x(a,b,c,d, vx,vy): x component of matrix-vector product M × v.
+fn mat2d_vecmul_x(a: double, b: double, c: double, d: double, vx: double, vy: double): double {
+    let t0: double = a * vx;
+    let t1: double = b * vy;
+    return t0 + t1;
+}
+
+// mat2d_vecmul_y(a,b,c,d, vx,vy): y component of matrix-vector product M × v.
+fn mat2d_vecmul_y(a: double, b: double, c: double, d: double, vx: double, vy: double): double {
+    let t0: double = c * vx;
+    let t1: double = d * vy;
+    return t0 + t1;
+}
+
+// ─── Solve 2×2 Linear System (Cramer's rule) ──────────────────────────────────
+//
+// Solves  [ a  b ] [x]   [ex]
+//         [ c  d ] [y] = [ey]
+//
+// x = (ex*d - b*ey) / det
+// y = (a*ey - ex*c) / det
+//
+// NOTE: det must be non-zero; no guard is applied (caller's responsibility).
+
+// solve2d_x: x solution component via Cramer's rule.
+fn solve2d_x(a: double, b: double, c: double, d: double, ex: double, ey: double): double {
+    let num: double = ex * d;
+    let sub: double = b * ey;
+    let numer: double = num - sub;
+    let det: double = mat2d_det(a, b, c, d);
+    return numer / det;
+}
+
+// solve2d_y: y solution component via Cramer's rule.
+fn solve2d_y(a: double, b: double, c: double, d: double, ex: double, ey: double): double {
+    let num: double = a * ey;
+    let sub: double = ex * c;
+    let numer: double = num - sub;
+    let det: double = mat2d_det(a, b, c, d);
+    return numer / det;
+}

package/src/stdlib/list.mcrs

@@ -170,3 +170,102 @@ fn list_sort_desc(arr: int[], len: int) {
         i = i + 1;
     }
 }
+
+// ─── Dynamic array aggregates ─────────────────────────────────────────────────
+
+// list_sum(arr, len): sum of all elements
+fn list_sum(arr: int[], len: int): int {
+    let s: int = 0;
+    let i: int = 0;
+    while (i < len) {
+        s = s + arr[i];
+        i = i + 1;
+    }
+    return s;
+}
+
+// list_avg(arr, len): arithmetic mean ×10000 (fixed-point)
+// Returns (sum * 10000) / len; returns 0 for empty array
+fn list_avg(arr: int[], len: int): int {
+    if (len <= 0) { return 0; }
+    let s: int = list_sum(arr, len);
+    return s * 10000 / len;
+}
+
+// list_min(arr, len): minimum element in array
+fn list_min(arr: int[], len: int): int {
+    let m: int = arr[0];
+    let i: int = 1;
+    while (i < len) {
+        if (arr[i] < m) { m = arr[i]; }
+        i = i + 1;
+    }
+    return m;
+}
+
+// list_max(arr, len): maximum element in array
+fn list_max(arr: int[], len: int): int {
+    let m: int = arr[0];
+    let i: int = 1;
+    while (i < len) {
+        if (arr[i] > m) { m = arr[i]; }
+        i = i + 1;
+    }
+    return m;
+}
+
+// list_contains(arr, len, val): 1 if val is in arr, 0 otherwise
+fn list_contains(arr: int[], len: int, val: int): int {
+    let i: int = 0;
+    while (i < len) {
+        if (arr[i] == val) { return 1; }
+        i = i + 1;
+    }
+    return 0;
+}
+
+// list_index_of(arr, len, val): first index of val in arr, or -1 if not found
+fn list_index_of(arr: int[], len: int, val: int): int {
+    let i: int = 0;
+    while (i < len) {
+        if (arr[i] == val) { return i; }
+        i = i + 1;
+    }
+    return -1;
+}
+
+// list_shuffle(arr, len, seed): Fisher-Yates shuffle in-place using next_lcg RNG
+// For each i from len-1 down to 1: pick j in [0, i] using next_lcg, swap arr[i] and arr[j]
+fn list_shuffle(arr: int[], len: int, seed: int): int[] {
+    let i: int = len - 1;
+    let s: int = seed;
+    while (i > 0) {
+        s = next_lcg(s);
+        let r: int = s;
+        if (r < 0) { r = 0 - r; }
+        let j: int = r % (i + 1);
+        let tmp: int = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+        i = i - 1;
+    }
+    return arr;
+}
+
+// list_dedup_count(arr, len): count of unique values (O(n²) — fine for small arrays)
+fn list_dedup_count(arr: int[], len: int): int {
+    let count: int = 0;
+    let i: int = 0;
+    while (i < len) {
+        // Check if arr[i] appeared before index i
+        let seen: int = 0;
+        let j: int = 0;
+        while (j < i) {
+            if (arr[j] == arr[i]) { seen = 1; }
+            j = j + 1;
+        }
+        if (seen == 0) { count = count + 1; }
+        i = i + 1;
+    }
+    return count;
+}

package/src/stdlib/math.mcrs

@@ -314,13 +314,14 @@ fn smootherstep(lo: int, hi: int, x: int) -> int {
 fn ln(x: int): int {
     // Input x: fixed-point ×10000; returns ln(x/10000)×10000
     // Valid range: x ∈ [100, 1000000]  (0.01 ~ 100.0)
-    // max_error: 0.000557 (in ×10000 units, i.e. 0.00000006 in real units)
+    // max_error: 0.000504 (in ×10000 units, i.e. 0.00000005 in real units)
+    // Tuned 2026-03-17 via SA (30k iterations), prev: A1=20010 A3=6856 A5=2539
 
     let scale: int = 10000;
     let ln2: int = 6931;
-    let A1: int = 20010;
-    let A3: int = 6856;
-    let A5: int = 2539;
+    let A1: int = 20026;
+    let A3: int = 6394;
+    let A5: int = 5511;
 
     // Step 1: range reduction — bring x into [scale, 2*scale)
     let xr: int = x;
@@ -348,11 +349,18 @@ fn ln(x: int): int {
 }
 
 // sqrt_fx(x): fixed-point sqrt, scale ×10000
+// Input x ×10000 (e.g. 40000 = 4.0)
+// Returns √(x/10000) × 10000
 // sqrt_fx(10000) == 10000  (√1.0 = 1.0)
 // sqrt_fx(20000) ≈ 14142   (√2.0 ≈ 1.4142)
 // sqrt_fx(40000) == 20000  (√4.0 = 2.0)
 fn sqrt_fx(x: int) -> int {
-    return isqrt(x * 100) * 100;
+    // √(x/10000) × 10000 = √x × 100
+    // isqrt(x) returns ⌊√x⌋, so isqrt(x) × 100 ≈ ⌊√x⌋ × 100
+    // For x=40000: isqrt(40000)=200, ×100=20000 ✓
+    // For x=10000: isqrt(10000)=100, ×100=10000 ✓
+    // For x=20000: isqrt(20000)=141, ×100=14100 (vs exact 14142, ≈0.3% error)
+    return isqrt(x) * 100;
 }
 
 // exp_fx(x): e^(x/10000) × 10000, fixed-point ×10000
@@ -527,3 +535,111 @@ fn approx_eq(a: int, b: int, eps: int): int {
     if (d <= eps) { return 1; }
     return 0;
 }
+
+// ─── Cubic root via Cardano / Newton ─────────────────────────────────────────
+
+// cbrt_newton(x): cube root using Newton-Raphson, more iterations than cbrt_fx
+// Returns floor(cbrt(x)) with better convergence for large values
+fn cbrt_newton(x: int): int {
+    if (x <= 0) { return 0; }
+    let g: int = cbrt_fx(x);  // start from cbrt_fx estimate
+    // Two Newton refinement steps: g = (2*g + x/g²) / 3
+    let g2: int = g * g;
+    if (g2 > 0) {
+        let next: int = (2 * g + x / g2) / 3;
+        let n2: int = next * next;
+        if (n2 > 0) { g = (2 * next + x / n2) / 3; } else { g = next; }
+    }
+    return g;
+}
+
+// ─── Cubic equation x³ + px + q = 0 (depressed cubic) ───────────────────────
+// Cardano's method, integer fixed-point ×10000
+// Returns the real root × 10000
+// Only works for depressed cubic (no x² term)
+// For ax³+bx²+cx+d=0, first substitute x = t - b/(3a) to depress
+
+// cubic_one_root_fx(p_fx, q_fx): real root of t³ + p*t + q = 0
+// p_fx, q_fx: coefficients ×10000
+// Returns t ×10000
+fn cubic_disc_fx(p_fx: int, q_fx: int): int {
+    // Discriminant: D = (q/2)² + (p/3)³
+    // ×10000 scale: q_fx/2 in units, cube of p_fx/3 tricky
+    let half_q: int = q_fx / 2;
+    let third_p: int = p_fx / 3;
+    // D = half_q² + third_p³ (×10000 each → result ×10000)
+    let d: int = half_q * half_q / 10000 + third_p * third_p / 10000 * third_p / 10000;
+    return d;
+}
+
+// Newton iteration for general cubic: ax³ + bx² + cx + d = 0
+// Returns approximate root ×10000, starting from x0_fx
+fn cubic_newton(a_fx: int, b_fx: int, c_fx: int, d_fx: int, x0_fx: int): int {
+    let x: int = x0_fx;
+    let step: int = 0;
+    while (step < 20) {
+        // f(x) = ax³ + bx² + cx + d  (all ×10000)
+        let x2: int = x * x / 10000;
+        let x3: int = x2 * x / 10000;
+        let fx: int = a_fx * x3 / 10000 + b_fx * x2 / 10000 + c_fx * x / 10000 + d_fx;
+        // f'(x) = 3ax² + 2bx + c
+        let dfx: int = 3 * a_fx * x2 / 10000 + 2 * b_fx * x / 10000 + c_fx;
+        if (dfx == 0) { step = 20; }
+        if (dfx != 0) {
+            let dx: int = fx * 10000 / dfx;
+            x = x - dx;
+            if (dx < 0) { dx = 0 - dx; }
+            if (dx < 5) { step = 20; }  // converged
+        }
+        step = step + 1;
+    }
+    return x;
+}
+
+// ─── Numerical integration ────────────────────────────────────────────────────
+
+// trapezoid_step(fa, fb, h): one trapezoid integration step
+// fa, fb: function values ×10000, h: step width ×10000
+// Returns area ×10000
+fn trapezoid_step(fa: int, fb: int, h: int): int {
+    return (fa + fb) * h / 20000;  // (fa+fb)/2 * h
+}
+
+// simpson_step(fa, fm, fb, h): one Simpson's rule step
+// fa, fm, fb: function at left/mid/right, h: half-width
+// Returns area ×10000 (over 2h width)
+fn simpson_step(fa: int, fm: int, fb: int, h: int): int {
+    return (fa + 4 * fm + fb) * h / 30000;  // (fa+4fm+fb) * h/3, factor 2h total
+}
+
+// ─── Newton's method (general scalar) ────────────────────────────────────────
+
+// newton_refine(x_fx, fx, dfx): one Newton step
+// x_fx: current x ×10000, fx: f(x) ×10000, dfx: f'(x) ×10000
+// Returns new x ×10000
+fn newton_step(x_fx: int, fx: int, dfx: int): int {
+    if (dfx == 0) { return x_fx; }
+    return x_fx - fx * 10000 / dfx;
+}
+
+// ─── Arc trigonometry ─────────────────────────────────────────────────────────
+
+// asin_approx(x_fx): arcsin approximation, x_fx ×10000 in [-10000, 10000]
+// Returns degrees ×10000
+// Uses: arcsin(x) = arctan(x / √(1-x²))
+fn asin_approx(x_fx: int): int {
+    if (x_fx >= 10000) { return 900000; }
+    if (x_fx <= -10000) { return -900000; }
+    let x2: int = x_fx * x_fx / 10000;
+    let denom_sq: int = 10000 - x2;  // (1 - x²) ×10000
+    if (denom_sq <= 0) { return 900000; }
+    let denom: int = isqrt(denom_sq * 100) * 100;  // √(1-x²) ×10000
+    if (denom == 0) { return 900000; }
+    return atan2_fixed(x_fx, denom);
+}
+
+// acos_approx(x_fx): arccos approximation
+// Returns degrees ×10000
+fn acos_approx(x_fx: int): int {
+    return 900000 - asin_approx(x_fx);  // acos = 90° - asin
+}