redscript-mc 2.6.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/matrix.mcrs

@@ -106,3 +106,116 @@ fn lerp_angle(a_fx: int, b_fx: int, t: int): int {
     while (diff < -1800000) { diff = diff + 3600000; }
     return a_fx + diff * t / 10000;
 }
+
+// ─── 3×3 Matrix multiplication ───────────────────────────────────────────────
+// All matrix values are ×10000 (fixed-point).
+// mat3_mul(a, b): C = A × B  where each element = sum of row×col / 10000
+//
+// Matrix layout (row-major, 9 components):
+//   a00 a01 a02
+//   a10 a11 a12
+//   a20 a21 a22
+
+// mat3_mul: compute one element C[row][col] of a 3×3 matrix product
+// row ∈ {0,1,2}, col ∈ {0,1,2}
+// Pass all 18 components of A and B individually.
+// Returns C[row][col] ×10000
+
+fn mat3_mul_elem(
+    a00: int, a01: int, a02: int,
+    a10: int, a11: int, a12: int,
+    a20: int, a21: int, a22: int,
+    b00: int, b01: int, b02: int,
+    b10: int, b11: int, b12: int,
+    b20: int, b21: int, b22: int,
+    row: int, col: int
+): int {
+    let r0: int = 0;
+    let r1: int = 0;
+    let r2: int = 0;
+    // Select row of A
+    let ar0: int = 0; let ar1: int = 0; let ar2: int = 0;
+    if (row == 0) { ar0 = a00; ar1 = a01; ar2 = a02; }
+    if (row == 1) { ar0 = a10; ar1 = a11; ar2 = a12; }
+    if (row == 2) { ar0 = a20; ar1 = a21; ar2 = a22; }
+    // Select column of B
+    let bc0: int = 0; let bc1: int = 0; let bc2: int = 0;
+    if (col == 0) { bc0 = b00; bc1 = b10; bc2 = b20; }
+    if (col == 1) { bc0 = b01; bc1 = b11; bc2 = b21; }
+    if (col == 2) { bc0 = b02; bc1 = b12; bc2 = b22; }
+    // Dot product: divide each term by 10000 to keep ×10000 scale
+    r0 = ar0 * bc0 / 10000;
+    r1 = ar1 * bc1 / 10000;
+    r2 = ar2 * bc2 / 10000;
+    return r0 + r1 + r2;
+}
+
+// mat3_mul_vec3: multiply 3×3 matrix by a column vector (vx, vy, vz) ×10000
+// Returns one component (0=x, 1=y, 2=z) of the result vector ×10000
+fn mat3_mul_vec3_elem(
+    a00: int, a01: int, a02: int,
+    a10: int, a11: int, a12: int,
+    a20: int, a21: int, a22: int,
+    vx: int, vy: int, vz: int,
+    comp: int
+): int {
+    let row0: int = a00 * vx / 10000 + a01 * vy / 10000 + a02 * vz / 10000;
+    let row1: int = a10 * vx / 10000 + a11 * vy / 10000 + a12 * vz / 10000;
+    let row2: int = a20 * vx / 10000 + a21 * vy / 10000 + a22 * vz / 10000;
+    if (comp == 0) { return row0; }
+    if (comp == 1) { return row1; }
+    return row2;
+}
+
+// ─── 4×4 Matrix multiplication ───────────────────────────────────────────────
+// MC Display Entity transformation uses 4×4 matrices (TRS decomposition).
+// All values ×10000.
+//
+// mat4_mul_elem: compute one element C[row][col] of a 4×4 matrix product.
+// Row-major, 16+16=32 components. Returns C[row][col] ×10000.
+
+fn mat4_mul_elem(
+    a00: int, a01: int, a02: int, a03: int,
+    a10: int, a11: int, a12: int, a13: int,
+    a20: int, a21: int, a22: int, a23: int,
+    a30: int, a31: int, a32: int, a33: int,
+    b00: int, b01: int, b02: int, b03: int,
+    b10: int, b11: int, b12: int, b13: int,
+    b20: int, b21: int, b22: int, b23: int,
+    b30: int, b31: int, b32: int, b33: int,
+    row: int, col: int
+): int {
+    // Select row of A
+    let ar0: int = 0; let ar1: int = 0; let ar2: int = 0; let ar3: int = 0;
+    if (row == 0) { ar0 = a00; ar1 = a01; ar2 = a02; ar3 = a03; }
+    if (row == 1) { ar0 = a10; ar1 = a11; ar2 = a12; ar3 = a13; }
+    if (row == 2) { ar0 = a20; ar1 = a21; ar2 = a22; ar3 = a23; }
+    if (row == 3) { ar0 = a30; ar1 = a31; ar2 = a32; ar3 = a33; }
+    // Select column of B
+    let bc0: int = 0; let bc1: int = 0; let bc2: int = 0; let bc3: int = 0;
+    if (col == 0) { bc0 = b00; bc1 = b10; bc2 = b20; bc3 = b30; }
+    if (col == 1) { bc0 = b01; bc1 = b11; bc2 = b21; bc3 = b31; }
+    if (col == 2) { bc0 = b02; bc1 = b12; bc2 = b22; bc3 = b32; }
+    if (col == 3) { bc0 = b03; bc1 = b13; bc2 = b23; bc3 = b33; }
+    return ar0 * bc0 / 10000 + ar1 * bc1 / 10000 + ar2 * bc2 / 10000 + ar3 * bc3 / 10000;
+}
+
+// mat4_mul_vec4_elem: multiply 4×4 matrix by homogeneous vector (vx,vy,vz,vw) ×10000
+// comp: 0=x, 1=y, 2=z, 3=w
+fn mat4_mul_vec4_elem(
+    a00: int, a01: int, a02: int, a03: int,
+    a10: int, a11: int, a12: int, a13: int,
+    a20: int, a21: int, a22: int, a23: int,
+    a30: int, a31: int, a32: int, a33: int,
+    vx: int, vy: int, vz: int, vw: int,
+    comp: int
+): int {
+    let row0: int = a00*vx/10000 + a01*vy/10000 + a02*vz/10000 + a03*vw/10000;
+    let row1: int = a10*vx/10000 + a11*vy/10000 + a12*vz/10000 + a13*vw/10000;
+    let row2: int = a20*vx/10000 + a21*vy/10000 + a22*vz/10000 + a23*vw/10000;
+    let row3: int = a30*vx/10000 + a31*vy/10000 + a32*vz/10000 + a33*vw/10000;
+    if (comp == 0) { return row0; }
+    if (comp == 1) { return row1; }
+    if (comp == 2) { return row2; }
+    return row3;
+}

