redscript-mc 2.4.1 → 2.6.0

package/src/stdlib/advanced.mcrs

@@ -309,6 +309,53 @@ fn newton_sqrt(n: int) -> int {
     return x;
 }
 
+// ─── Category 3 (cont.): Higher-order Bezier curves ─────────────────────────
+
+// Quartic Bezier: 5-point curve using De Casteljau's algorithm.
+// t in [0, 1000].
+// bezier_quartic(0, 250, 500, 750, 1000, 0)    == 0    (t=0: start)
+// bezier_quartic(0, 250, 500, 750, 1000, 1000) == 1000 (t=1: end)
+// bezier_quartic(0, 250, 500, 750, 1000, 500)  == 500  (midpoint, uniform pts)
+fn bezier_quartic(p0: int, p1: int, p2: int, p3: int, p4: int, t: int) -> int {
+    let m0: int = lerp(p0, p1, t);
+    let m1: int = lerp(p1, p2, t);
+    let m2: int = lerp(p2, p3, t);
+    let m3: int = lerp(p3, p4, t);
+    let n0: int = lerp(m0, m1, t);
+    let n1: int = lerp(m1, m2, t);
+    let n2: int = lerp(m2, m3, t);
+    let o0: int = lerp(n0, n1, t);
+    let o1: int = lerp(n1, n2, t);
+    return lerp(o0, o1, t);
+}
+
+// bezier_n(pts, n, t): N-order Bezier curve via De Casteljau's algorithm.
+// pts: array of n control points (int[], will be modified in-place).
+// t in [0, 1000].
+// WARNING: modifies pts in-place. Call bezier_n_safe if you need to preserve pts.
+// bezier_n([0,333,667,1000], 4, 0)    == 0    (t=0: returns pts[0])
+// bezier_n([0,333,667,1000], 4, 1000) == 1000 (t=1: returns pts[n-1])
+fn bezier_n(pts: int[], n: int, t: int) -> int {
+    let r: int = 0;
+    while (r < n - 1) {
+        let i: int = 0;
+        while (i < n - 1 - r) {
+            pts[i] = lerp(pts[i], pts[i + 1], t);
+            i = i + 1;
+        }
+        r = r + 1;
+    }
+    return pts[0];
+}
+
+// bezier_n_safe(pts, work, n, t): N-order Bezier, non-destructive.
+// Copies pts into work (length >= n) then runs bezier_n on work.
+// pts is not modified.
+fn bezier_n_safe(pts: int[], work: int[], n: int, t: int) -> int {
+    bigint_copy(pts, work, n);
+    return bezier_n(work, n, t);
+}
+
 // Digital root: repeatedly sum digits until single digit.
 // digital_root(493) == 7  (4+9+3=16 → 1+6=7)
 // digital_root(9) == 9

package/src/stdlib/bigint.mcrs

@@ -1,124 +1,65 @@
 // bigint.mcrs — Multi-precision integer arithmetic for RedScript.
 //
-// Representation: "万进制" (base-10000) int array stored in NBT storage.
-//   [1, 2345, 6789] represents 1_0002345_6789 = 100,023,456,789
-//   Each element is 0-9999 (4 decimal digits).
-//   First element is the most significant (big-endian).
-//   Leading zeros in non-first elements must be preserved conceptually.
+// Representation: base-10000 (万进制) int array stored in NBT storage.
+//   arr[0] = most significant chunk (big-endian)
+//   Each element: 0-9999 (4 decimal digits)
+//   Example: [1, 2345, 6789] = 1_0002345_6789 = 100,023,456,789
 //
-// NBT path: storage rs:bigint <varname>
+// Functions for 96-bit (3-chunk) operations:
+//   bigint3_add, bigint3_sub, bigint3_mul1, bigint3_cmp, bigint3_div_by_small
 //
