@series-inc/rundot-syncplay 5.26.0-beta.2 → 5.26.0-beta.3

package/core/native/fixed_math.cpp

@@ -0,0 +1,741 @@
+#include "fixed_math.hpp"
+
+#include <cmath>
+#include <limits>
+
+namespace rundot::fixedmath {
+namespace {
+
+// ECMAScript Math.round, which is NOT std::round: it breaks halves toward +inf
+// (Math.round(-2.5) === -2) where std::round breaks them away from zero (-3).
+// toFixed is the only entry point where a real argument reaches this, and it is
+// exactly where a std::round port would silently diverge.
+double jsRound(double x) {
+  if (std::isnan(x) || std::isinf(x) || x == 0.0) return x;
+  if (x > 0.0 && x < 0.5) return 0.0;
+  if (x < 0.0 && x >= -0.5) return -0.0;
+  // At and above 2^52 the spacing is >= 1, so every double is already an
+  // integer and Math.round is identity. floor(x + 0.5) is NOT: for an odd x the
+  // sum ties and rounds to even, yielding x + 1.
+  if (std::fabs(x) >= 4503599627370496.0) return x;
+  return std::floor(x + 0.5);
+}
+
+// Number.isInteger: finite and integral. Non-integers make the reference throw.
+bool isFixed(double v) { return std::isfinite(v) && std::floor(v) == v; }
+
+bool isSafeInteger(double v) { return isFixed(v) && std::fabs(v) <= 9007199254740991.0; }
+
+// NOT std::fmin/std::fmax: those IGNORE a NaN operand and return the other one,
+// where Math.min/Math.max propagate it. They also disagree on signed zero, which
+// Math.min/Math.max order (-0 < +0). clamp is the one operation with no integer
+// assertion, so a real or NaN argument reaches these from creator code.
+double jsMax(double a, double b) {
+  if (std::isnan(a) || std::isnan(b)) return std::numeric_limits<double>::quiet_NaN();
+  if (a == 0.0 && b == 0.0) return (std::signbit(a) && std::signbit(b)) ? -0.0 : 0.0;
+  return a > b ? a : b;
+}
+
+double jsMin(double a, double b) {
+  if (std::isnan(a) || std::isnan(b)) return std::numeric_limits<double>::quiet_NaN();
+  if (a == 0.0 && b == 0.0) return (std::signbit(a) || std::signbit(b)) ? -0.0 : 0.0;
+  return a < b ? a : b;
+}
+
+double saturate(double v, double lo, double hi) {
+  return jsMin(hi, jsMax(lo, v));
+}
+
+// -0 is tagged by the canonical layer, so the reference keeps it out of state.
+double normalizeZero(double v) { return (v == 0.0 && std::signbit(v)) ? 0.0 : v; }
+
+double mulFixed(const Config& c, double a, double b) {
+  return std::trunc((a * b) / c.fixedScale);
+}
+
+double sinQuarter(const Config& c, double xTurns) {
+  const double q = c.fixedScale / 4;
+  const double u = std::trunc((xTurns * c.fixedScale) / q);
+  const double u2 = mulFixed(c, u, u);
+  const double u3 = mulFixed(c, u2, u);
+  const double u5 = mulFixed(c, u3, u2);
+  return mulFixed(c, jsRound(1.5707963 * c.fixedScale), u) +
+         mulFixed(c, jsRound(-0.6459641 * c.fixedScale), u3) +
+         mulFixed(c, jsRound(0.0796926 * c.fixedScale), u5);
+}
+
+double clampOne(const Config& c, double v) {
+  if (v < -c.fixedScale) return -c.fixedScale;
+  if (v > c.fixedScale) return c.fixedScale;
+  return v;
+}
+
+double sinTurnsImpl(const Config& c, double turns) {
+  const double q = c.fixedScale / 4;
+  const double t = std::fmod(std::fmod(turns, c.fixedScale) + c.fixedScale, c.fixedScale);
+  if (t < q) return normalizeZero(clampOne(c, sinQuarter(c, t)));
+  if (t < 2 * q) return normalizeZero(clampOne(c, sinQuarter(c, 2 * q - t)));
+  if (t < 3 * q) return normalizeZero(clampOne(c, -sinQuarter(c, t - 2 * q)));
+  return normalizeZero(clampOne(c, -sinQuarter(c, c.fixedScale - t)));
+}
+
+// Math.PI is the nearest double to pi in both languages, so these constants are
+// bit-identical to the reference's this.toFixed(Math.PI / 4) and friends.
+constexpr double kPi = 3.141592653589793;
+
+}  // namespace
+
+Config defaultConfig() { return Config{1000.0, -2147483648.0, 2147483647.0}; }
+
+double toFixed(const Config& c, double value, bool& ok) {
+  if (!std::isfinite(value)) {
+    ok = false;
+    return 0.0;
+  }
+  return normalizeZero(saturate(jsRound(value * c.fixedScale), c.minFixed, c.maxFixed));
+}
+
+double fromFixed(const Config& c, double value, bool& ok) {
+  if (!isFixed(value)) {
+    ok = false;
+    return 0.0;
+  }
+  return value / c.fixedScale;
+}
+
+double add(const Config& c, double a, double b, bool& ok) {
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  const double result = a + b;
+  if (result < c.minFixed || result > c.maxFixed) {
+    ok = false;
+    return 0.0;
+  }
+  return result;
+}
+
+double sub(const Config& c, double a, double b, bool& ok) {
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  const double result = a - b;
+  if (result < c.minFixed || result > c.maxFixed) {
+    ok = false;
+    return 0.0;
+  }
+  return result;
+}
+
+// Over-2^53 semantic: the reference computes a*b as an IEEE double and
+// truncates, so products beyond 2^53 lose low bits identically on every peer. We
+// reproduce that by computing in double rather than int64 — a naive int64 port
+// stays exact and therefore DISAGREES. Pinned by the mulWide vectors in
+// core/tests/fixed-corpus.mjs, which use widened bounds so the result is not
+// saturated and the difference is observable.
+double mul(const Config& c, double a, double b, bool& ok) {
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  return normalizeZero(saturate(std::trunc((a * b) / c.fixedScale), c.minFixed, c.maxFixed));
+}
+
+double div(const Config& c, double a, double b, bool& ok) {
+  if (!isFixed(a) || !isFixed(b) || b == 0.0) {
+    ok = false;
+    return 0.0;
+  }
+  return normalizeZero(saturate(std::trunc((a * c.fixedScale) / b), c.minFixed, c.maxFixed));
+}
+
+double saturatingAdd(const Config& c, double a, double b, bool& ok) {
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  return saturate(a + b, c.minFixed, c.maxFixed);
+}
+
+double saturatingSub(const Config& c, double a, double b, bool& ok) {
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  return saturate(a - b, c.minFixed, c.maxFixed);
+}
+
+double quantize(const Config& c, double value, double engine, bool& ok) {
+  (void)c;
+  if (!isFixed(value) || !isFixed(engine) || engine <= 0.0) {
+    ok = false;
+    return 0.0;
+  }
+  return std::trunc(value / engine) * engine;
+}
+
+double sqrtFixed(const Config& c, double value, bool& ok) {
+  if (!isFixed(value) || value < 0.0) {
+    ok = false;
+    return 0.0;
+  }
+  if (value == 0.0) return 0.0;
+  const double n = value * c.fixedScale;
+  double x = n;
+  double y = std::trunc((x + 1) / 2);
+  while (y < x) {
+    x = y;
+    y = std::trunc((x + std::trunc(n / x)) / 2);
+  }
+  return saturate(x, c.minFixed, c.maxFixed);
+}
+
+double integerSqrt(const Config& c, double value, bool& ok) {
+  (void)c;
+  if (!isSafeInteger(value) || value < 0.0) {
+    ok = false;
+    return 0.0;
+  }
+  if (value < 2.0) return value;
+  double low = 1.0;
+  double high = jsMin(value, 94906266.0);
+  while (low <= high) {
+    const double mid = low + std::trunc((high - low) / 2);
+    if (mid <= std::trunc(value / mid)) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return high;
+}
+
+double absFixed(const Config& c, double value, bool& ok) {
+  if (!isFixed(value)) {
+    ok = false;
+    return 0.0;
+  }
+  return saturate(value < 0.0 ? -value : value, c.minFixed, c.maxFixed);
+}
+
+double sign(const Config& c, double value, bool& ok) {
+  if (!isFixed(value)) {
+    ok = false;
+    return 0.0;
+  }
+  if (value > 0.0) return c.fixedScale;
+  if (value < 0.0) return -c.fixedScale;
+  return 0.0;
+}
+
+double minFixed(const Config& c, double a, double b, bool& ok) {
+  (void)c;
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  return a < b ? a : b;
+}
+
+double maxFixed(const Config& c, double a, double b, bool& ok) {
+  (void)c;
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  return a > b ? a : b;
+}
+
+double lerp(const Config& c, double a, double b, double t, bool& ok) {
+  if (!isFixed(a) || !isFixed(b) || !isFixed(t)) {
+    ok = false;
+    return 0.0;
+  }
+  return saturate(a + std::trunc(((b - a) * t) / c.fixedScale), c.minFixed, c.maxFixed);
+}
+
+double mod(const Config& c, double a, double b, bool& ok) {
+  (void)c;
+  if (!isFixed(a) || !isFixed(b) || b == 0.0) {
+    ok = false;
+    return 0.0;
+  }
+  const double r = std::fmod(a, b);
+  return (r != 0.0 && ((r < 0.0) != (b < 0.0))) ? r + b : r;
+}
+
+double inverseLerp(const Config& c, double a, double b, double v, bool& ok) {
+  if (!isFixed(a) || !isFixed(b) || !isFixed(v)) {
+    ok = false;
+    return 0.0;
+  }
+  if (a == b) return 0.0;
+  return saturate(std::trunc(((v - a) * c.fixedScale) / (b - a)), c.minFixed, c.maxFixed);
+}
+
+double remap(const Config& c, double inMin, double inMax, double outMin, double outMax, double v, bool& ok) {
+  const double t = inverseLerp(c, inMin, inMax, v, ok);
+  if (!ok) return 0.0;
+  return lerp(c, outMin, outMax, t, ok);
+}
+
+double smoothstep(const Config& c, double edge0, double edge1, double x, bool& ok) {
+  const double raw = inverseLerp(c, edge0, edge1, x, ok);
+  if (!ok) return 0.0;
+  const double t = clamp(c, raw, 0.0, c.fixedScale, ok);
+  const double t2 = std::trunc((t * t) / c.fixedScale);
+  const double t3 = std::trunc((t2 * t) / c.fixedScale);
+  return saturate(3 * t2 - 2 * t3, c.minFixed, c.maxFixed);
+}
+
+double log2Fixed(const Config& c, double value, bool& ok) {
+  if (!isFixed(value) || value <= 0.0) {
+    ok = false;
+    return 0.0;
+  }
+  double e = 0.0;
+  double v = value;
+  const double one = c.fixedScale;
+  while (v >= 2 * one) {
+    v = std::trunc(v / 2);
+    e += 1;
+  }
+  while (v < one) {
+    v = v * 2;
+    e -= 1;
+  }
+  const double f = v - one;
+  const double c1 = jsRound(1.4273 * c.fixedScale);
+  const double c2 = jsRound(0.6018 * c.fixedScale);
+  const double c3 = jsRound(0.1745 * c.fixedScale);
+  const double poly = mulFixed(c, f, c1 - mulFixed(c, f, c2 - mulFixed(c, f, c3)));
+  return e * c.fixedScale + poly;
+}
+
+double logFixed(const Config& c, double value, bool& ok) {
+  const double l2 = log2Fixed(c, value, ok);
+  if (!ok) return 0.0;
+  const double ln2 = jsRound(0.6931472 * c.fixedScale);
+  return saturate(std::trunc((l2 * ln2) / c.fixedScale), c.minFixed, c.maxFixed);
+}
+
+double expFixed(const Config& c, double value, bool& ok) {
+  if (!isFixed(value)) {
+    ok = false;
+    return 0.0;
+  }
+  const double invLn2 = jsRound(1.4426950 * c.fixedScale);
+  const double y = std::trunc((value * invLn2) / c.fixedScale);
+  double yi = std::trunc(y / c.fixedScale);
+  double yf = y - yi * c.fixedScale;
+  if (yf < 0.0) {
+    yf += c.fixedScale;
+    yi -= 1;
+  }
+  const double b1 = jsRound(0.6931472 * c.fixedScale);
+  const double b2 = jsRound(0.2401596 * c.fixedScale);
+  const double b3 = jsRound(0.0521416 * c.fixedScale);
+  double result = c.fixedScale + mulFixed(c, yf, b1 + mulFixed(c, yf, b2 + mulFixed(c, yf, b3)));
+  if (yi >= 0.0) {
+    for (double i = 0; i < yi; i += 1) {
+      result = saturate(result * 2, c.minFixed, c.maxFixed);
+    }
+  } else {
+    for (double i = 0; i < -yi; i += 1) {
+      result = std::trunc(result / 2);
+    }
+  }
+  return saturate(result, c.minFixed, c.maxFixed);
+}
+
+double sinTurns(const Config& c, double turns, bool& ok) {
+  if (!isFixed(turns)) {
+    ok = false;
+    return 0.0;
+  }
+  return sinTurnsImpl(c, turns);
+}
+
+double cosTurns(const Config& c, double turns, bool& ok) {
+  if (!isFixed(turns)) {
+    ok = false;
+    return 0.0;
+  }
+  return sinTurnsImpl(c, turns + c.fixedScale / 4);
+}
+
+double tanTurns(const Config& c, double turns, bool& ok) {
+  const double s = sinTurns(c, turns, ok);
+  if (!ok) return 0.0;
+  const double co = cosTurns(c, turns, ok);
+  if (!ok) return 0.0;
+  return div(c, s, co, ok);
+}
+
+double atan2Turns(const Config& c, double y, double x, bool& ok) {
+  if (!isFixed(y) || !isFixed(x)) {
+    ok = false;
+    return 0.0;
+  }
+  if (x == 0.0 && y == 0.0) return 0.0;
+  const double ax = x < 0.0 ? -x : x;
+  const double ay = y < 0.0 ? -y : y;
+  const bool swap = ay > ax;
+  const double z = div(c, swap ? ax : ay, swap ? ay : ax, ok);
+  if (!ok) return 0.0;
+  const double k1 = toFixed(c, kPi / 4, ok);
+  const double k2 = toFixed(c, 0.2447, ok);
+  const double k3 = toFixed(c, 0.0663, ok);
+  if (!ok) return 0.0;
+
+  const double term1 = mul(c, k1, z, ok);
+  const double zc = sub(c, c.fixedScale, z, ok);
+  const double zz = mul(c, z, zc, ok);
+  const double inner = add(c, k2, mul(c, k3, z, ok), ok);
+  const double atanRad = add(c, term1, mul(c, zz, inner, ok), ok);
+  if (!ok) return 0.0;
+
+  double turn = mul(c, atanRad, toFixed(c, 1 / (2 * kPi), ok), ok);
+  if (!ok) return 0.0;
+  if (swap) {
+    turn = sub(c, c.fixedScale / 4, turn, ok);
+    if (!ok) return 0.0;
+  }
+
+  double full = 0.0;
+  if (x >= 0.0 && y >= 0.0) {
+    full = turn;
+  } else if (x < 0.0 && y >= 0.0) {
+    full = sub(c, c.fixedScale / 2, turn, ok);
+  } else if (x < 0.0 && y < 0.0) {
+    full = add(c, c.fixedScale / 2, turn, ok);
+  } else {
+    full = sub(c, c.fixedScale, turn, ok);
+  }
+  if (!ok) return 0.0;
+  return std::fmod(std::fmod(full, c.fixedScale) + c.fixedScale, c.fixedScale);
+}
+
+double atan2Signed(const Config& c, double y, double x, bool& ok) {
+  const double turn = atan2Turns(c, y, x, ok);
+  if (!ok) return 0.0;
+  const double half = c.fixedScale / 2;
+  return turn >= half ? turn - c.fixedScale : turn;
+}
+
+double wrapTurns(const Config& c, double t, bool& ok) {
+  if (!isFixed(t)) {
+    ok = false;
+    return 0.0;
+  }
+  return std::fmod(std::fmod(t, c.fixedScale) + c.fixedScale, c.fixedScale);
+}
+
+double angleDeltaTurns(const Config& c, double a, double b, bool& ok) {
+  if (!isFixed(a) || !isFixed(b)) {
+    ok = false;
+    return 0.0;
+  }
+  const double half = c.fixedScale / 2;
+  double d = std::fmod(std::fmod(b - a, c.fixedScale) + c.fixedScale, c.fixedScale);
+  if (d >= half) d -= c.fixedScale;
+  return d;
+}
+
+double turnsToRadians(const Config& c, double t, bool& ok) {
+  if (!isFixed(t)) {
+    ok = false;
+    return 0.0;
+  }
+  const double tau = toFixed(c, 2 * kPi, ok);
+  if (!ok) return 0.0;
+  return saturate(std::trunc((t * tau) / c.fixedScale), c.minFixed, c.maxFixed);
+}
+
+double radiansToTurns(const Config& c, double r, bool& ok) {
+  if (!isFixed(r)) {
+    ok = false;
+    return 0.0;
+  }
+  const double tau = toFixed(c, 2 * kPi, ok);
+  if (!ok) return 0.0;
+  return saturate(std::trunc((r * c.fixedScale) / tau), c.minFixed, c.maxFixed);
+}
+
+double hypot(const Config& c, double x, double y, bool& ok) {
+  if (!isFixed(x) || !isFixed(y)) {
+    ok = false;
+    return 0.0;
+  }
+  const double xx = mul(c, x, x, ok);
+  const double yy = mul(c, y, y, ok);
+  if (!ok) return 0.0;
+  return sqrtFixed(c, saturate(xx + yy, c.minFixed, c.maxFixed), ok);
+}
+
+Vec2 vec2(const Config& c, double x, double y, bool& ok) {
+  (void)c;
+  if (!isFixed(x) || !isFixed(y)) {
+    ok = false;
+    return Vec2{0, 0};
+  }
+  return Vec2{x, y};
+}
+
+Vec2 vec2Add(const Config& c, Vec2 a, Vec2 b, bool& ok) {
+  (void)ok;
+  return Vec2{saturate(a.x + b.x, c.minFixed, c.maxFixed), saturate(a.y + b.y, c.minFixed, c.maxFixed)};
+}
+
+Vec2 vec2Sub(const Config& c, Vec2 a, Vec2 b, bool& ok) {
+  const double x = saturatingSub(c, a.x, b.x, ok);
+  const double y = saturatingSub(c, a.y, b.y, ok);
+  return Vec2{x, y};
+}
+
+Vec2 vec2Scale(const Config& c, Vec2 v, double s, bool& ok) {
+  if (!isFixed(v.x) || !isFixed(v.y) || !isFixed(s)) {
+    ok = false;
+    return Vec2{0, 0};
+  }
+  const double x = mul(c, v.x, s, ok);
+  const double y = mul(c, v.y, s, ok);
+  return Vec2{x, y};
+}
+
+double vec2Dot(const Config& c, Vec2 a, Vec2 b, bool& ok) {
+  const double xx = mul(c, a.x, b.x, ok);
+  const double yy = mul(c, a.y, b.y, ok);
+  if (!ok) return 0.0;
+  return saturate(xx + yy, c.minFixed, c.maxFixed);
+}
+
+double vec2Cross(const Config& c, Vec2 a, Vec2 b, bool& ok) {
+  const double xy = mul(c, a.x, b.y, ok);
+  const double yx = mul(c, a.y, b.x, ok);
+  if (!ok) return 0.0;
+  return saturate(xy - yx, c.minFixed, c.maxFixed);
+}
+
+double vec2LengthSq(const Config& c, Vec2 v, bool& ok) {
+  const double xx = mul(c, v.x, v.x, ok);
+  const double yy = mul(c, v.y, v.y, ok);
+  if (!ok) return 0.0;
+  return saturate(xx + yy, c.minFixed, c.maxFixed);
+}
+
+double vec2Length(const Config& c, Vec2 v, bool& ok) { return hypot(c, v.x, v.y, ok); }
+
+double vec2DistanceSq(const Config& c, Vec2 a, Vec2 b, bool& ok) {
+  const Vec2 d = vec2Sub(c, a, b, ok);
+  if (!ok) return 0.0;
+  return vec2LengthSq(c, d, ok);
+}
+
+double vec2Distance(const Config& c, Vec2 a, Vec2 b, bool& ok) {
+  const double dx = saturatingSub(c, a.x, b.x, ok);
+  const double dy = saturatingSub(c, a.y, b.y, ok);
+  if (!ok) return 0.0;
+  return hypot(c, dx, dy, ok);
+}
+
+Vec2 vec2Normalize(const Config& c, Vec2 v, bool& ok) {
+  const double len = hypot(c, v.x, v.y, ok);
+  if (!ok) return Vec2{0, 0};
+  if (len == 0.0) return Vec2{0, 0};
+  const double x = div(c, v.x, len, ok);
+  const double y = div(c, v.y, len, ok);
+  return Vec2{x, y};
+}
+
+Vec2 vec2Perp(const Config& c, Vec2 v, bool& ok) {
+  if (!isFixed(v.x) || !isFixed(v.y)) {
+    ok = false;
+    return Vec2{0, 0};
+  }
+  return Vec2{saturatingSub(c, 0, v.y, ok), v.x};
+}
+
+Vec2 vec2Negate(const Config& c, Vec2 v, bool& ok) {
+  if (!isFixed(v.x) || !isFixed(v.y)) {
+    ok = false;
+    return Vec2{0, 0};
+  }
+  const double x = saturatingSub(c, 0, v.x, ok);
+  const double y = saturatingSub(c, 0, v.y, ok);
+  return Vec2{x, y};
+}
+
+Vec2 vec2Rotate(const Config& c, Vec2 v, double turns, bool& ok) {
+  if (!isFixed(v.x) || !isFixed(v.y) || !isFixed(turns)) {
+    ok = false;
+    return Vec2{0, 0};
+  }
+  const double co = cosTurns(c, turns, ok);
+  const double si = sinTurns(c, turns, ok);
+  if (!ok) return Vec2{0, 0};
+  const double x = saturatingSub(c, mul(c, v.x, co, ok), mul(c, v.y, si, ok), ok);
+  const double y = saturatingAdd(c, mul(c, v.x, si, ok), mul(c, v.y, co, ok), ok);
+  return Vec2{x, y};
+}
+
+Vec2 vec2FromAngleTurns(const Config& c, double turns, double length, bool& ok) {
+  if (!isFixed(turns) || !isFixed(length)) {
+    ok = false;
+    return Vec2{0, 0};
+  }
+  const double x = mul(c, cosTurns(c, turns, ok), length, ok);
+  const double y = mul(c, sinTurns(c, turns, ok), length, ok);
+  return Vec2{x, y};
+}
+
+double vec2AngleTurns(const Config& c, Vec2 v, bool& ok) { return atan2Turns(c, v.y, v.x, ok); }
+
+Vec2 vec2Lerp(const Config& c, Vec2 a, Vec2 b, double t, bool& ok) {
+  if (!isFixed(t)) {
+    ok = false;
+    return Vec2{0, 0};
+  }
+  return Vec2{
+    normalizeZero(a.x + std::trunc(((b.x - a.x) * t) / c.fixedScale)),
+    normalizeZero(a.y + std::trunc(((b.y - a.y) * t) / c.fixedScale)),
+  };
+}
+
+Vec3 vec3(const Config& c, double x, double y, double z, bool& ok) {
+  (void)c;
+  if (!isFixed(x) || !isFixed(y) || !isFixed(z)) {
+    ok = false;
+    return Vec3{0, 0, 0};
+  }
+  return Vec3{x, y, z};
+}
+
+Vec3 vec3Add(const Config& c, Vec3 a, Vec3 b, bool& ok) {
+  (void)ok;
+  return Vec3{
+    saturate(a.x + b.x, c.minFixed, c.maxFixed),
+    saturate(a.y + b.y, c.minFixed, c.maxFixed),
+    saturate(a.z + b.z, c.minFixed, c.maxFixed),
+  };
+}
+
+Vec3 vec3Sub(const Config& c, Vec3 a, Vec3 b, bool& ok) {
+  const double x = saturatingSub(c, a.x, b.x, ok);
+  const double y = saturatingSub(c, a.y, b.y, ok);
+  const double z = saturatingSub(c, a.z, b.z, ok);
+  return Vec3{x, y, z};
+}
+
+Vec3 vec3Scale(const Config& c, Vec3 v, double s, bool& ok) {
+  if (!isFixed(s)) {
+    ok = false;
+    return Vec3{0, 0, 0};
+  }
+  const double x = mul(c, v.x, s, ok);
+  const double y = mul(c, v.y, s, ok);
+  const double z = mul(c, v.z, s, ok);
+  return Vec3{x, y, z};
+}
+
+double vec3Dot(const Config& c, Vec3 a, Vec3 b, bool& ok) {
+  const double xx = mul(c, a.x, b.x, ok);
+  const double yy = mul(c, a.y, b.y, ok);
+  const double zz = mul(c, a.z, b.z, ok);
+  if (!ok) return 0.0;
+  return saturate(xx + yy + zz, c.minFixed, c.maxFixed);
+}
+
+Vec3 vec3Cross(const Config& c, Vec3 a, Vec3 b, bool& ok) {
+  const double x = sub(c, mul(c, a.y, b.z, ok), mul(c, a.z, b.y, ok), ok);
+  const double y = sub(c, mul(c, a.z, b.x, ok), mul(c, a.x, b.z, ok), ok);
+  const double z = sub(c, mul(c, a.x, b.y, ok), mul(c, a.y, b.x, ok), ok);
+  return Vec3{x, y, z};
+}
+
+double vec3LengthSq(const Config& c, Vec3 v, bool& ok) {
+  const double xx = mul(c, v.x, v.x, ok);
+  const double yy = mul(c, v.y, v.y, ok);
+  const double zz = mul(c, v.z, v.z, ok);
+  if (!ok) return 0.0;
+  return saturate(xx + yy + zz, c.minFixed, c.maxFixed);
+}
+
+double vec3Length(const Config& c, Vec3 v, bool& ok) {
+  const double lenSq = vec3LengthSq(c, v, ok);
+  if (!ok) return 0.0;
+  return sqrtFixed(c, lenSq, ok);
+}
+
+double vec3Distance(const Config& c, Vec3 a, Vec3 b, bool& ok) {
+  const Vec3 d = vec3Sub(c, a, b, ok);
+  if (!ok) return 0.0;
+  return vec3Length(c, d, ok);
+}
+
+Vec3 vec3Normalize(const Config& c, Vec3 v, bool& ok) {
+  const double len = vec3Length(c, v, ok);
+  if (!ok) return Vec3{0, 0, 0};
+  if (len == 0.0) return Vec3{0, 0, 0};
+  const double x = div(c, v.x, len, ok);
+  const double y = div(c, v.y, len, ok);
+  const double z = div(c, v.z, len, ok);
+  return Vec3{x, y, z};
+}
+
+Vec3 vec3Lerp(const Config& c, Vec3 a, Vec3 b, double t, bool& ok) {
+  if (!isFixed(t)) {
+    ok = false;
+    return Vec3{0, 0, 0};
+  }
+  const double x = lerp(c, a.x, b.x, t, ok);
+  const double y = lerp(c, a.y, b.y, t, ok);
+  const double z = lerp(c, a.z, b.z, t, ok);
+  return Vec3{x, y, z};
+}
+
+Vec3 vec3Negate(const Config& c, Vec3 v, bool& ok) {
+  const double x = saturatingSub(c, 0, v.x, ok);
+  const double y = saturatingSub(c, 0, v.y, ok);
+  const double z = saturatingSub(c, 0, v.z, ok);
+  return Vec3{x, y, z};
+}
+
+Quat quatFromYawTurns(const Config& c, double turns, bool& ok) {
+  if (!isFixed(turns)) {
+    ok = false;
+    return Quat{0, 0, 0, 0};
+  }
+  const double halfTurns = std::trunc(turns / 2);
+  return Quat{
+    0.0,
+    0.0,
+    normalizeZero(sinTurnsImpl(c, halfTurns)),
+    normalizeZero(sinTurnsImpl(c, halfTurns + c.fixedScale / 4)),
+  };
+}
+
+Quat quatLerp(const Config& c, Quat a, Quat b, double t, bool& ok) {
+  if (!isFixed(t)) {
+    ok = false;
+    return Quat{0, 0, 0, 0};
+  }
+  return Quat{
+    a.x + std::trunc(((b.x - a.x) * t) / c.fixedScale),
+    a.y + std::trunc(((b.y - a.y) * t) / c.fixedScale),
+    a.z + std::trunc(((b.z - a.z) * t) / c.fixedScale),
+    a.w + std::trunc(((b.w - a.w) * t) / c.fixedScale),
+  };
+}
+
+// The only operation with no integer assertion, so it can be handed a real or a
+// NaN and must return one. Everything else asserts first.
+double clamp(const Config& c, double value, double lo, double hi, bool& ok) {
+  (void)c;
+  (void)ok;
+  return jsMin(hi, jsMax(lo, value));
+}
+
+}  // namespace rundot::fixedmath