@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/native/component_runtime.hpp

@@ -0,0 +1,112 @@
+// Portable C++20 component runtime for the native-compliant R3F proof fork.
+// No browser, JS engine, or platform dependencies: fixed-tick, fixed-point
+// (scale 1e6) int64 simulation over exactly four installed component families.
+// Canonical hash layout must stay byte-identical to
+// component-reference-runtime.mjs.
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace rundot {
+
+enum class ComponentType : std::uint8_t {
+  Transform,
+  FixedTickMover,
+  InputActionState,
+  ReplicatedState,
+};
+
+struct Vec3i64 {
+  std::int64_t x = 0;
+  std::int64_t y = 0;
+  std::int64_t z = 0;
+};
+
+struct TransformState {
+  Vec3i64 position;
+  Vec3i64 rotation;
+  Vec3i64 scale;
+};
+
+struct MoverState {
+  Vec3i64 velocityPerTick;
+};
+
+struct InputState {
+  std::string actionId;
+  std::string outputField;
+  bool pressed = false;
+  std::int64_t lastEdgeTick = -1;
+};
+
+struct ReplicatedSpec {
+  std::string authority;
+  std::vector<std::string> fields;
+};
+
+struct ComponentRecord {
+  ComponentType type;
+  std::size_t index;
+};
+
+struct EntityState {
+  std::string id;
+  std::vector<ComponentRecord> components;
+  bool hasTransform = false;
+  TransformState transform;
+  std::vector<MoverState> movers;
+  std::vector<InputState> inputs;
+  bool hasReplicated = false;
+  ReplicatedSpec replicated;
+};
+
+struct ReplayAction {
+  std::int64_t tick = 0;
+  std::string actionId;
+  bool pressed = false;
+};
+
+struct CorrectionField {
+  std::string field;
+  bool isVec3 = false;
+  Vec3i64 vec;
+  bool boolValue = false;
+};
+
+struct ReplayCorrection {
+  std::int64_t tick = 0;
+  std::string entityId;
+  std::vector<CorrectionField> fields;
+};
+
+struct Replay {
+  std::int64_t tickCount = 0;
+  std::vector<ReplayAction> actions;
+  std::vector<ReplayCorrection> corrections;
+};
+
+struct RuntimeFault {
+  std::string code;
+  std::int64_t tick = -1;
+  std::string entityId;
+};
+
+struct RunResult {
+  std::vector<std::string> tickHashes;
+  std::string finalDigest;
+  bool faulted = false;
+  RuntimeFault fault;
+  std::int64_t completedTicks = 0;
+};
+
+std::string sha256Hex(const std::uint8_t* data, std::size_t size);
+
+// Executes the replay against the entity set (declared pack order). All
+// simulation state lives in the packed EntityState vector; the only
+// allocations after activation are the bounded hash buffers.
+RunResult runReplay(std::vector<EntityState>& entities, const Replay& replay, bool hashEveryTick);
+
+}  // namespace rundot

package/native/deterministic_math.cpp