-// Operations use raw() to emit NBT commands. All operations are on stored values.
-// This module provides:
-//   1. Helper functions for single-chunk arithmetic (within int32)
-//   2. raw()-based macros for NBT-backed multi-chunk operations
-//   3. Conversion utilities
-//
-// NOTE: Full arbitrary-precision ops (like kaer's library) require
-// complex NBT recursion not yet expressible in RedScript.
-// This module provides a 96-bit (3 × 4-digit) max precision layer,
-// which covers values up to ~10^12 (1 trillion).
+// Functions for arbitrary-length arrays (requires array by-ref, RedScript ≥ 2.4.0):
+//   bigint_add(a, b, result, len) — add two n-chunk bigints
+//   bigint_cmp(a, b, len)        — compare two n-chunk bigints
+//   bigint_mul_small(a, n, result, len) — multiply n-chunk bigint by small int
+//   bigint_zero(arr, len)        — set array to zero
+//   bigint_copy(src, dst, len)   — copy bigint
 
 module library;
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
-// BIGINT_BASE: base for 万进制 representation
 fn bigint_base(): int { return 10000; }
 
-// ─── Single-precision helpers ────────────────────────────────────────────────
-// These work on individual 4-digit chunks.
-
-// chunk_hi(n): upper 4 digits of an 8-digit product (n must fit in int32)
-// chunk_hi(12345678) = 1234
-fn chunk_hi(n: int): int {
-    return n / 10000;
-}
-
-// chunk_lo(n): lower 4 digits
-// chunk_lo(12345678) = 5678
-fn chunk_lo(n: int): int {
-    return n % 10000;
-}
-
-// ─── 96-bit (3-chunk) addition ────────────────────────────────────────────────
-// Represents number as (hi, mid, lo) where value = hi*10^8 + mid*10^4 + lo
-
-// bigint3_add_lo(alo, blo): low chunk sum (carry handled by mid)
-fn bigint3_add_lo(alo: int, blo: int): int {
-    return (alo + blo) % 10000;
-}
-
-// bigint3_carry_lo(alo, blo): carry from low to mid chunk (0 or 1)
-fn bigint3_carry_lo(alo: int, blo: int): int {
-    return (alo + blo) / 10000;
-}
+// ─── Single-chunk helpers ────────────────────────────────────────────────────
 
-// bigint3_add_mid(amid, bmid, carry): mid chunk sum
-fn bigint3_add_mid(amid: int, bmid: int, carry: int): int {
-    return (amid + bmid + carry) % 10000;
-}
+fn chunk_hi(n: int): int { return n / 10000; }
+fn chunk_lo(n: int): int { return n % 10000; }
 
-fn bigint3_carry_mid(amid: int, bmid: int, carry: int): int {
-    return (amid + bmid + carry) / 10000;
-}
+// ─── 3-chunk (96-bit) arithmetic ─────────────────────────────────────────────
 
-fn bigint3_add_hi(ahi: int, bhi: int, carry: int): int {
-    return (ahi + bhi + carry) % 10000;
-}
-
-// ─── 96-bit subtraction (a >= b assumed) ─────────────────────────────────────
+fn bigint3_add_lo(alo: int, blo: int): int { return (alo + blo) % 10000; }
+fn bigint3_carry_lo(alo: int, blo: int): int { return (alo + blo) / 10000; }
+fn bigint3_add_mid(amid: int, bmid: int, carry: int): int { return (amid + bmid + carry) % 10000; }
+fn bigint3_carry_mid(amid: int, bmid: int, carry: int): int { return (amid + bmid + carry) / 10000; }
+fn bigint3_add_hi(ahi: int, bhi: int, carry: int): int { return (ahi + bhi + carry) % 10000; }
 
 fn bigint3_sub_lo(alo: int, blo: int): int {
     if (alo >= blo) { return alo - blo; }
     return alo + 10000 - blo;
 }
-
 fn bigint3_borrow_lo(alo: int, blo: int): int {
     if (alo >= blo) { return 0; }
     return 1;
 }
