@the-situation/core 0.5.0-alpha.0

package/dist/math/sq128.js

@@ -0,0 +1,611 @@
+/**
+ * SQ128x128 fixed-point number type.
+ *
+ * An immutable fixed-point number with 128 bits of integer precision
+ * and 128 bits of fractional precision.
+ *
+ * ## Range
+ * - Minimum: -2^128 ≈ -3.4×10³⁸
+ * - Maximum: 2^128 - 2^-128 ≈ 3.4×10³⁸
+ *
+ * ## Design
+ * - Immutable: all operations return new instances
+ * - Safe: operations return null on overflow/underflow
+ * - Compatible: toRaw()/fromRaw() for Starknet serialization
+ *
+ * @module
+ */
+import { isValidSQ128x128Raw, MAX_LIMB, NEG_ONE_RAW, ONE_RAW, ZERO_RAW, } from './sq128-raw';
+/** 2^64 for limb arithmetic */
+const LIMB_BITS = 64n;
+/** 2^128 - the scaling factor for the fractional part */
+const SCALE = 1n << 128n;
+/** Maximum magnitude (2^256 - 1) */
+const MAX_MAG = (1n << 256n) - 1n;
+/**
+ * Splits a 256-bit magnitude into four 64-bit limbs.
+ */
+function toLimbs(mag) {
+    return {
+        limb0: mag & MAX_LIMB,
+        limb1: (mag >> LIMB_BITS) & MAX_LIMB,
+        limb2: (mag >> 128n) & MAX_LIMB,
+        limb3: mag >> 192n,
+    };
+}
+/**
+ * Reconstructs magnitude from four 64-bit limbs.
+ */
+function fromLimbs(limb0, limb1, limb2, limb3) {
+    return limb0 + (limb1 << LIMB_BITS) + (limb2 << 128n) + (limb3 << 192n);
+}
+/**
+ * An immutable signed Q128.128 fixed-point number.
+ */
+export class SQ128x128 {
+    magnitude;
+    negative;
+    constructor(magnitude, negative) {
+        this.magnitude = magnitude;
+        this.negative = negative;
+    }
+    /**
+     * Creates an SQ128x128 from a JavaScript number.
+     *
+     * @param value - The number to convert
+     * @returns The SQ128x128 value, or null if overflow/invalid
+     */
+    static fromNumber(value) {
+        if (!Number.isFinite(value)) {
+            return null;
+        }
+        const negative = value < 0;
+        const absValue = Math.abs(value);
+        // Separate integer and fractional parts for precise encoding.
+        // Directly multiplying by 2^128 loses precision because JavaScript
+        // numbers only have ~53 bits of mantissa precision.
+        const intPart = Math.floor(absValue);
+        const fracPart = absValue - intPart;
+        // Integer part contribution: intPart * 2^128 (exact for integers up to 2^53)
+        const intContrib = BigInt(intPart) * SCALE;
+        // Fractional part contribution: fracPart * 2^128
+        // Split into two 64-bit multiplications for better precision.
+        // fracPart * 2^64 fits in JavaScript's Number precision for fracPart < 1
+        const HALF_SCALE = 1n << 64n;
+        const fracScaled = BigInt(Math.round(fracPart * Number(HALF_SCALE)));
+        const fracContrib = fracScaled * HALF_SCALE;
+        const magnitude = intContrib + fracContrib;
+        if (magnitude > MAX_MAG) {
+            return null;
+        }
+        return new SQ128x128(magnitude, negative && magnitude !== 0n);
+    }
+    /**
+     * Creates an SQ128x128 from a bigint integer value.
+     *
+     * @param value - The integer to convert
+     * @returns The SQ128x128 value, or null if overflow
+     */
+    static fromBigInt(value) {
+        const negative = value < 0n;
+        const absValue = negative ? -value : value;
+        const scaled = absValue * SCALE;
+        if (scaled > MAX_MAG) {
+            return null;
+        }
+        return new SQ128x128(scaled, negative && scaled !== 0n);
+    }
+    /**
+     * Creates an SQ128x128 from a raw representation.
+     *
+     * @param raw - The raw limb representation
+     * @returns The SQ128x128 value, or null if invalid
+     */
+    static fromRaw(raw) {
+        if (!isValidSQ128x128Raw(raw)) {
+            return null;
+        }
+        const magnitude = fromLimbs(raw.limb0, raw.limb1, raw.limb2, raw.limb3);
+        return new SQ128x128(magnitude, raw.neg && magnitude !== 0n);
+    }
+    /**
+     * Converts to a raw representation for Starknet serialization.
+     */
+    toRaw() {
+        const { limb0, limb1, limb2, limb3 } = toLimbs(this.magnitude);
+        return { limb0, limb1, limb2, limb3, neg: this.negative };
+    }
+    /**
+     * Converts to a JavaScript number.
+     *
+     * Note: May lose precision for very large or very small values.
+     */
+    toNumber() {
+        const value = Number(this.magnitude) / Number(SCALE);
+        return this.negative ? -value : value;
+    }
+    /**
+     * Returns the underlying scaled magnitude as a bigint.
+     */
+    toScaledBigInt() {
+        return this.negative ? -this.magnitude : this.magnitude;
+    }
+    // ============================================================================
+    // Comparison
+    // ============================================================================
+    /**
+     * Tests equality with another SQ128x128.
+     */
+    eq(other) {
+        return this.magnitude === other.magnitude && this.negative === other.negative;
+    }
+    /**
+     * Tests if this value is less than another.
+     */
+    lt(other) {
+        if (this.negative !== other.negative) {
+            return this.negative;
+        }
+        if (this.negative) {
+            return this.magnitude > other.magnitude;
+        }
+        return this.magnitude < other.magnitude;
+    }
+    /**
+     * Tests if this value is greater than another.
+     */
+    gt(other) {
+        return other.lt(this);
+    }
+    /**
+     * Tests if this value is less than or equal to another.
+     */
+    lte(other) {
+        return this.eq(other) || this.lt(other);
+    }
+    /**
+     * Tests if this value is greater than or equal to another.
+     */
+    gte(other) {
+        return this.eq(other) || this.gt(other);
+    }
+    // ============================================================================
+    // Predicates
+    // ============================================================================
+    /**
+     * Returns true if this value is zero.
+     */
+    isZero() {
+        return this.magnitude === 0n;
+    }
+    /**
+     * Returns true if this value is negative.
+     */
+    isNegative() {
+        return this.negative;
+    }
+    /**
+     * Returns true if this value is positive (greater than zero).
+     */
+    isPositive() {
+        return !this.negative && this.magnitude > 0n;
+    }
+    // ============================================================================
+    // Arithmetic
+    // ============================================================================
+    /**
+     * Adds another SQ128x128 to this value.
+     *
+     * @returns The sum, or null on overflow
+     */
+    add(other) {
+        const a = this.toScaledBigInt();
+        const b = other.toScaledBigInt();
+        const result = a + b;
+        const negative = result < 0n;
+        const magnitude = negative ? -result : result;
+        if (magnitude > MAX_MAG) {
+            return null;
+        }
+        return new SQ128x128(magnitude, negative && magnitude !== 0n);
+    }
+    /**
+     * Subtracts another SQ128x128 from this value.
+     *
+     * @returns The difference, or null on overflow
+     */
+    sub(other) {
+        const a = this.toScaledBigInt();
+        const b = other.toScaledBigInt();
+        const result = a - b;
+        const negative = result < 0n;
+        const magnitude = negative ? -result : result;
+        if (magnitude > MAX_MAG) {
+            return null;
+        }
+        return new SQ128x128(magnitude, negative && magnitude !== 0n);
+    }
+    /**
+     * Multiplies by another SQ128x128.
+     *
+     * @returns The product (rounded toward zero), or null on overflow
+     */
+    mul(other) {
+        const product = this.magnitude * other.magnitude;
+        // Scale back down: divide by SCALE (rounding toward zero)
+        const scaled = product / SCALE;
+        if (scaled > MAX_MAG) {
+            return null;
+        }
+        const negative = this.negative !== other.negative;
+        return new SQ128x128(scaled, negative && scaled !== 0n);
+    }
+    /**
+     * Divides by another SQ128x128.
+     *
+     * @returns The quotient (rounded toward zero), or null on division by zero/overflow
+     */
+    div(other) {
+        if (other.magnitude === 0n) {
+            return null;
+        }
+        // Scale up before dividing to maintain precision
+        const scaled = (this.magnitude * SCALE) / other.magnitude;
+        if (scaled > MAX_MAG) {
+            return null;
+        }
+        const negative = this.negative !== other.negative;
+        return new SQ128x128(scaled, negative && scaled !== 0n);
+    }
+    /**
+     * Returns the negation of this value.
+     *
+     * @returns The negated value, or null if negating MIN would overflow
+     */
+    neg() {
+        if (this.magnitude === 0n) {
+            return new SQ128x128(0n, false);
+        }
+        return new SQ128x128(this.magnitude, !this.negative);
+    }
+    /**
+     * Returns the absolute value.
+     */
+    abs() {
+        return new SQ128x128(this.magnitude, false);
+    }
+    /**
+     * Computes the square of this value (x * x).
+     *
+     * More efficient than mul(this) as we can skip sign computation.
+     *
+     * @returns The squared value, or null on overflow
+     */
+    pow2() {
+        const product = this.magnitude * this.magnitude;
+        const scaled = product / SCALE;
+        if (scaled > MAX_MAG) {
+            return null;
+        }
+        // Square is always non-negative
+        return new SQ128x128(scaled, false);
+    }
+    /**
+     * Computes the floor (integer part) of the absolute value.
+     *
+     * @returns The integer part as a number
+     */
+    floor() {
+        // The integer part is stored in limb2 and limb3 (bits 128-255)
+        const integerPart = this.magnitude >> 128n;
+        return Number(integerPart);
+    }
+    /**
+     * Computes the fractional part (value - floor).
+     *
+     * @returns The fractional part as SQ128x128
+     */
+    frac() {
+        // Mask to keep only the lower 128 bits (fractional part)
+        const fracMask = (1n << 128n) - 1n;
+        const fracMagnitude = this.magnitude & fracMask;
+        return new SQ128x128(fracMagnitude, false);
+    }
+    /**
+     * Computes exp(-|self|) for this value.
+     *
+     * Uses range reduction: exp(-u) = exp(-k) * exp(-(u mod 1))
+     * where k = floor(u) and the fractional part uses Taylor series.
+     *
+     * @returns The exponential value, or null if computation fails
+     */
+    expNeg() {
+        // For negative values, exp(-negative) = exp(positive) > 1
+        // Clamp to 1 since exp(x) > 1 for x > 0
+        if (this.negative) {
+            return ONE;
+        }
+        // For very large values, exp(-u) is effectively zero
+        const absValue = this.abs();
+        if (absValue.floor() >= EXP_NEG_TABLE.length) {
+            return ZERO;
+        }
+        // Range reduction: find k = floor(u)
+        const k = absValue.floor();
+        const expNegK = EXP_NEG_TABLE[k];
+        if (!expNegK || expNegK.isZero()) {
+            return ZERO;
+        }
+        // Get fractional part: r = u - k, where r in [0, 1)
+        const r = absValue.frac();
+        // Taylor series for exp(-r) where r in [0, 1]
+        const expNegR = taylorExpNegSmall(r);
+        if (!expNegR) {
+            return null;
+        }
+        // exp(-u) = exp(-k) * exp(-r)
+        return expNegK.mul(expNegR);
+    }
+    /**
+     * Computes exp(-x²/2) for this value.
+     *
+     * This is a common operation in normal distribution computations.
+     *
+     * @returns The exponential value, or null if computation fails
+     */
+    expNegHalfSquared() {
+        const xSquared = this.pow2();
+        if (!xSquared) {
+            return null;
+        }
+        const half = HALF;
+        const u = xSquared.mul(half);
+        if (!u) {
+            return null;
+        }
+        return u.expNeg();
+    }
+}
+// ============================================================================
+// Constants
+// ============================================================================
+/** Zero (0.0) */
+export const ZERO = SQ128x128.fromRaw(ZERO_RAW);
+/** Half (0.5) */
+export const HALF = SQ128x128.fromRaw({
+    limb0: 0n,
+    limb1: 0x8000000000000000n,
+    limb2: 0n,
+    limb3: 0n,
+    neg: false,
+});
+/** Two (2.0) */
+export const TWO = SQ128x128.fromRaw({
+    limb0: 0n,
+    limb1: 0n,
+    limb2: 2n,
+    limb3: 0n,
+    neg: false,
+});
+/** One (1.0) */
+export const ONE = SQ128x128.fromRaw(ONE_RAW);
+/** Negative one (-1.0) */
+export const NEG_ONE = SQ128x128.fromRaw(NEG_ONE_RAW);
+/** Minimum value - practical limit for testing (using bigint for precision) */
+export const MIN = SQ128x128.fromBigInt(-(1n << 64n));
+/** Maximum value - practical limit for testing (using bigint for precision) */
+export const MAX = SQ128x128.fromBigInt((1n << 64n) - 1n);
+// ============================================================================
+// Math Constants for PDF Computation
+// ============================================================================
+/**
+ * 1/√(2π) ≈ 0.3989422804014327
+ *
+ * This constant is used in normal distribution PDF computation.
+ */
+export const INV_SQRT_2PI = SQ128x128.fromRaw({
+    limb0: 0x3f2cf1402eae38bfn,
+    limb1: 0x662114cf50d94234n,
+    limb2: 0n,
+    limb3: 0n,
+    neg: false,
+});
+/**
+ * Precomputed exp(-k) lookup table for k = 0..10.
+ *
+ * For k > 10, exp(-k) < 2e-5, effectively zero for our precision.
+ */
+export const EXP_NEG_TABLE = [
+    // exp(-0) = 1.0
+    SQ128x128.fromRaw({ limb0: 0n, limb1: 0n, limb2: 1n, limb3: 0n, neg: false }),
+    // exp(-1) ≈ 0.36787944117144232
+    SQ128x128.fromRaw({
+        limb0: 0xb4c7e2563b8a0390n,
+        limb1: 0x5e2d58d8b3bcdf1an,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-2) ≈ 0.13533528323661269
+    SQ128x128.fromRaw({
+        limb0: 0x5fc21ca1f0ead89bn,
+        limb1: 0x22a5dc02c1e4ebd2n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-3) ≈ 0.04978706836786394
+    SQ128x128.fromRaw({
+        limb0: 0x89571c88d8a3eacdn,
+        limb1: 0x0cbfbf00de0c6c61n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-4) ≈ 0.01831563888873418
+    SQ128x128.fromRaw({
+        limb0: 0x8b3e5e37fb91925en,
+        limb1: 0x04b08b4b7f06c6f9n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-5) ≈ 0.00673794699908547
+    SQ128x128.fromRaw({
+        limb0: 0xf4fce765679d0f2cn,
+        limb1: 0x01ba3fa6a10b78dcn,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-6) ≈ 0.00247875217666636
+    SQ128x128.fromRaw({
+        limb0: 0x1b1af20c7dc7ab1dn,
+        limb1: 0x00a2515f16c37668n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-7) ≈ 0.00091188196555452
+    SQ128x128.fromRaw({
+        limb0: 0x9c51bea3e0c3a7ecn,
+        limb1: 0x003bc8fa73692c09n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-8) ≈ 0.00033546262790251
+    SQ128x128.fromRaw({
+        limb0: 0xa5f10cf3b5cddb19n,
+        limb1: 0x0015f41e9c1b12abn,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-9) ≈ 0.00012340980408668
+    SQ128x128.fromRaw({
+        limb0: 0x17bef44e8b2d2e80n,
+        limb1: 0x00081458daa6a0c5n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // exp(-10) ≈ 0.00004539992976248
+    SQ128x128.fromRaw({
+        limb0: 0xe62e6db6b0d2efdfn,
+        limb1: 0x0002f7a9b11f8cden,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+];
+/**
+ * Taylor coefficients for exp(-r) using Horner's method.
+ *
+ * exp(-r) = 1 + r*(-1 + r*(1/2 + r*(-1/6 + r*(1/24 + r*(-1/120 + r/720)))))
+ *
+ * Coefficients: c6 = 1/720, c5 = -1/120, c4 = 1/24, c3 = -1/6, c2 = 1/2, c1 = -1
+ */
+const TAYLOR_COEFFS = {
+    // c6 = 1/720 ≈ 0.00138888888888889
+    c6: SQ128x128.fromRaw({
+        limb0: 0n,
+        limb1: 0x5b05b05b05b05cn,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // c5 = -1/120 ≈ -0.00833333333333333
+    c5: SQ128x128.fromRaw({
+        limb0: 0n,
+        limb1: 0x222222222222220n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: true,
+    }),
+    // c4 = 1/24 ≈ 0.04166666666666667
+    c4: SQ128x128.fromRaw({
+        limb0: 0n,
+        limb1: 0xaaaaaaaaaaaaa80n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: false,
+    }),
+    // c3 = -1/6 ≈ -0.16666666666666667
+    c3: SQ128x128.fromRaw({
+        limb0: 0n,
+        limb1: 0x2aaaaaaaaaaaaa00n,
+        limb2: 0n,
+        limb3: 0n,
+        neg: true,
+    }),
+    // c2 = 1/2 = 0.5
+    c2: HALF,
+    // c1 = -1
+    c1: NEG_ONE,
+};
+/**
+ * Taylor series for exp(-r) where r in [0, 1].
+ *
+ * Uses Horner's method with precomputed coefficients for numerical stability.
+ * exp(-r) = 1 + r*(-1 + r*(1/2 + r*(-1/6 + r*(1/24 + r*(-1/120 + r/720)))))
+ *
+ * @param r - The fractional part in [0, 1)
+ * @returns The approximation of exp(-r), clamped to [0, 1]
+ */
+function taylorExpNegSmall(r) {
+    const { c6, c5, c4, c3, c2, c1 } = TAYLOR_COEFFS;
+    // Horner's method: start from innermost coefficient
+    let result = c6;
+    // c5 + r * result
+    let term = r.mul(result);
+    if (!term)
+        return null;
+    result = c5.add(term);
+    if (!result)
+        return null;
+    // c4 + r * result
+    term = r.mul(result);
+    if (!term)
+        return null;
+    result = c4.add(term);
+    if (!result)
+        return null;
+    // c3 + r * result
+    term = r.mul(result);
+    if (!term)
+        return null;
+    result = c3.add(term);
+    if (!result)
+        return null;
+    // c2 + r * result
+    term = r.mul(result);
+    if (!term)
+        return null;
+    result = c2.add(term);
+    if (!result)
+        return null;
+    // c1 + r * result
+    term = r.mul(result);
+    if (!term)
+        return null;
+    result = c1.add(term);
+    if (!result)
+        return null;
+    // 1 + r * result
+    term = r.mul(result);
+    if (!term)
+        return null;
+    result = ONE.add(term);
+    if (!result)
+        return null;
+    // Clamp to [0, 1] for safety
+    if (result.isNegative()) {
+        return ZERO;
+    }
+    if (result.gt(ONE)) {
+        return ONE;
+    }
+    return result;
+}
+//# sourceMappingURL=sq128.js.map

package/dist/math/sq128.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sq128.js","sourceRoot":"","sources":["../../src/math/sq128.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@the-situation/core",
+  "version": "0.5.0-alpha.0",
+  "description": "Core types, math primitives, and Effect error hierarchy for The Situation SDK",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -b",
+    "test": "bun test src/ 2>/dev/null || true",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
+  },
+  "dependencies": {
+    "effect": "^3.12.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/bun": "^1.1.0"
+  },
+  "license": "MIT"
+}