package/src/stdlib/ode.mcrs

@@ -0,0 +1,168 @@
+// ode.mcrs — Runge-Kutta 4th order ODE helpers for RedScript datapacks.
+//
+// Fixed-point convention in this module: scale = 10000.
+//   1.0  -> 10000
+//   0.1  -> 1000
+//
+// Usage example (exponential decay):
+//   // dy/dt = -k*y, with k = 1.0, y0 = 1.0, h = 0.1, 10 steps
+//   ode_run(ODE_SYSTEM_DECAY, 0, 10000, 1000, 10, 10000)
+//   let y1: int = ode_get_y()
+//   // Exact solution: y(t) = y0 * e^(-k*t)
+//   // At t = 1.0: y ≈ 3679 (= 0.3679 × 10000)
+//
+// State layout in storage-backed int[] (8 slots):
+//   [system_id, t_fx, y_fx, y2_fx, param_k, param_extra, step_count, reserved]
+//
+// Built-in systems:
+//   1 = exponential decay   (dy/dt = -k*y)
+//   2 = exponential growth  (dy/dt =  k*y)
+//   3 = harmonic oscillator (y' = y2, y2' = -k*y - extra*y2)
+
+module library
+
+fn ode_mul_fx(a_fx: int, b_fx: int): int {
+    return a_fx * b_fx / 10000
+}
+
+fn ode_weighted_increment(h_fx: int, deriv_sum_fx: int): int {
+    return h_fx * deriv_sum_fx / 60000
+}
+
+fn _ode_set_slot0(v: int) { raw("execute store result storage rs:ode state[0] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot1(v: int) { raw("execute store result storage rs:ode state[1] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot2(v: int) { raw("execute store result storage rs:ode state[2] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot3(v: int) { raw("execute store result storage rs:ode state[3] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot4(v: int) { raw("execute store result storage rs:ode state[4] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot5(v: int) { raw("execute store result storage rs:ode state[5] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot6(v: int) { raw("execute store result storage rs:ode state[6] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot7(v: int) { raw("execute store result storage rs:ode state[7] int 1 run scoreboard players get $p0 __OBJ__") }
+
+fn _ode_get_slot0(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[0]"); raw("return 1"); return 0 }
+fn _ode_get_slot1(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[1]"); raw("return 1"); return 0 }
+fn _ode_get_slot2(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[2]"); raw("return 1"); return 0 }
+fn _ode_get_slot3(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[3]"); raw("return 1"); return 0 }
+fn _ode_get_slot4(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[4]"); raw("return 1"); return 0 }
+fn _ode_get_slot5(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[5]"); raw("return 1"); return 0 }
+fn _ode_get_slot6(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[6]"); raw("return 1"); return 0 }
+fn _ode_get_slot7(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[7]"); raw("return 1"); return 0 }
+
+fn ode_reset(system_id: int, t_fx: int, y_fx: int, y2_fx: int, k_fx: int, extra_fx: int) {
+    raw("data modify storage rs:ode state set value [0,0,0,0,0,0,0,0]")
+    _ode_set_slot0(system_id)
+    _ode_set_slot1(t_fx)
+    _ode_set_slot2(y_fx)
+    _ode_set_slot3(y2_fx)
+    _ode_set_slot4(k_fx)
+    _ode_set_slot5(extra_fx)
+    _ode_set_slot6(0)
+    _ode_set_slot7(0)
+}
+
+fn ode_get_system(): int { return _ode_get_slot0() }
+fn ode_get_t(): int { return _ode_get_slot1() }
+fn ode_get_y(): int { return _ode_get_slot2() }
+fn ode_get_y2(): int { return _ode_get_slot3() }
+fn ode_get_k(): int { return _ode_get_slot4() }
+fn ode_get_extra(): int { return _ode_get_slot5() }
+fn ode_get_steps(): int { return _ode_get_slot6() }
+
+// Scalar-system dispatcher helper matching the callback-free pattern.
+// Uses the module state parameter k from slot 4.
+fn ode_k1(system_id: int, t_fx: int, y_fx: int): int {
+    let k_fx: int = ode_get_k()
+    if (system_id == 1) {
+        return 0 - ode_mul_fx(k_fx, y_fx)
+    }
+    if (system_id == 2) {
+        return ode_mul_fx(k_fx, y_fx)
+    }
+    return 0
+}
+
+fn ode_eval_y(system_id: int, t_fx: int, y_fx: int, y2_fx: int, k_fx: int, extra_fx: int): int {
+    if (system_id == 1) {
+        return 0 - ode_mul_fx(k_fx, y_fx)
+    }
+    if (system_id == 2) {
+        return ode_mul_fx(k_fx, y_fx)
+    }
+    if (system_id == 3) {
+        return y2_fx
+    }
+    return 0
+}
+
+fn ode_eval_y2(system_id: int, t_fx: int, y_fx: int, y2_fx: int, k_fx: int, extra_fx: int): int {
+    if (system_id == 3) {
+        return 0 - ode_mul_fx(k_fx, y_fx) - ode_mul_fx(extra_fx, y2_fx)
+    }
+    return 0
+}
+
+fn ode_step(h_fx: int) {
+    let system_id: int = ode_get_system()
+    let t_fx: int = ode_get_t()
+    let y_fx: int = ode_get_y()
+    let y2_fx: int = ode_get_y2()
+    let k_fx: int = ode_get_k()
+    let extra_fx: int = ode_get_extra()
+    let step_count: int = ode_get_steps()
+
+    let half_h_fx: int = h_fx / 2
+
+    if (system_id == 3) {
+        let k1_y: int = ode_eval_y(system_id, t_fx, y_fx, y2_fx, k_fx, extra_fx)
+        let k1_y2: int = ode_eval_y2(system_id, t_fx, y_fx, y2_fx, k_fx, extra_fx)
+
+        let t2_fx: int = t_fx + half_h_fx
+        let y_k2_fx: int = y_fx + half_h_fx * k1_y / 10000
+        let y2_k2_fx: int = y2_fx + half_h_fx * k1_y2 / 10000
+        let k2_y: int = ode_eval_y(system_id, t2_fx, y_k2_fx, y2_k2_fx, k_fx, extra_fx)
+        let k2_y2: int = ode_eval_y2(system_id, t2_fx, y_k2_fx, y2_k2_fx, k_fx, extra_fx)
+
+        let y_k3_fx: int = y_fx + half_h_fx * k2_y / 10000
+        let y2_k3_fx: int = y2_fx + half_h_fx * k2_y2 / 10000
+        let k3_y: int = ode_eval_y(system_id, t2_fx, y_k3_fx, y2_k3_fx, k_fx, extra_fx)
+        let k3_y2: int = ode_eval_y2(system_id, t2_fx, y_k3_fx, y2_k3_fx, k_fx, extra_fx)
+
+        let t4_fx: int = t_fx + h_fx
+        let y_k4_fx: int = y_fx + h_fx * k3_y / 10000
+        let y2_k4_fx: int = y2_fx + h_fx * k3_y2 / 10000
+        let k4_y: int = ode_eval_y(system_id, t4_fx, y_k4_fx, y2_k4_fx, k_fx, extra_fx)
+        let k4_y2: int = ode_eval_y2(system_id, t4_fx, y_k4_fx, y2_k4_fx, k_fx, extra_fx)
+
+        _ode_set_slot1(t_fx + h_fx)
+        _ode_set_slot2(y_fx + ode_weighted_increment(h_fx, k1_y + 2 * k2_y + 2 * k3_y + k4_y))
+        _ode_set_slot3(y2_fx + ode_weighted_increment(h_fx, k1_y2 + 2 * k2_y2 + 2 * k3_y2 + k4_y2))
+        _ode_set_slot6(step_count + 1)
+        return
+    }
+
+    let k1: int = ode_eval_y(system_id, t_fx, y_fx, y2_fx, k_fx, extra_fx)
+    let k2: int = ode_eval_y(system_id, t_fx + half_h_fx, y_fx + half_h_fx * k1 / 10000, y2_fx, k_fx, extra_fx)
+    let k3: int = ode_eval_y(system_id, t_fx + half_h_fx, y_fx + half_h_fx * k2 / 10000, y2_fx, k_fx, extra_fx)
+    let k4: int = ode_eval_y(system_id, t_fx + h_fx, y_fx + h_fx * k3 / 10000, y2_fx, k_fx, extra_fx)
+
+    _ode_set_slot1(t_fx + h_fx)
+    _ode_set_slot2(y_fx + ode_weighted_increment(h_fx, k1 + 2 * k2 + 2 * k3 + k4))
+    _ode_set_slot6(step_count + 1)
+}
+
+fn ode_run(system_id: int, t0_fx: int, y0_fx: int, h_fx: int, steps: int, k_fx: int) {
+    ode_reset(system_id, t0_fx, y0_fx, 0, k_fx, 0)
+    let i: int = 0
+    while (i < steps) {
+        ode_step(h_fx)
+        i = i + 1
+    }
+}
+
+fn ode_run2(system_id: int, t0_fx: int, y0_fx: int, y20_fx: int, h_fx: int, steps: int, k_fx: int, extra_fx: int) {
+    ode_reset(system_id, t0_fx, y0_fx, y20_fx, k_fx, extra_fx)
+    let i: int = 0
+    while (i < steps) {
+        ode_step(h_fx)
+        i = i + 1
+    }
+}