-
 fn bigint3_sub_mid(amid: int, bmid: int, borrow: int): int {
     let v: int = amid - bmid - borrow;
     if (v < 0) { v = v + 10000; }
     return v;
 }
-
 fn bigint3_borrow_mid(amid: int, bmid: int, borrow: int): int {
     if (amid - borrow >= bmid) { return 0; }
     return 1;
 }
-
 fn bigint3_sub_hi(ahi: int, bhi: int, borrow: int): int {
     return ahi - bhi - borrow;
 }
 
-// ─── Multiplication (int × int → 96-bit) ─────────────────────────────────────
-
-// bigint3_mul_lo(a, b): low chunk of a × b (a, b each up to 10^12 / 10^8)
-// For a, b ≤ 9999 (one chunk each):
-fn bigint3_mul1_lo(a: int, b: int): int {
-    return (a * b) % 10000;
-}
-
-fn bigint3_mul1_hi(a: int, b: int): int {
-    return (a * b) / 10000;
-}
-
-// int32 × int32 → 96-bit: a*b where both ≤ 9999
-// Result fits in 8 decimal digits (max 9999*9999 = 99,980,001)
-fn bigint3_mul1_mid(a: int, b: int): int {
-    // No mid chunk needed for 1×1; return 0
-    return 0;
-}
-
-// ─── Comparison ──────────────────────────────────────────────────────────────
+fn bigint3_mul1_lo(a: int, b: int): int { return (a * b) % 10000; }
+fn bigint3_mul1_hi(a: int, b: int): int { return (a * b) / 10000; }
 