@@ -0,0 +1,594 @@
+// Transliteration of the deterministic fdlibm-style JS math shim
+// (kinetix-deterministic-math.mjs, DETERMINISTIC_MATH_SOURCE) into C++.
+// Every floating-point expression is kept in EXACTLY the shape the
+// JS source writes it — same operation order, same intermediates — so that
+// with -ffp-contract=off the results are bit-identical to the JS shim for all
+// finite inputs. JS bitwise semantics (`| 0` → ToInt32, `>>> 0` → ToUint32)
+// are mirrored with explicit std::int32_t / std::uint32_t casts.
+
+#include "deterministic_math.hpp"
+
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstdint>
+
+namespace rundot::detmath {
+
+namespace {
+
+// ---- word access helpers (JS: Float64Array/Uint32Array views) --------------
+inline std::int32_t HI(double x) {
+  return static_cast<std::int32_t>(
+      static_cast<std::uint32_t>(std::bit_cast<std::uint64_t>(x) >> 32));
+}
+inline std::int32_t LO(double x) {
+  return static_cast<std::int32_t>(
+      static_cast<std::uint32_t>(std::bit_cast<std::uint64_t>(x)));
+}
+inline double fromWords(std::uint32_t hi, std::uint32_t lo) {
+  return std::bit_cast<double>((static_cast<std::uint64_t>(hi) << 32) |
+                               static_cast<std::uint64_t>(lo));
+}
+inline double setHi(double x, std::uint32_t hi) {
+  const std::uint64_t bits = std::bit_cast<std::uint64_t>(x);
+  return std::bit_cast<double>((static_cast<std::uint64_t>(hi) << 32) |
+                               (bits & 0xffffffffull));
+}
+inline double setLo(double x, std::uint32_t lo) {
+  const std::uint64_t bits = std::bit_cast<std::uint64_t>(x);
+  return std::bit_cast<double>((bits & 0xffffffff00000000ull) |
+                               static_cast<std::uint64_t>(lo));
+}
+
+// ECMAScript ToInt32 (JS `value | 0` on a double).
+inline std::int32_t toInt32(double v) {
+  if (std::isnan(v) || std::isinf(v)) return 0;
+  double d = std::trunc(v);
+  d = std::fmod(d, 4294967296.0);
+  if (d < 0.0) d += 4294967296.0;
+  return static_cast<std::int32_t>(static_cast<std::uint32_t>(d));
+}
+
+// ---- scalbn2 ----------------------------------------------------------------
+double scalbn2(double x, int n) {
+  std::int32_t hx = HI(x), lx = LO(x);
+  std::int32_t k = (hx & 0x7ff00000) >> 20;
+  if (k == 0) {
+    if ((lx | (hx & 0x7fffffff)) == 0) return x;
+    x *= 18014398509481984.0;
+    hx = HI(x);
+    k = ((hx & 0x7ff00000) >> 20) - 54;
+    if (n < -50000) return 1e-300 * x;
+  }
+  if (k == 0x7ff) return x + x;
+  k = k + n;
+  if (k > 0x7fe) return 1e300 * (x > 0 ? 1e300 : -1e300);
+  if (k > 0) return setHi(x, static_cast<std::uint32_t>((hx & 0x800fffff) | (k << 20)));
+  if (k <= -54) {
+    if (n > 50000) return 1e300 * (x > 0 ? 1e300 : -1e300);
+    return 1e-300 * (x > 0 ? 1e-300 : -1e-300);
+  }
+  k += 54;
+  x = setHi(x, static_cast<std::uint32_t>((hx & 0x800fffff) | (k << 20)));
+  return x * 5.55112312578270211816e-17;  // 2^-54
+}
+
+// ---- __kernel_sin / __kernel_cos (fdlibm) -----------------------------------
+constexpr double S1 = -1.66666666666666324348e-01, S2 = 8.33333333332248946124e-03,
+                 S3 = -1.98412698298579493134e-04, S4 = 2.75573137070700676789e-06,
+                 S5 = -2.50507602534068634195e-08, S6 = 1.58969099521155010221e-10;
+double kernelSin(double x, double y, int iy) {
+  const double z = x * x;
+  const double v = z * x;
+  const double r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));
+  if (iy == 0) return x + v * (S1 + z * r);
+  return x - ((z * (0.5 * y - v * r) - y) - v * S1);
+}
+constexpr double C1 = 4.16666666666666019037e-02, C2 = -1.38888888888741095749e-03,
+                 C3 = 2.48015872894767294178e-05, C4 = -2.75573143513906633035e-07,
+                 C5 = 2.08757232129817482790e-09, C6 = -1.13596475577881948265e-11;
+double kernelCos(double x, double y) {
+  const double z = x * x;
+  const double r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))));
+  const double hz = 0.5 * z;
+  const double w = 1.0 - hz;
+  return w + (((1.0 - w) - hz) + (z * r - x * y));
+}
+
+// ---- __rem_pio2 (fdlibm, incl. Payne-Hanek for large args) -------------------
+constexpr std::int32_t twoOverPi[] = {
+    0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, 0x95993C, 0x439041,
+    0xFE5163, 0xABDEBB, 0xC561B7, 0x246E3A, 0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C,
+    0xFE1DEB, 0x1CB129, 0xA73EE8, 0x8235F5, 0x2EBB44, 0x84E99C, 0x7026B4, 0x5F7E41,
+    0x3991D6, 0x398353, 0x39F49C, 0x845F8B, 0xBDF928, 0x3B1FF8, 0x97FFDE, 0x05980F,
+    0xEF2F11, 0x8B5A0A, 0x6D1F6D, 0x367ECF, 0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D,
+    0x7527BA, 0xC7EBE5, 0xF17B3D, 0x0739F7, 0x8A5292, 0xEA6BFB, 0x5FB11F, 0x8D5D08,
+    0x560330, 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3, 0x91615E, 0xE61B08,
+    0x659985, 0x5F14A0, 0x68408D, 0xFFD880, 0x4D7327, 0x310606, 0x1556CA, 0x73A8C9,
+    0x60E27B, 0xC08C6B,
+};
+constexpr double PIo2[] = {
+    1.57079625129699707031e+00, 7.54978941586159635335e-08, 5.39030252995776476554e-15,
+    3.28200341580791294123e-22, 1.27065575308067607349e-29, 1.22933308981111328932e-36,
+    2.73370053816464559624e-44, 2.16741683877804819444e-51,
+};
+constexpr double two24 = 1.67772160000000000000e+07, twon24 = 5.96046447753906250000e-08;
+int kernelRemPio2(const double* x, double* y, int e0, int nx) {
+  // prec = 2 (double), jk = 4
+  const int jk = 4, jp = 4;
+  const int jx = nx - 1;
+  int jv = (e0 - 3) / 24;  // JS: ((e0 - 3) / 24) | 0 — truncation toward zero
+  if (jv < 0) jv = 0;
+  int q0 = e0 - 24 * (jv + 1);
+  double f[20] = {0};
+  double q[20] = {0};
+  std::int32_t iq[20] = {0};
+  double fw0[20] = {0};
+  int i, j, k, n = 0, ih, carry;
+  double z, fw;
+  for (i = 0, j = jv - jx; i <= jx + jk; i++, j++) f[i] = j < 0 ? 0 : static_cast<double>(twoOverPi[j]);
+  for (i = 0; i <= jk; i++) {
+    fw = 0;
+    for (j = 0; j <= jx; j++) fw += x[j] * f[jx + i - j];
+    q[i] = fw;
+  }
+  int jz = jk;
+  bool recomputeNeeded = true;
+  while (recomputeNeeded) {
+    recomputeNeeded = false;
+    // distill q[] into iq[] reversingly
+    for (i = 0, j = jz, z = q[jz]; j > 0; i++, j--) {
+      fw = std::floor(twon24 * z);
+      iq[i] = toInt32(z - two24 * fw);
+      z = q[j - 1] + fw;
+    }
+    z = scalbn2(z, q0);
+    z -= 8.0 * std::floor(z * 0.125);
+    n = toInt32(z);
+    z -= n;
+    ih = 0;
+    if (q0 > 0) {
+      i = (iq[jz - 1] >> (24 - q0));
+      n += i;
+      iq[jz - 1] -= i << (24 - q0);
+      ih = iq[jz - 1] >> (23 - q0);
+    } else if (q0 == 0) ih = iq[jz - 1] >> 23;
+    else if (z >= 0.5) ih = 2;
+    if (ih > 0) {
+      n += 1;
+      carry = 0;
+      for (i = 0; i < jz; i++) {
+        j = iq[i];
+        if (carry == 0) {
+          if (j != 0) { carry = 1; iq[i] = 0x1000000 - j; }
+        } else iq[i] = 0xffffff - j;
+      }
+      if (q0 > 0) {
+        switch (q0) {
+          case 1: iq[jz - 1] &= 0x7fffff; break;
+          case 2: iq[jz - 1] &= 0x3fffff; break;
+        }
+      }
+      if (ih == 2) {
+        z = 1.0 - z;
+        if (carry != 0) z -= scalbn2(1.0, q0);
+      }
+    }
+    if (z == 0) {
+      j = 0;
+      for (i = jz - 1; i >= jk; i--) j |= iq[i];
+      if (j == 0) {
+        for (k = 1; iq[jk - k] == 0; k++) { }
+        for (i = jz + 1; i <= jz + k; i++) {
+          f[jx + i] = static_cast<double>(twoOverPi[jv + i]);
+          for (j = 0, fw = 0; j <= jx; j++) fw += x[j] * f[jx + i - j];
+          q[i] = fw;
+        }
+        jz += k;
+        recomputeNeeded = true;
+        continue;
+      }
+    }
+    if (z == 0) {
+      jz -= 1;
+      q0 -= 24;
+      while (iq[jz] == 0) { jz--; q0 -= 24; }
+    } else {
+      z = scalbn2(z, -q0);
+      if (z >= two24) {
+        fw = std::floor(twon24 * z);
+        iq[jz] = toInt32(z - two24 * fw);
+        jz += 1;
+        q0 += 24;
+        iq[jz] = toInt32(fw);
+      } else iq[jz] = toInt32(z);
+    }
+    fw = scalbn2(1.0, q0);
+    for (i = jz; i >= 0; i--) { q[i] = fw * iq[i]; fw *= twon24; }
+    for (i = jz; i >= 0; i--) {
+      for (fw = 0, k = 0; k <= jp && k <= jz - i; k++) fw += PIo2[k] * q[i + k];
+      fw0[jz - i] = fw;
+    }
+    // compress fw0 into y[] (prec 2)
+    fw = 0;
+    for (i = jz; i >= 0; i--) fw += fw0[i];
+    y[0] = ih == 0 ? fw : -fw;
+    fw = fw0[0] - fw;
+    for (i = 1; i <= jz; i++) fw += fw0[i];
+    y[1] = ih == 0 ? fw : -fw;
+  }
+  return n & 7;
+}
+
+constexpr double invpio2 = 6.36619772367581382433e-01;
+constexpr double pio2_1 = 1.57079632673412561417e+00, pio2_1t = 6.07710050650619224932e-11;
+constexpr double pio2_2 = 6.07710050630396597660e-11, pio2_2t = 2.02226624879595063154e-21;
+constexpr double pio2_3 = 2.02226624871116645580e-21, pio2_3t = 8.47842766036889956997e-32;
+constexpr std::int32_t npio2_hw[] = {
+    0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C,
+    0x4025FDBB, 0x402921FB, 0x402C463A, 0x402F6A7A, 0x4031475C, 0x4032D97C,
+    0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, 0x403AB41B, 0x403C463A,
+    0x403DD85A, 0x403F6A7A, 0x40407E4C, 0x4041475C, 0x4042106C, 0x4042D97C,
+    0x4043A28C, 0x40446B9C, 0x404534AC, 0x4045FDBB, 0x4046C6CB, 0x40478FDB,
+    0x404858EB, 0x404921FB,
+};
+int remPio2(double x, double* y) {
+  const std::int32_t hx = HI(x);
+  const std::int32_t ix = hx & 0x7fffffff;
+  if (ix <= 0x3fe921fb) { y[0] = x; y[1] = 0; return 0; }
+  if (ix < 0x4002d97c) {  // |x| < 3pi/4
+    if (hx > 0) {
+      double z = x - pio2_1;
+      if (ix != 0x3ff921fb) { y[0] = z - pio2_1t; y[1] = (z - y[0]) - pio2_1t; }
+      else { z -= pio2_2; y[0] = z - pio2_2t; y[1] = (z - y[0]) - pio2_2t; }
+      return 1;
+    }
+    double z = x + pio2_1;
+    if (ix != 0x3ff921fb) { y[0] = z + pio2_1t; y[1] = (z - y[0]) + pio2_1t; }
+    else { z += pio2_2; y[0] = z + pio2_2t; y[1] = (z - y[0]) + pio2_2t; }
+    return -1;
+  }
+  if (ix <= 0x413921fb) {  // |x| <= 2^19 pi/2
+    const double t = std::fabs(x);
+    const int n = toInt32(t * invpio2 + 0.5);
+    const double fn = n;
+    double r = t - fn * pio2_1;
+    double w = fn * pio2_1t;
+    if (n < 32 && ix != npio2_hw[n - 1]) {
+      y[0] = r - w;
+    } else {
+      const std::int32_t j = ix >> 20;
+      y[0] = r - w;
+      std::int32_t i = j - ((HI(y[0]) >> 20) & 0x7ff);
+      if (i > 16) {
+        const double t2 = r;
+        w = fn * pio2_2;
+        r = t2 - w;
+        w = fn * pio2_2t - ((t2 - r) - w);
+        y[0] = r - w;
+        i = j - ((HI(y[0]) >> 20) & 0x7ff);
+        if (i > 49) {
+          const double t3 = r;
+          w = fn * pio2_3;
+          r = t3 - w;
+          w = fn * pio2_3t - ((t3 - r) - w);
+          y[0] = r - w;
+        }
+      }
+    }
+    y[1] = (r - y[0]) - w;
+    if (hx < 0) { y[0] = -y[0]; y[1] = -y[1]; return -n; }
+    return n;
+  }
+  if (ix >= 0x7ff00000) { y[0] = y[1] = x - x; return 0; }
+  // Payne-Hanek
+  const std::int32_t lx = LO(x);
+  const int e0 = (ix >> 20) - 1046;
+  double z = setHi(0, static_cast<std::uint32_t>(ix - (e0 << 20)));
+  z = setLo(z, static_cast<std::uint32_t>(lx));
+  double tx[3] = {0, 0, 0};
+  for (int i = 0; i < 2; i++) { tx[i] = toInt32(z); z = (z - tx[i]) * two24; }
+  tx[2] = z;
+  int nx = 3;
+  while (nx > 0 && tx[nx - 1] == 0) nx--;
+  const int n = kernelRemPio2(tx, y, e0, nx);
+  if (hx < 0) { y[0] = -y[0]; y[1] = -y[1]; return -n; }
+  return n;
+}
+
+// ---- log (fdlibm e_log) ------------------------------------------------------
+constexpr double ln2_hi = 6.93147180369123816490e-01, ln2_lo = 1.90821492927058770002e-10;
+constexpr double Lg1 = 6.666666666666735130e-01, Lg2 = 3.999999999940941908e-01,
+                 Lg3 = 2.857142874366239149e-01, Lg4 = 2.222219843214978396e-01,
+                 Lg5 = 1.818357216161805012e-01, Lg6 = 1.531383769920937332e-01,
+                 Lg7 = 1.479819860511658591e-01;
+constexpr double two54 = 1.80143985094819840000e+16;
+
+// ---- exp (fdlibm e_exp) --------------------------------------------------------
+constexpr double halF[] = {0.5, -0.5};
+constexpr double o_threshold = 7.09782712893383973096e+02;
+constexpr double u_threshold = -7.45133219101941108420e+02;
+constexpr double invln2 = 1.44269504088896338700e+00;
+constexpr double ln2HI[] = {6.93147180369123816490e-01, -6.93147180369123816490e-01};
+constexpr double ln2LO[] = {1.90821492927058770002e-10, -1.90821492927058770002e-10};
+constexpr double P1 = 1.66666666666666019037e-01, P2 = -2.77777777770155933842e-03,
+                 P3 = 6.61375632143793436117e-05, P4 = -1.65339022054652515390e-06,
+                 P5 = 4.13813679705723846039e-08;
+constexpr double twom1000 = 9.33263618503218878990e-302;
+
+// ---- atan / atan2 (fdlibm s_atan / e_atan2) -----------------------------------
+constexpr double atanhi[] = {
+    4.63647609000806093515e-01, 7.85398163397448278999e-01,
+    9.82793723247329054082e-01, 1.57079632679489655800e+00,
+};
+constexpr double atanlo[] = {
+    2.26987774529616870924e-17, 3.06161699786838301793e-17,
+    1.39033110312309984516e-17, 6.12323399573676603587e-17,
+};
+constexpr double aT[] = {
+    3.33333333333329318027e-01, -1.99999999998764832476e-01, 1.42857142725034663711e-01,
+    -1.11111104054623557880e-01, 9.09088713343650656196e-02, -7.69187620504482999495e-02,
+    6.66107313738753120669e-02, -5.83357013379057348645e-02, 4.97687799461593236017e-02,
+    -3.65315727442169155270e-02, 1.62858201153657823623e-02,
+};
+constexpr double tiny_atan2 = 1.0e-300;
+constexpr double pi_o_4 = 7.8539816339744827900e-01, pi_o_2 = 1.5707963267948965580e+00;
+constexpr double detPi = 3.1415926535897931160e+00, pi_lo = 1.2246467991473531772e-16;
+
+// JS: (lx | -lx) >>> 31 — computed unsigned to avoid the INT32_MIN negation UB.
+inline std::int32_t nonZeroBit(std::int32_t lx) {
+  const std::uint32_t ulx = static_cast<std::uint32_t>(lx);
+  return static_cast<std::int32_t>((ulx | (0u - ulx)) >> 31);
+}
+
+}  // namespace
+
+double det_sin(double x) {
+  const std::int32_t ix = HI(x) & 0x7fffffff;
+  if (ix <= 0x3fe921fb) {
+    if (ix < 0x3e400000) { if (toInt32(x) == 0 && x == x) return x; }
+    return kernelSin(x, 0, 0);
+  }
+  if (ix >= 0x7ff00000) return x - x;
+  double y[2] = {0, 0};
+  const int n = remPio2(x, y);
+  switch (n & 3) {
+    case 0: return kernelSin(y[0], y[1], 1);
+    case 1: return kernelCos(y[0], y[1]);
+    case 2: return -kernelSin(y[0], y[1], 1);
+    default: return -kernelCos(y[0], y[1]);
+  }
+}
+
+double det_cos(double x) {
+  const std::int32_t ix = HI(x) & 0x7fffffff;
+  if (ix <= 0x3fe921fb) {
+    if (ix < 0x3e400000) return 1.0;
+    return kernelCos(x, 0);
+  }
+  if (ix >= 0x7ff00000) return x - x;
+  double y[2] = {0, 0};
+  const int n = remPio2(x, y);
+  switch (n & 3) {
+    case 0: return kernelCos(y[0], y[1]);
+    case 1: return -kernelSin(y[0], y[1], 1);
+    case 2: return -kernelCos(y[0], y[1]);
+    default: return kernelSin(y[0], y[1], 1);
+  }
+}
+
+double det_log(double x) {
+  std::int32_t hx = HI(x);
+  const std::int32_t lx = LO(x);
+  std::int32_t k = 0;
+  if (hx < 0x00100000) {
+    if (((hx & 0x7fffffff) | lx) == 0) return -HUGE_VAL;
+    if (hx < 0) return (x - x) / 0.0;
+    k -= 54;
+    x *= two54;
+    hx = HI(x);
+  }
+  if (hx >= 0x7ff00000) return x + x;
+  k += (hx >> 20) - 1023;
+  hx &= 0x000fffff;
+  const std::int32_t i = (hx + 0x95f64) & 0x100000;
+  x = setHi(x, static_cast<std::uint32_t>(hx | (i ^ 0x3ff00000)));
+  k += i >> 20;
+  const double f = x - 1.0;
+  if ((0x000fffff & (2 + hx)) < 3) {
+    if (f == 0) { if (k == 0) return 0; return k * ln2_hi + k * ln2_lo; }
+    const double R = f * f * (0.5 - 0.33333333333333333 * f);
+    if (k == 0) return f - R;
+    return k * ln2_hi - ((R - k * ln2_lo) - f);
+  }
+  const double s = f / (2.0 + f);
+  const double dk = k;
+  const double z = s * s;
+  const std::int32_t ii = hx - 0x6147a;
+  const double w = z * z;
+  const std::int32_t jj = 0x6b851 - hx;
+  const double t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
+  const double t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
+  const std::int32_t ij = ii | jj;
+  const double R = t2 + t1;
+  if (ij > 0) {
+    const double hfsq = 0.5 * f * f;
+    if (k == 0) return f - (hfsq - s * (hfsq + R));
+    return dk * ln2_hi - ((hfsq - (s * (hfsq + R) + dk * ln2_lo)) - f);
+  }
+  if (k == 0) return f - s * (f - R);
+  return dk * ln2_hi - ((s * (f - R) - dk * ln2_lo) - f);
+}
+
+double det_exp(double x) {
+  std::int32_t hx = HI(x);
+  const std::int32_t xsb = (hx >> 31) & 1;
+  hx &= 0x7fffffff;
+  if (hx >= 0x40862E42) {
+    if (hx >= 0x7ff00000) {
+      if (((hx & 0xfffff) | LO(x)) != 0) return x + x;
+      return xsb == 0 ? x : 0.0;
+    }
+    if (x > o_threshold) return HUGE_VAL;
+    if (x < u_threshold) return 0;
+  }
+  std::int32_t k = 0;
+  double hi = 0, lo = 0, t;
+  if (hx > 0x3fd62e42) {
+    if (hx < 0x3FF0A2B2) { hi = x - ln2HI[xsb]; lo = ln2LO[xsb]; k = 1 - xsb - xsb; }
+    else {
+      k = toInt32(invln2 * x + halF[xsb]);
+      t = k;
+      hi = x - t * ln2HI[0];
+      lo = t * ln2LO[0];
+    }
+    x = hi - lo;
+  } else if (hx < 0x3e300000) {
+    return 1.0 + x;
+  }
+  t = x * x;
+  const double c = x - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));
+  if (k == 0) return 1.0 - ((x * c) / (c - 2.0) - x);
+  double y = 1.0 - ((lo - (x * c) / (2.0 - c)) - hi);
+  if (k >= -1021) return setHi(y, static_cast<std::uint32_t>(HI(y) + (k << 20)));
+  y = setHi(y, static_cast<std::uint32_t>(HI(y) + ((k + 1000) << 20)));
+  return y * twom1000;
+}
+
+double det_atan(double x) {
+  const std::int32_t hx = HI(x);
+  const std::int32_t ix = hx & 0x7fffffff;
+  if (ix >= 0x44100000) {
+    if (ix > 0x7ff00000 || (ix == 0x7ff00000 && LO(x) != 0)) return x + x;
+    return hx > 0 ? atanhi[3] + atanlo[3] : -atanhi[3] - atanlo[3];
+  }
+  std::int32_t id;
+  if (ix < 0x3fdc0000) {
+    if (ix < 0x3e200000) return x;
+    id = -1;
+  } else {
+    x = std::fabs(x);
+    if (ix < 0x3ff30000) {
+      if (ix < 0x3fe60000) { id = 0; x = (2.0 * x - 1.0) / (2.0 + x); }
+      else { id = 1; x = (x - 1.0) / (x + 1.0); }
+    } else {
+      if (ix < 0x40038000) { id = 2; x = (x - 1.5) / (1.0 + 1.5 * x); }
+      else { id = 3; x = -1.0 / x; }
+    }
+  }
+  const double z = x * x;
+  const double w = z * z;
+  const double s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10])))));
+  const double s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9]))));
+  if (id < 0) return x - x * (s1 + s2);
+  const double zz = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x);
+  return hx < 0 ? -zz : zz;
+}
+
+double det_atan2(double y, double x) {
+  const std::int32_t hx = HI(x), lx = LO(x), hy = HI(y), ly = LO(y);
+  const std::int32_t ix = hx & 0x7fffffff, iy = hy & 0x7fffffff;
+  if ((ix | nonZeroBit(lx)) > 0x7ff00000 || (iy | nonZeroBit(ly)) > 0x7ff00000) return x + y;
+  if (hx == 0x3ff00000 && lx == 0) return det_atan(y);
+  const std::int32_t m = ((hy >> 31) & 1) | ((hx >> 30) & 2);
+  if ((iy | ly) == 0) {
+    switch (m) {
+      case 0: case 1: return y;
+      case 2: return detPi + tiny_atan2;
+      default: return -detPi - tiny_atan2;
+    }
+  }
+  if ((ix | lx) == 0) return hy < 0 ? -pi_o_2 - tiny_atan2 : pi_o_2 + tiny_atan2;
+  if (ix == 0x7ff00000) {
+    if (iy == 0x7ff00000) {
+      switch (m) {
+        case 0: return pi_o_4 + tiny_atan2;
+        case 1: return -pi_o_4 - tiny_atan2;
+        case 2: return 3.0 * pi_o_4 + tiny_atan2;
+        default: return -3.0 * pi_o_4 - tiny_atan2;
+      }
+    } else {
+      switch (m) {
+        case 0: return 0.0;
+        case 1: return -0.0;
+        case 2: return detPi + tiny_atan2;
+        default: return -detPi - tiny_atan2;
+      }
+    }
+  }
+  if (iy == 0x7ff00000) return hy < 0 ? -pi_o_2 - tiny_atan2 : pi_o_2 + tiny_atan2;
+  const std::int32_t k = (iy - ix) >> 20;
+  double z;
+  if (k > 60) z = pi_o_2 + 0.5 * pi_lo;
+  else if (hx < 0 && k < -60) z = 0.0;
+  else z = det_atan(std::fabs(y / x));
+  switch (m) {
+    case 0: return z;
+    case 1: return -z;
+    case 2: return detPi - (z - pi_lo);
+    default: return (z - pi_lo) - detPi;
+  }
+}
+
+double det_hypot2(double x, double y) {
+  std::int32_t ha = HI(x) & 0x7fffffff;
+  std::int32_t hb = HI(y) & 0x7fffffff;
+  double a, b;
+  if (hb > ha) { a = y; b = x; const std::int32_t j = ha; ha = hb; hb = j; }
+  else { a = x; b = y; }
+  a = std::fabs(a);
+  b = std::fabs(b);
+  if (ha - hb > 0x3c00000) return a + b;
+  std::int32_t k = 0;
+  if (ha > 0x5f300000) {
+    if (ha >= 0x7ff00000) {
+      double w = std::fabs(x + 0.0) - std::fabs(y + 0.0);
+      if (((ha & 0xfffff) | LO(a)) == 0) w = a;
+      if (((hb ^ 0x7ff00000) | LO(b)) == 0) w = b;
+      return w;
+    }
+    ha -= 0x25800000;
+    hb -= 0x25800000;
+    k += 600;
+    a = setHi(a, static_cast<std::uint32_t>(ha));
+    b = setHi(b, static_cast<std::uint32_t>(hb));
+  }
+  if (hb < 0x20b00000) {
+    if (hb <= 0x000fffff) {
+      if ((hb | LO(b)) == 0) return a;
+      const double scale = fromWords(0x7fd00000u, 0u);
+      b *= scale;
+      a *= scale;
+      k -= 1022;
+      ha = HI(a);
+      hb = HI(b);
+    } else {
+      ha += 0x25800000;
+      hb += 0x25800000;
+      k -= 600;
+      a = setHi(a, static_cast<std::uint32_t>(ha));
+      b = setHi(b, static_cast<std::uint32_t>(hb));
+    }
+  }
+  double w = a - b;
+  if (w > b) {
+    const double t1 = fromWords(static_cast<std::uint32_t>(ha), 0u);
+    const double t2 = a - t1;
+    w = std::sqrt(t1 * t1 - (b * (-b) - t2 * (a + t1)));
+  } else {
+    a = a + a;
+    const double y1 = fromWords(static_cast<std::uint32_t>(hb), 0u);
+    const double y2 = b - y1;
+    const double t1 = fromWords(static_cast<std::uint32_t>(ha + 0x00100000), 0u);
+    const double t2 = a - t1;
+    w = std::sqrt(t1 * y1 - (w * (-w) - (t1 * y2 + t2 * b)));
+  }
+  if (k != 0) {
+    const double scale = setHi(1.0, static_cast<std::uint32_t>(HI(1.0) + (k << 20)));
+    return scale * w;
+  }
+  return w;
+}
+
+}  // namespace rundot::detmath