-// bigint3_cmp(ahi, amid, alo, bhi, bmid, blo):
-// Returns 1 if a > b, -1 if a < b, 0 if equal
-fn bigint3_cmp(ahi: int, amid: int, alo: int,
-               bhi: int, bmid: int, blo: int): int {
+// Compare: returns 1 if a>b, -1 if a<b, 0 if equal
+fn bigint3_cmp(ahi: int, amid: int, alo: int, bhi: int, bmid: int, blo: int): int {
     if (ahi > bhi) { return 1; }
     if (ahi < bhi) { return -1; }
     if (amid > bmid) { return 1; }
@@ -128,41 +69,252 @@ fn bigint3_cmp(ahi: int, amid: int, alo: int,
     return 0;
 }
 
-// ─── Conversion helpers ───────────────────────────────────────────────────────
-
-// int32_to_bigint3_lo(n): low chunk of n (4 digits)
+// int32 → 3 chunks
 fn int32_to_bigint3_lo(n: int): int {
     if (n < 0) { n = 0 - n; }
     return n % 10000;
 }
-
-// int32_to_bigint3_mid(n): mid chunk (digits 5-8)
 fn int32_to_bigint3_mid(n: int): int {
     if (n < 0) { n = 0 - n; }
     return (n / 10000) % 10000;
 }
-
-// int32_to_bigint3_hi(n): high chunk (digits 9+, usually 0 for int32)
 fn int32_to_bigint3_hi(n: int): int {
     if (n < 0) { n = 0 - n; }
     return n / 100000000;
 }
-
-// bigint3_to_int32(hi, mid, lo): convert back to int32 (truncates if > 2^31)
 fn bigint3_to_int32(hi: int, mid: int, lo: int): int {
     return hi * 100000000 + mid * 10000 + lo;
 }
 
-// ─── Division (96-bit / 16-bit) ──────────────────────────────────────────────
-// Divide 3-chunk bigint by a single small integer (≤ 9999).
-// Algorithm: long division, chunk by chunk.
-
-// bigint3_div_chunk(chunk, rem, divisor): quotient of (rem*10000 + chunk) / divisor
+// Division helpers (array ÷ small int ≤ 9999)
 fn bigint3_div_chunk(chunk: int, rem: int, divisor: int): int {
     return (rem * 10000 + chunk) / divisor;
 }
-
-// bigint3_rem_chunk(chunk, rem, divisor): new remainder after dividing (rem*10000+chunk)
 fn bigint3_rem_chunk(chunk: int, rem: int, divisor: int): int {
     return (rem * 10000 + chunk) % divisor;
 }
+
+// ─── Arbitrary-length operations (array by-ref, RedScript ≥ 2.4.0) ──────────
+
+// bigint_zero(arr, len): set all chunks to 0
+fn bigint_zero(arr: int[], len: int) {
+    let i: int = 0;
+    while (i < len) { arr[i] = 0; i = i + 1; }
+}
+
+// bigint_copy(src, dst, len): copy src into dst
+fn bigint_copy(src: int[], dst: int[], len: int) {
+    let i: int = 0;
+    while (i < len) { dst[i] = src[i]; i = i + 1; }
+}
+
+// bigint_cmp(a, b, len): compare a and b, returns 1 if a>b, -1 if a<b, 0 if equal
+// Most significant chunk is at index 0 (big-endian)
+fn bigint_cmp(a: int[], b: int[], len: int): int {
+    let i: int = 0;
+    while (i < len) {
+        if (a[i] > b[i]) { return 1; }
+        if (a[i] < b[i]) { return -1; }
+        i = i + 1;
+    }
+    return 0;
+}
+
+// bigint_add(a, b, result, len): result = a + b (in-place into result array)
+// Returns carry out (0 or 1) — caller should handle overflow
+fn bigint_add(a: int[], b: int[], result: int[], len: int): int {
+    let carry: int = 0;
+    let i: int = len - 1;  // start from least significant (rightmost)
+    while (i >= 0) {
+        let sum: int = a[i] + b[i] + carry;
+        result[i] = sum % 10000;
+        carry = sum / 10000;
+        i = i - 1;
+    }
+    return carry;
+}
+
+// bigint_sub(a, b, result, len): result = a - b (assumes a >= b)
+fn bigint_sub(a: int[], b: int[], result: int[], len: int) {
+    let borrow: int = 0;
+    let i: int = len - 1;
+    while (i >= 0) {
+        let diff: int = a[i] - b[i] - borrow;
+        if (diff < 0) {
+            diff = diff + 10000;
+            borrow = 1;
+        }
+        if (diff >= 0) { borrow = 0; }
+        result[i] = diff;
+        i = i - 1;
+    }
+}
+
+// bigint_mul_small(a, n, result, len): result = a × n, where n ≤ 9999
+fn bigint_mul_small(a: int[], n: int, result: int[], len: int) {
+    let carry: int = 0;
+    let i: int = len - 1;
+    while (i >= 0) {
+        let prod: int = a[i] * n + carry;
+        result[i] = prod % 10000;
+        carry = prod / 10000;
+        i = i - 1;
+    }
+}
+
+// bigint_shift_left(arr, len): multiply by 10000 (shift left one chunk)
+// Loses most significant chunk if non-zero
+fn bigint_shift_left(arr: int[], len: int) {
+    let i: int = 0;
+    while (i < len - 1) {
+        arr[i] = arr[i + 1];
+        i = i + 1;
+    }
+    arr[len - 1] = 0;
+}
+
+// bigint_is_zero(arr, len): returns 1 if all chunks are 0
+fn bigint_is_zero(arr: int[], len: int): int {
+    let i: int = 0;
+    while (i < len) {
+        if (arr[i] != 0) { return 0; }
+        i = i + 1;
+    }
+    return 1;
+}
+
+// bigint_leading_zeros(arr, len): count leading zero chunks
+fn bigint_leading_zeros(arr: int[], len: int): int {
+    let count: int = 0;
+    let i: int = 0;
+    while (i < len) {
+        if (arr[i] != 0) { return count; }
+        count = count + 1;
+        i = i + 1;
+    }
+    return count;
+}
+
+// ─── Division: bigint ÷ small integer ────────────────────────────────────────
+// Divides n-chunk bigint by a small integer (1 ≤ divisor ≤ 9999)
+// Algorithm: long division chunk by chunk (most-significant first)
+// result[i] = (rem*10000 + a[i]) / divisor
+// rem = (rem*10000 + a[i]) % divisor
+
+// bigint_div_small(a, divisor, result, len): result = a / divisor
+// Returns remainder.
+fn bigint_div_small(a: int[], divisor: int, result: int[], len: int): int {
+    let rem: int = 0;
+    let i: int = 0;
+    while (i < len) {
+        let cur: int = rem * 10000 + a[i];
+        result[i] = cur / divisor;
+        rem = cur % divisor;
+        i = i + 1;
+    }
+    return rem;
+}
+
+// bigint_mod_small(a, divisor, len): return a % divisor (0..divisor-1)
+fn bigint_mod_small(a: int[], divisor: int, len: int): int {
+    let rem: int = 0;
+    let i: int = 0;
+    while (i < len) {
+        rem = (rem * 10000 + a[i]) % divisor;
+        i = i + 1;
+    }
+    return rem;
+}
+
+// bigint_print_chunks(a, len): get the value of chunk at index i
+// Helper to read specific chunk for display purposes
+fn bigint_chunk(a: int[], i: int): int {
+    return a[i];
+}
+
+// ─── Full bigint × bigint multiplication ─────────────────────────────────────
+//
+// bigint_mul(a, b, result, la, lb):
+//   Multiply two bigints: result = a * b
+//   a has la chunks, b has lb chunks, result must have la+lb chunks (pre-zeroed)
+//   Uses schoolbook O(n²) algorithm.
+//   Maximum safe chunk product: 9999 * 9999 = 99,980,001 < INT32_MAX ✓
+//   After accumulation each chunk can exceed 10000 — carry_pass normalizes.
+//
+// Usage:
+//   import "stdlib/bigint"
+//   let a: int[] = [0, 0, 1234, 5678];   // 4-chunk
+//   let b: int[] = [0, 0, 9999];          // 3-chunk
+//   let result: int[] = [0, 0, 0, 0, 0, 0, 0]; // la+lb = 7 chunks, pre-zeroed
+//   bigint_mul(a, b, result, 4, 3);
+//
+fn bigint_mul(a: int[], b: int[], result: int[], la: int, lb: int) {
+    // Phase 1: accumulate partial products (big-endian, MSB at index 0)
+    // a[i] is the (la-1-i)-th digit from LSB, similarly for b[j]
+    // result has la+lb chunks; result[la+lb-1] is the LSB chunk
+    let i: int = 0;
+    while (i < la) {
+        let j: int = 0;
+        while (j < lb) {
+            // Position in result: MSB-aligned
+            // a[i] * b[j] contributes to result[i + j + 1] (1-indexed from MSB, 0 = overflow slot)
+            let pos: int = i + j + 1;
+            result[pos] = result[pos] + a[i] * b[j];
+            j = j + 1;
+        }
+        i = i + 1;
+    }
+
+    // Phase 2: carry propagation from LSB to MSB
+    let total: int = la + lb;
+    let k: int = total - 1;
+    while (k > 0) {
+        let carry: int = result[k] / 10000;
+        result[k] = result[k] % 10000;
+        result[k - 1] = result[k - 1] + carry;
+        k = k - 1;
+    }
+}
+
+// bigint_mul_result_len(la, lb): required result array length for bigint_mul
+fn bigint_mul_result_len(la: int, lb: int): int {
+    return la + lb;
+}
+
+// bigint_sq(a, result, len):
+//   Square a bigint: result = a * a
+//   result must have len*2 chunks (pre-zeroed).
+//   Optimized: only compute upper triangle and double (avoids redundant multiplications).
+//
+fn bigint_sq(a: int[], result: int[], len: int) {
+    // Diagonal terms (i == j)
+    let i: int = 0;
+    while (i < len) {
+        let pos: int = i + i + 1;
+        result[pos] = result[pos] + a[i] * a[i];
+        i = i + 1;
+    }
+
+    // Off-diagonal terms (i < j), doubled
+    i = 0;
+    while (i < len) {
+        let j: int = i + 1;
+        while (j < len) {
+            let pos: int = i + j + 1;
+            // a[i]*a[j] * 2 — safe: 9999*9999*2 = 199,960,002 < INT32_MAX
+            result[pos] = result[pos] + a[i] * a[j] * 2;
+            j = j + 1;
+        }
+        i = i + 1;
+    }
+
+    // Carry propagation
+    let total: int = len * 2;
+    let k: int = total - 1;
+    while (k > 0) {
+        let carry: int = result[k] / 10000;
+        result[k] = result[k] % 10000;
+        result[k - 1] = result[k - 1] + carry;
+        k = k - 1;
+    }
+}

package/src/stdlib/calculus.mcrs

@@ -0,0 +1,150 @@
+// calculus.mcrs — Numerical calculus for RedScript datapacks.
+//
+// All values fixed-point ×10000 unless noted.
+//
+// Methods:
+//   - Numerical differentiation (finite difference)
+//   - Numerical integration (trapezoid, Simpson's rule over fixed arrays)
+//   - Riemann sum helpers
+//   - Curve length approximation
+
+module library;
+
+// ─── Differentiation ─────────────────────────────────────────────────────────
+
+// deriv_forward(f1, f0, h_fx): forward difference derivative
+// f1 = f(x+h), f0 = f(x), h_fx = step size ×10000
+// Returns df/dx ×10000
+fn deriv_forward(f1: int, f0: int, h_fx: int): int {
+    if (h_fx == 0) { return 0; }
+    return (f1 - f0) * 10000 / h_fx;
+}
+
+// deriv_central(f_plus, f_minus, h_fx): central difference (more accurate)
+// f_plus = f(x+h), f_minus = f(x-h)
+// Returns df/dx ×10000
+fn deriv_central(f_plus: int, f_minus: int, h_fx: int): int {
+    if (h_fx == 0) { return 0; }
+    return (f_plus - f_minus) * 10000 / (2 * h_fx);
+}
+
+// second_deriv(f_plus, f0, f_minus, h_fx): second derivative
+// Returns d²f/dx² ×10000
+fn second_deriv(f_plus: int, f0: int, f_minus: int, h_fx: int): int {
+    if (h_fx == 0) { return 0; }
+    return (f_plus - 2 * f0 + f_minus) * 100000000 / h_fx / h_fx;
+}
+
+// ─── Integration over arrays ──────────────────────────────────────────────────
+//
+// For integration, the user provides an array of function values at equally
+// spaced points, and the step size.
+
+// integrate_trapezoid(vals, n, h_fx): trapezoidal rule integration
+// vals: array of n function values ×10000, equally spaced by h_fx
+// h_fx: step width ×10000
+// Returns integral ×10000 (area under curve)
+fn integrate_trapezoid(vals: int[], n: int, h_fx: int): int {
+    if (n < 2) { return 0; }
+    // Sum = (vals[0] + vals[n-1]) / 2 + vals[1] + vals[2] + ... + vals[n-2]
+    let sum: int = vals[0] / 2 + vals[n - 1] / 2;
+    let i: int = 1;
+    while (i < n - 1) {
+        sum = sum + vals[i];
+        i = i + 1;
+    }
+    return sum * h_fx / 10000;
+}
+
+// integrate_simpson(vals, n, h_fx): Simpson's 1/3 rule (n must be odd, n ≥ 3)
+// More accurate than trapezoid for smooth functions
+fn integrate_simpson(vals: int[], n: int, h_fx: int): int {
+    if (n < 3) { return integrate_trapezoid(vals, n, h_fx); }
+    // Ensure n is odd by using n-1 if even
+    let m: int = n;
+    if (m % 2 == 0) { m = m - 1; }
+    // Coefficients: 1, 4, 2, 4, 2, ..., 4, 1 (times h/3)
+    let sum: int = vals[0] + vals[m - 1];
+    let i: int = 1;
+    while (i < m - 1) {
+        if (i % 2 == 1) {
+            sum = sum + 4 * vals[i];
+        }
+        if (i % 2 == 0) {
+            sum = sum + 2 * vals[i];
+        }
+        i = i + 1;
+    }
+    return sum * h_fx / 30000;  // × h/3 = h_fx / (3 × 10000)
+}
+
+// ─── Riemann sums ─────────────────────────────────────────────────────────────
+
+// riemann_left(vals, n, h_fx): left Riemann sum
+fn riemann_left(vals: int[], n: int, h_fx: int): int {
+    let sum: int = 0;
+    let i: int = 0;
+    while (i < n - 1) { sum = sum + vals[i]; i = i + 1; }
+    return sum * h_fx / 10000;
+}
+
+// riemann_right(vals, n, h_fx): right Riemann sum
+fn riemann_right(vals: int[], n: int, h_fx: int): int {
+    let sum: int = 0;
+    let i: int = 1;
+    while (i < n) { sum = sum + vals[i]; i = i + 1; }
+    return sum * h_fx / 10000;
+}
+
+// riemann_mid(vals, n, h_fx): midpoint Riemann sum
+// vals: midpoint values (n-1 midpoints for n-1 intervals)
+fn riemann_mid(vals: int[], n: int, h_fx: int): int {
+    let sum: int = 0;
+    let i: int = 0;
+    while (i < n) { sum = sum + vals[i]; i = i + 1; }
+    return sum * h_fx / 10000;
+}
+
+// ─── Curve length ────────────────────────────────────────────────────────────
+
+// curve_length_2d(xs, ys, n): approximate arc length of a 2D polyline
+// xs, ys: x and y coordinates ×10000 of n points
+fn curve_length_2d(xs: int[], ys: int[], n: int): int {
+    let total: int = 0;
+    let i: int = 0;
+    while (i < n - 1) {
+        let dx: int = xs[i + 1] - xs[i];
+        let dy: int = ys[i + 1] - ys[i];
+        let seg_sq: int = dx * dx / 10000 + dy * dy / 10000;
+        total = total + isqrt(seg_sq * 100) * 100;
+        i = i + 1;
+    }
+    return total;
+}
+
+// ─── Running statistics ───────────────────────────────────────────────────────
+
+// running_mean(prev_mean, new_val, n): Welford's online mean update
+// prev_mean ×10000, new_val ×10000, n: count after adding new_val (n ≥ 1)
+fn running_mean(prev_mean: int, new_val: int, n: int): int {
+    if (n <= 1) { return new_val; }
+    return prev_mean + (new_val - prev_mean) * 10000 / (n * 10000);
+}
+
+// running_m2(prev_m2, prev_mean, new_mean, new_val): Welford's M2 update
+// Used to compute variance: variance = m2 / (n-1)
+fn running_m2(prev_m2: int, prev_mean: int, new_mean: int, new_val: int): int {
+    return prev_m2 + (new_val - prev_mean) * (new_val - new_mean) / 10000;
+}
+
+// variance_from_m2(m2, n): get variance from Welford's M2, n = number of samples
+fn variance_from_m2(m2: int, n: int): int {
+    if (n <= 1) { return 0; }
+    return m2 / (n - 1);
+}
+
+// std_dev_approx(variance_fx): approximate std dev = √variance
+fn std_dev_approx(variance_fx: int): int {
+    if (variance_fx <= 0) { return 0; }
+    return isqrt(variance_fx * 100) * 100 / 10000;
+}