@cortex-js/compute-engine 0.57.0 → 0.59.0

package/dist/numerics.umd.cjs

@@ -1,4 +1,4 @@
-/** Numerics 0.57.0 */
+/** Numerics 0.59.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Numerics = {}));})(this, (function (exports) { 'use strict';
 var Numerics = (() => {
   var __defProp = Object.defineProperty;
@@ -317,6 +317,7 @@ var Numerics = (() => {
     return sum;
   }
   function fpln(x, scale) {
+    if (x <= 0n) throw new RangeError("fpln: input must be positive");
     if (x === scale) return 0n;
     const xNum = Number(x);
     const scaleNum = Number(scale);
@@ -966,9 +967,11 @@ var Numerics = (() => {
       if (Number.isFinite(thisExp) && Number.isFinite(otherExp)) {
         if (other.significand === 0n) return _BigDecimal.NAN;
         if (this.significand === 0n) return fromRaw(0n, 0);
-        return this.sub(this.div(other).trunc().mul(other)).toPrecision(
-          _BigDecimal.precision
-        );
+        const ediff = thisExp - otherExp;
+        const num = ediff >= 0 ? this.significand * pow10(ediff) : this.significand;
+        const den = ediff >= 0 ? other.significand : other.significand * pow10(-ediff);
+        const q = num / den;
+        return this.sub(fromRaw(q, 0).mul(other));
       }
       if (thisExp !== thisExp || otherExp !== otherExp) return _BigDecimal.NAN;
       if (!Number.isFinite(thisExp)) return _BigDecimal.NAN;
@@ -1013,7 +1016,10 @@ var Numerics = (() => {
           return this.pow(n.neg()).inv();
         }
         const absSig = this.significand < 0n ? -this.significand : this.significand;
-        const thisLog10 = bigintDigits(absSig) + this.exponent;
+        const sigDigits = bigintDigits(absSig);
+        const dropped = sigDigits > 15 ? sigDigits - 15 : 0;
+        const lead = dropped > 0 ? Number(absSig / 10n ** BigInt(dropped)) : Number(absSig);
+        const thisLog10 = Math.log10(lead) + dropped + this.exponent;
         const resultLog10 = Number(expValue) * thisLog10;
         if (resultLog10 > 9e15) {
           return this.significand < 0n && expValue % 2n !== 0n ? _BigDecimal.NEGATIVE_INFINITY : _BigDecimal.POSITIVE_INFINITY;
@@ -1046,7 +1052,19 @@ var Numerics = (() => {
         return _BigDecimal.POSITIVE_INFINITY;
       }
       if (this.significand < 0n) return _BigDecimal.NAN;
-      return n.mul(this.ln()).exp();
+      const baseSig = this.significand;
+      const decExpBase = this.exponent + bigintDigits(baseSig) - 1;
+      const nSig = n.significand < 0n ? -n.significand : n.significand;
+      const decExpN = n.exponent + bigintDigits(nSig) - 1;
+      const argMag = decExpN + Math.log10(Math.abs(decExpBase) * 2.303 + 3) + 1;
+      const extra = Math.min(20, Math.max(2, Math.ceil(argMag) + 2));
+      const savedPrec = _BigDecimal.precision;
+      _BigDecimal.precision = savedPrec + extra;
+      try {
+        return n.mul(this.ln()).exp().toPrecision(savedPrec);
+      } finally {
+        _BigDecimal.precision = savedPrec;
+      }
     }
     // ---------- Conversion methods ----------
     /** Convert to a JavaScript number. May lose precision for large values. */
@@ -1287,6 +1305,20 @@ var Numerics = (() => {
     const sig = negative ? -absFp : absFp;
     return fromRaw(sig, resultExp);
   }
+  function decimalExponent(x) {
+    const sig = x.significand < 0n ? -x.significand : x.significand;
+    return x.exponent + bigintDigits(sig) - 1;
+  }
+  var MAX_SAFE_EXPONENT = BigInt(Number.MAX_SAFE_INTEGER);
+  var _ln10Fp = null;
+  var _ln10Scale = null;
+  function ln10Fixed(scale) {
+    if (_ln10Scale !== scale) {
+      _ln10Fp = fpln(10n * scale, scale);
+      _ln10Scale = scale;
+    }
+    return _ln10Fp;
+  }
   BigDecimal.prototype.sqrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
@@ -1297,9 +1329,13 @@ var Numerics = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 2);
+    const m = fromRaw(this.significand, this.exponent - 2 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const sqrtFp = fpsqrt(fp, scale);
-    return fromFixedPoint(sqrtFp, scale, targetPrec);
+    const root = fromFixedPoint(sqrtFp, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.prototype.cbrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -1313,10 +1349,13 @@ var Numerics = (() => {
     }
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 3);
+    const m = fromRaw(this.significand, this.exponent - 3 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const C = fp * scale * scale;
     let x;
-    const numVal = this.toNumber();
+    const numVal = m.toNumber();
     const scaleNum = Number(scale);
     if (Number.isFinite(numVal) && numVal > 0 && Number.isFinite(scaleNum)) {
       const approx = Math.cbrt(numVal);
@@ -1345,7 +1384,8 @@ var Numerics = (() => {
       const diffNext = bigintAbs(next * next * next - C);
       if (diffNext < diffX) x = next;
     }
-    return fromFixedPoint(x, scale, targetPrec);
+    const root = fromFixedPoint(x, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.sqrt = function(x) {
     return x.sqrt();
@@ -1360,11 +1400,27 @@ var Numerics = (() => {
       return BigDecimal.ZERO;
     }
     if (this.isZero()) return BigDecimal.ONE;
+    if (decimalExponent(this) >= 17)
+      return this.significand > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const expFp = fpexp(fp, scale);
-    return fromFixedPoint(expFp, scale, targetPrec);
+    const absSig = this.significand < 0n ? -this.significand : this.significand;
+    const magnitude = Math.max(0, this.exponent + bigintDigits(absSig));
+    const workingPrec = targetPrec + 20 + magnitude;
+    const [xFp, scale] = toFixedPoint(this, workingPrec);
+    const l10 = ln10Fixed(scale);
+    let k = xFp / l10;
+    let rFp = xFp - k * l10;
+    if (rFp < 0n) {
+      k -= 1n;
+      rFp += l10;
+    }
+    if (k > MAX_SAFE_EXPONENT || k < -MAX_SAFE_EXPONENT)
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    const expR = fromFixedPoint(fpexp(rFp, scale), scale, targetPrec);
+    const newExp = expR.exponent + Number(k);
+    if (!Number.isSafeInteger(newExp))
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    return fromRaw(expR.significand, newExp);
   };
   BigDecimal.prototype.ln = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -1376,10 +1432,16 @@ var Numerics = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     if (this.eq(1)) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const lnFp = fpln(fp, scale);
-    return fromFixedPoint(lnFp, scale, targetPrec);
+    const sig = this.significand;
+    const digits = bigintDigits(sig);
+    const e = this.exponent + digits - 1;
+    const m = fromRaw(sig, -(digits - 1));
+    const eDigits = Math.abs(e).toString().length;
+    const workingPrec = targetPrec + 20 + eDigits;
+    const [mFp, scale] = toFixedPoint(m, workingPrec);
+    const l10 = ln10Fixed(scale);
+    const resultFp = fpln(mFp, scale) + BigInt(e) * l10;
+    return fromFixedPoint(resultFp, scale, targetPrec);
   };
   BigDecimal.prototype.log = function(base) {
     const b = base instanceof BigDecimal ? base : new BigDecimal(base);
@@ -1399,7 +1461,10 @@ var Numerics = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp] = fpsincos(fp, scale);
     return fromFixedPoint(sinFp, scale, targetPrec);
@@ -1410,6 +1475,8 @@ var Numerics = (() => {
     if (this.isZero()) return BigDecimal.ONE;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [, cosFp] = fpsincos(fp, scale);
     return fromFixedPoint(cosFp, scale, targetPrec);
@@ -1419,7 +1486,10 @@ var Numerics = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp, cosFp] = fpsincos(fp, scale);
     if (cosFp === 0n) {
@@ -1437,7 +1507,9 @@ var Numerics = (() => {
       return piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const atanFp = fpatan(fp, scale);
     return fromFixedPoint(atanFp, scale, targetPrec);
@@ -1454,7 +1526,9 @@ var Numerics = (() => {
       return this.significand > 0n ? piHalf : piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 20;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 20 + (e < 0 ? -e : 0);
     const [xFp, scale] = toFixedPoint(this, workingPrec);
     const x2 = fpmul(xFp, xFp, scale);
     const oneMinusX2 = scale - x2;
@@ -1517,6 +1591,23 @@ var Numerics = (() => {
       if (this.significand > 0n) return BigDecimal.POSITIVE_INFINITY;
       return BigDecimal.NEGATIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const expX2 = this.exp();
+        return expX2.sub(expX2.inv()).div(BigDecimal.TWO).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3)) {
+      const h = this.abs().exp().div(BigDecimal.TWO);
+      return this.significand > 0n ? h : h.neg();
+    }
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.sub(expNegX).div(BigDecimal.TWO);
@@ -1527,6 +1618,9 @@ var Numerics = (() => {
     if (!this.isFinite()) {
       return BigDecimal.POSITIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.abs().exp().div(BigDecimal.TWO);
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.add(expNegX).div(BigDecimal.TWO);
@@ -1538,6 +1632,21 @@ var Numerics = (() => {
       if (this.significand > 0n) return BigDecimal.ONE;
       return BigDecimal.NEGATIVE_ONE;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const exp2x2 = this.mul(BigDecimal.TWO).exp();
+        return exp2x2.sub(BigDecimal.ONE).div(exp2x2.add(BigDecimal.ONE)).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.significand > 0n ? BigDecimal.ONE : BigDecimal.NEGATIVE_ONE;
     const exp2x = this.mul(BigDecimal.TWO).exp();
     return exp2x.sub(BigDecimal.ONE).div(exp2x.add(BigDecimal.ONE));
   };
@@ -1624,9 +1733,7 @@ var Numerics = (() => {
     if (typeof a === "bigint") return a;
     if (typeof a === "number") {
       if (!Number.isInteger(a)) return null;
-      if (a >= Number.MAX_SAFE_INTEGER && a <= Number.MAX_SAFE_INTEGER)
-        return BigInt(a);
-      return bigint(a.toString());
+      return BigInt(a);
     }
     if (a instanceof BigDecimal) {
       if (!a.isInteger()) return null;
@@ -2907,7 +3014,8 @@ var Numerics = (() => {
         [1, 5],
         [1, 6],
         [1, 7],
-        [1, 8],
+        [2, 2],
+        // √8 = 2√2
         [3, 1],
         [1, 10],
         [1, 11],
@@ -2919,7 +3027,8 @@ var Numerics = (() => {
         [1, 17],
         [3, 2],
         [1, 19],
-        [1, 20]
+        [2, 5]
+        // √20 = 2√5
       ][n];
       if (result) return result;
     }
@@ -2944,7 +3053,8 @@ var Numerics = (() => {
   }
   function lcm(a, b) {
     if (a === 0 || b === 0) return 0;
-    const res = BigInt(a) * BigInt(b) / BigInt(gcd(a, b));
+    let res = BigInt(a) * BigInt(b) / BigInt(gcd(a, b));
+    if (res < 0n) res = -res;
     return Number(res);
   }
   function factorial(n) {
@@ -3499,12 +3609,23 @@ var Numerics = (() => {
     "error",
     ...EXPRESSION_TYPES
   ];
+  var NUMERIC_TYPES_SET = new Set(
+    NUMERIC_TYPES
+  );
+  var COLLECTION_TYPES_SET = new Set(
+    COLLECTION_TYPES
+  );
+  var SCALAR_TYPES_SET = new Set(
+    SCALAR_TYPES
+  );
+  var PRIMITIVE_TYPES_SET = new Set(
+    PRIMITIVE_TYPES
+  );
   function isValidType(t) {
-    if (typeof t === "string")
-      return PRIMITIVE_TYPES.includes(t);
+    if (typeof t === "string") return PRIMITIVE_TYPES_SET.has(t);
     if (typeof t !== "object") return false;
     if (!("kind" in t)) return false;
-    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "function" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
+    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "value" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "symbol" || t.kind === "expression" || t.kind === "numeric" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
   }
 
   // src/common/type/lexer.ts
@@ -4214,19 +4335,13 @@ var Numerics = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -4267,19 +4382,13 @@ var Numerics = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -4310,16 +4419,30 @@ var Numerics = (() => {
       return this.createNode("tensor", { elementType });
     }
     parseDimensions() {
-      const dimensions = [];
       const firstDim = this.parseDimension();
       if (!firstDim) return void 0;
-      dimensions.push(firstDim);
-      while (this.match("x")) {
-        const dim = this.parseDimension();
-        if (!dim) {
-          this.error("Expected dimension after x");
+      const dimensions = [firstDim];
+      for (; ; ) {
+        const tok = this.current;
+        if (tok.type === "IDENTIFIER" && /^(x\d+)+$/.test(tok.value)) {
+          this.advance();
+          for (const m of tok.value.match(/x(\d+)/g))
+            dimensions.push(
+              this.createNode("dimension", {
+                size: parseInt(m.slice(1))
+              })
+            );
+        } else if (tok.type === "IDENTIFIER" && tok.value === "x") {
+          const next = this.lexer.peekToken();
+          if (next.type !== "NUMBER_LITERAL" && next.type !== "?")
+            this.error(
+              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
+            );
+          this.advance();
+          dimensions.push(this.parseDimension());
+        } else {
+          break;
         }
-        dimensions.push(dim);
       }
       return dimensions;
     }
@@ -4333,35 +4456,11 @@ var Numerics = (() => {
       }
       return void 0;
     }
-    parseDimensionWithX() {
-      if (this.current.type === "NUMBER_LITERAL") {
-        const dimensions = [];
-        const firstDim = parseInt(this.advance().value);
-        dimensions.push(
-          this.createNode("dimension", { size: firstDim })
-        );
-        if (this.current.type === "IDENTIFIER" && this.current.value.startsWith("x")) {
-          const dimString = this.current.value;
-          const matches = dimString.match(/x(\d+)/g);
-          if (matches && matches.join("") === dimString) {
-            this.advance();
-            for (const match of matches) {
-              const dimValue = parseInt(match.substring(1));
-              dimensions.push(
-                this.createNode("dimension", { size: dimValue })
-              );
-            }
-          } else if (dimString === "x" || dimString.startsWith("x")) {
-            this.error(
-              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
-            );
-          }
-        }
-        if (dimensions.length > 1) {
-          return dimensions;
-        }
-      }
-      return void 0;
+    parseCaretDimensions() {
+      const paren = this.match("(");
+      const dimensions = this.parseDimensions();
+      if (paren) this.expect(")");
+      return dimensions;
     }
     parseTupleType() {
       if (this.current.type === "IDENTIFIER" && this.current.value === "tuple") {
@@ -4546,6 +4645,18 @@ var Numerics = (() => {
             this.expect("..");
             const upperBound = this.parseValue();
             this.expect(">");
+            const lower = lowerBound?.value ?? -Infinity;
+            const upper = upperBound?.value ?? Infinity;
+            if (Number.isNaN(lower) || Number.isNaN(upper))
+              this.error(
+                "Invalid numeric type",
+                "Lower and upper bounds must be valid numbers"
+              );
+            if (lower > upper)
+              this.error(
+                `Invalid range: ${lower}..${upper}`,
+                "The lower bound must be less than the upper bound"
+              );
             return this.createNode("numeric", {
               baseType,
               lowerBound,
@@ -4560,7 +4671,7 @@ var Numerics = (() => {
     parsePrimitiveType() {
       if (this.current.type === "IDENTIFIER") {
         const name = this.current.value;
-        if (PRIMITIVE_TYPES.includes(name)) {
+        if (PRIMITIVE_TYPES_SET.has(name)) {
           this.advance();
           return this.createNode("primitive", { name });
         }
@@ -4894,14 +5005,32 @@ var Numerics = (() => {
   }
 
   // src/common/type/parse.ts
+  var TYPE_CACHE = /* @__PURE__ */ new Map();
+  var TYPE_CACHE_MAX_SIZE = 2048;
+  function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+    if (Object.isFrozen(obj)) return obj;
+    Object.freeze(obj);
+    for (const value of Object.values(obj)) deepFreeze(value);
+    return obj;
+  }
   function parseType(s, typeResolver) {
     if (s === void 0) return void 0;
     if (isValidType(s)) return s;
     if (typeof s !== "string") return void 0;
+    const cacheable = typeResolver === void 0;
+    if (cacheable) {
+      const cached = TYPE_CACHE.get(s);
+      if (cached !== void 0) return cached;
+    }
     try {
       const parser = new Parser(s, { typeResolver });
       const ast = parser.parseType();
       const type = buildTypeFromAST(ast, typeResolver);
+      if (cacheable) {
+        if (TYPE_CACHE.size >= TYPE_CACHE_MAX_SIZE) TYPE_CACHE.clear();
+        TYPE_CACHE.set(s, deepFreeze(type));
+      }
       return type;
     } catch (error) {
       throw new Error(
@@ -4976,19 +5105,36 @@ var Numerics = (() => {
     color: [],
     expression: EXPRESSION_TYPES
   };
+  var PRIMITIVE_SUBTYPES_CLOSURE = (() => {
+    const closure = {};
+    const closeOver = (t) => {
+      if (closure[t]) return closure[t];
+      const result = /* @__PURE__ */ new Set([t]);
+      closure[t] = result;
+      for (const sub of PRIMITIVE_SUBTYPES[t]) {
+        if (sub === t) continue;
+        for (const s of closeOver(sub)) result.add(s);
+      }
+      return result;
+    };
+    for (const t of Object.keys(PRIMITIVE_SUBTYPES))
+      closeOver(t);
+    return closure;
+  })();
   function isPrimitiveSubtype(lhs, rhs) {
     if (rhs === "any") return true;
     if (lhs === "never") return true;
     if (lhs === "unknown" || rhs === "unknown") return false;
     if (lhs === rhs) return true;
-    return PRIMITIVE_SUBTYPES[rhs].includes(lhs);
+    return PRIMITIVE_SUBTYPES_CLOSURE[rhs].has(lhs);
   }
   function isSubtype(lhs, rhs) {
-    if (typeof lhs === "string" && !PRIMITIVE_TYPES.includes(lhs))
+    if (typeof lhs === "string" && !PRIMITIVE_TYPES_SET.has(lhs))
       lhs = parseType(lhs);
-    if (typeof rhs === "string" && !PRIMITIVE_TYPES.includes(rhs))
+    if (typeof rhs === "string" && !PRIMITIVE_TYPES_SET.has(rhs))
       rhs = parseType(rhs);
     if (rhs === "any") return true;
+    if (lhs === "never") return true;
     if (rhs === "never") return false;
     if (rhs === "error") return lhs === "error";
     if (rhs === "nothing") return lhs === "nothing";
@@ -5003,7 +5149,7 @@ var Numerics = (() => {
         if (typeof lhs.value === "number") {
           if (Number.isInteger(lhs.value))
             return isPrimitiveSubtype("integer", rhs);
-          return isPrimitiveSubtype("number", rhs);
+          return isPrimitiveSubtype("real", rhs);
         }
         if (typeof lhs.value === "boolean")
           return isPrimitiveSubtype("boolean", rhs);
@@ -5233,7 +5379,7 @@ var Numerics = (() => {
   }
   function isNumeric(type) {
     if (typeof type === "string")
-      return NUMERIC_TYPES.includes(type);
+      return NUMERIC_TYPES_SET.has(type);
     if (type.kind === "value") return typeof type.value === "number";
     if (type.kind === "numeric") return true;
     return false;
@@ -5241,7 +5387,7 @@ var Numerics = (() => {
   function isScalar(type) {
     if (isNumeric(type)) return true;
     if (typeof type === "string")
-      return SCALAR_TYPES.includes(type);
+      return SCALAR_TYPES_SET.has(type);
     if (type.kind === "value")
       return ["string", "boolean", "number"].includes(typeof type.value);
     return false;
@@ -5249,7 +5395,7 @@ var Numerics = (() => {
   function isCollection(type) {
     if (isIndexedCollection(type)) return true;
     if (typeof type === "string")
-      return COLLECTION_TYPES.includes(type);
+      return COLLECTION_TYPES_SET.has(type);
     return ["collection", "set", "record", "dictionary"].includes(type.kind);
   }
   function isIndexedCollection(type) {
@@ -5288,13 +5434,75 @@ var Numerics = (() => {
     if (b === "nothing") return a;
     if (isSubtype(a, b)) return b;
     if (isSubtype(b, a)) return a;
-    return superType(a, b);
+    const sup = superType(a, b);
+    if (LOSSY_SUPERTYPE.has(sup)) return unionTypes(a, b);
+    return sup;
+  }
+  var LOSSY_SUPERTYPE = /* @__PURE__ */ new Set([
+    "scalar",
+    "value",
+    "function",
+    "expression",
+    "collection",
+    "indexed_collection",
+    "list",
+    "set",
+    "tuple",
+    "record",
+    "dictionary",
+    "map",
+    "any"
+  ]);
+  function unionTypes(a, b) {
+    const members = [];
+    const keys = /* @__PURE__ */ new Set();
+    const push = (t) => {
+      if (typeof t === "object" && t.kind === "union") {
+        for (const m of t.types) push(m);
+        return;
+      }
+      const key = typeof t === "string" ? t : JSON.stringify(t);
+      if (!keys.has(key)) {
+        keys.add(key);
+        members.push(t);
+      }
+    };
+    push(a);
+    push(b);
+    if (members.length === 1) return members[0];
+    return { kind: "union", types: members };
   }
   function widen(...types) {
     if (types.length === 0) return "nothing";
     if (types.length === 1) return types[0];
     return types.reduce((a, b) => widen2(a, b));
   }
+  var SUPERTYPE_PROBE_ORDER = [
+    "non_finite_number",
+    "finite_integer",
+    "integer",
+    "finite_rational",
+    "rational",
+    "finite_real",
+    "real",
+    "imaginary",
+    "finite_complex",
+    "complex",
+    "finite_number",
+    "number",
+    "list",
+    "record",
+    "dictionary",
+    "set",
+    "tuple",
+    "indexed_collection",
+    "collection",
+    "scalar",
+    "value",
+    "function",
+    "expression"
+  ];
+  var PRIMITIVE_SUPERTYPE_CACHE = /* @__PURE__ */ new Map();
   function superType(a, b) {
     if (a === b) return a;
     if (a === "any" || b === "any") return "any";
@@ -5304,35 +5512,26 @@ var Numerics = (() => {
     if (b === "unknown") return a;
     if (a === "nothing") return b;
     if (b === "nothing") return a;
-    if (commonSupertype(a, b, "non_finite_number")) return "non_finite_number";
-    if (commonSupertype(a, b, "finite_integer")) return "finite_integer";
-    if (commonSupertype(a, b, "integer")) return "integer";
-    if (commonSupertype(a, b, "finite_rational")) return "finite_rational";
-    if (commonSupertype(a, b, "rational")) return "rational";
-    if (commonSupertype(a, b, "finite_real")) return "finite_real";
-    if (commonSupertype(a, b, "real")) return "real";
-    if (commonSupertype(a, b, "imaginary")) return "imaginary";
-    if (commonSupertype(a, b, "finite_complex")) return "finite_complex";
-    if (commonSupertype(a, b, "complex")) return "complex";
-    if (commonSupertype(a, b, "finite_number")) return "finite_number";
-    if (commonSupertype(a, b, "number")) return "number";
-    if (commonSupertype(a, b, "list")) return "list";
-    if (commonSupertype(a, b, "record")) return "record";
-    if (commonSupertype(a, b, "dictionary")) return "dictionary";
-    if (commonSupertype(a, b, "set")) return "set";
-    if (commonSupertype(a, b, "tuple")) return "tuple";
-    if (commonSupertype(a, b, "indexed_collection")) return "indexed_collection";
-    if (commonSupertype(a, b, "collection")) return "collection";
-    if (commonSupertype(a, b, "scalar")) return "scalar";
-    if (commonSupertype(a, b, "value")) return "value";
-    if (commonSupertype(a, b, "function")) return "function";
-    if (commonSupertype(a, b, "expression")) return "expression";
+    if (typeof a === "string" && typeof b === "string") {
+      const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+      let result = PRIMITIVE_SUPERTYPE_CACHE.get(key);
+      if (result === void 0) {
+        result = "any";
+        for (const ancestor of SUPERTYPE_PROBE_ORDER) {
+          const subtypes = PRIMITIVE_SUBTYPES_CLOSURE[ancestor];
+          if (subtypes.has(a) && subtypes.has(b)) {
+            result = ancestor;
+            break;
+          }
+        }
+        PRIMITIVE_SUPERTYPE_CACHE.set(key, result);
+      }
+      return result;
+    }
+    for (const ancestor of SUPERTYPE_PROBE_ORDER)
+      if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return ancestor;
     return "any";
   }
-  function commonSupertype(a, b, ancestor) {
-    if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return true;
-    return false;
-  }
 
   // src/compute-engine/numeric-value/exact-numeric-value.ts
   var ExactNumericValue = class _ExactNumericValue extends NumericValue {
@@ -5550,6 +5749,10 @@ var Numerics = (() => {
       });
     }
     inv() {
+      if (this.isNaN) return this;
+      if (this.isPositiveInfinity || this.isNegativeInfinity)
+        return this.clone(0);
+      if (this.isZero) return this.clone(Infinity);
       if (this.isOne) return this;
       if (this.isNegativeOne) return this;
       return this.clone({
@@ -5668,7 +5871,7 @@ var Numerics = (() => {
         } else {
           if (exponent instanceof _ExactNumericValue) {
             if (exponent.radical === 1 && exponent.rational[0] == 1)
-              return this.root(exponent.rational[0]);
+              return this.root(Number(exponent.rational[1]));
           }
           exponent = exponent.re;
         }
@@ -5803,19 +6006,52 @@ var Numerics = (() => {
       if (this.isPositiveInfinity) return this.clone(Infinity);
       return this.factory(this.bignumRe).exp();
     }
+    /**
+     * Floor/ceil/round of a pure rational (`radical === 1`) computed exactly with
+     * bigints. Routing through `this.re` (a float) would lose digits for
+     * integers/rationals larger than 2^53.
+     */
+    _integerPart(mode2) {
+      let n = BigInt(this.rational[0]);
+      let d = BigInt(this.rational[1]);
+      if (d < 0n) {
+        n = -n;
+        d = -d;
+      }
+      let q;
+      if (mode2 === "round") {
+        const m = 2n * n + d;
+        const dd = 2n * d;
+        q = m / dd;
+        if (m % dd !== 0n && m < 0n) q -= 1n;
+      } else {
+        q = n / d;
+        const r = n % d;
+        if (r !== 0n) {
+          if (mode2 === "floor" && n < 0n) q -= 1n;
+          if (mode2 === "ceil" && n > 0n) q += 1n;
+        }
+      }
+      return this.clone({ rational: [q, BigInt(1)], radical: 1 });
+    }
+    // An exact value is an integer iff it has no radical part and a unit
+    // denominator. (`this.type` returns `'finite_integer'`, never `'integer'`.)
     floor() {
       if (this.isNaN) return this.clone(NaN);
-      if (this.type === "integer") return this;
+      if (this.radical === 1 && isInteger(this.rational)) return this;
+      if (this.radical === 1) return this._integerPart("floor");
       return this.clone(Math.floor(this.re));
     }
     ceil() {
       if (this.isNaN) return this.clone(NaN);
-      if (this.type === "integer") return this;
+      if (this.radical === 1 && isInteger(this.rational)) return this;
+      if (this.radical === 1) return this._integerPart("ceil");
       return this.clone(Math.ceil(this.re));
     }
     round() {
       if (this.isNaN) return this.clone(NaN);
-      if (this.type === "integer") return this;
+      if (this.radical === 1 && isInteger(this.rational)) return this;
+      if (this.radical === 1) return this._integerPart("round");
       return this.clone(Math.round(this.re));
     }
     eq(other) {
@@ -5914,7 +6150,7 @@ var Numerics = (() => {
     return a.abs();
   }
   function lcm3(a, b) {
-    return a.mul(b).div(gcd3(a, b));
+    return a.mul(b).div(gcd3(a, b)).abs();
   }
   function* factorial22(n) {
     if (!n.isInteger() || n.isNegative()) return BigDecimal.NAN;
@@ -6094,8 +6330,8 @@ var Numerics = (() => {
       if (this.isOne) return this;
       if (this.isNegativeOne) return this;
       if (this.im === 0) return this.clone(this.decimal.inv());
-      const d = Math.hypot(this.re, this.im);
-      const bigD = this.decimal.mul(this.decimal).add(this.im * this.im).sqrt();
+      const d = this.re * this.re + this.im * this.im;
+      const bigD = this.decimal.mul(this.decimal).add(this.im * this.im);
       return this.clone({ re: this.decimal.div(bigD), im: -this.im / d });
     }
     add(other) {
@@ -6122,7 +6358,7 @@ var Numerics = (() => {
       if (other === 1) return this;
       if (other === -1) return this.neg();
       if (other === 0) {
-        if (this.isPositiveInfinity || this.isNegativeInfinity || this.isComplexInfinity)
+        if (this.isNaN || this.isPositiveInfinity || this.isNegativeInfinity || this.isComplexInfinity)
           return this._makeExact(NaN);
         return this.clone(0);
       }
@@ -6152,7 +6388,7 @@ var Numerics = (() => {
       if (other.isOne) return this;
       if (other.isNegativeOne) return this.neg();
       if (other.isZero) {
-        if (this.isPositiveInfinity || this.isNegativeInfinity || this.isComplexInfinity)
+        if (this.isNaN || this.isPositiveInfinity || this.isNegativeInfinity || this.isComplexInfinity)
           return this._makeExact(NaN);
         return this.clone(0);
       }
@@ -6175,7 +6411,11 @@ var Numerics = (() => {
       }
       if (other.isOne) return this;
       if (other.isNegativeOne) return this.neg();
-      if (other.isZero) return this.clone(this.isZero ? NaN : Infinity);
+      if (other.isZero) {
+        if (this.isZero || this.isNaN) return this.clone(NaN);
+        if (this.im !== 0) return this.clone({ im: Infinity });
+        return this.clone(this.decimal.isNegative() ? -Infinity : Infinity);
+      }
       if (this.im === 0 && other.im === 0)
         return this.clone(this.decimal.div(other.bignumRe ?? other.re));
       const [a, b] = [this.re, this.im];
@@ -6209,13 +6449,18 @@ var Numerics = (() => {
           if (this.im === Infinity) return this.clone(NaN);
           if (this.isNegativeInfinity) return this.clone(0);
           if (this.isPositiveInfinity) return this.clone({ im: Infinity });
-          const zRe = this.pow(re);
-          const zArg = this.decimal.ln().mul(im);
-          const zIm = this.clone({
-            re: zArg.cos(),
-            im: chop2(zArg.sin().toNumber())
+          if (this.isZero) return re > 0 ? this.clone(0) : this.clone(NaN);
+          const a2 = this.decimal;
+          const b2 = this.im;
+          const lnMod = a2.mul(a2).add(b2 * b2).sqrt().ln();
+          const arg = BigDecimal.atan2(b2, a2);
+          const realExp = lnMod.mul(re).sub(arg.mul(im));
+          const imagExp = arg.mul(re).add(lnMod.mul(im));
+          const mag = realExp.exp();
+          return this.clone({
+            re: mag.mul(imagExp.cos()),
+            im: chop2(mag.mul(imagExp.sin()).toNumber())
           });
-          return zRe.mul(zIm);
         }
       }
       if (this.isPositiveInfinity) {
@@ -6259,13 +6504,13 @@ var Numerics = (() => {
         if (this.decimal.isNegative()) return this._makeExact(NaN);
         if (exp === 2) return this.clone(this.decimal.sqrt());
         if (exp === 3) return this.clone(this.decimal.cbrt());
-        return this.clone(this.decimal.pow(1 / exp));
+        return this.clone(this.decimal.ln().div(exp).exp());
       }
       const a = this.decimal;
       const b = this.im;
       const modulus = a.mul(a).add(b * b).sqrt();
       const argument = BigDecimal.atan2(b, a);
-      const newModulus = modulus.pow(1 / exp);
+      const newModulus = modulus.ln().div(exp).exp();
       const newArgument = argument.div(exp);
       return this.clone({
         re: newModulus.mul(newArgument.cos()),
@@ -6531,7 +6776,7 @@ var Numerics = (() => {
       if (this.isOne) return this;
       if (this.isNegativeOne) return this;
       if (this.im === 0) return this.clone(1 / this.decimal);
-      const d = Math.hypot(this.re, this.im);
+      const d = this.re * this.re + this.im * this.im;
       return this.clone({ re: this.decimal / d, im: -this.im / d });
     }
     add(other) {
@@ -6641,11 +6886,17 @@ var Numerics = (() => {
           if (this.im === Infinity) return this.clone(NaN);
           if (this.isNegativeInfinity) return this.clone(0);
           if (this.isPositiveInfinity) return this.clone({ im: Infinity });
-          const zRe = this.pow(re).re;
-          const zArg = Math.log(this.decimal) * im;
+          if (this.isZero) return re > 0 ? this.clone(0) : this.clone(NaN);
+          const a2 = this.decimal;
+          const b2 = this.im;
+          const lnMod = 0.5 * Math.log(a2 * a2 + b2 * b2);
+          const arg = Math.atan2(b2, a2);
+          const realExp = re * lnMod - im * arg;
+          const imagExp = re * arg + im * lnMod;
+          const mag = Math.exp(realExp);
           return this.clone({
-            re: chop3(zRe * Math.cos(zArg)),
-            im: chop3(zRe * Math.sin(zArg))
+            re: chop3(mag * Math.cos(imagExp)),
+            im: chop3(mag * Math.sin(imagExp))
           });
         }
       }
@@ -6664,14 +6915,15 @@ var Numerics = (() => {
         if (exponent > 0) return this;
         if (exponent < 0) return this.clone({ im: Infinity });
       }
-      if (exponent < 0) return this.clone(1 / this.decimal ** -exponent);
+      if (exponent < 0 && this.im === 0)
+        return this.clone(1 / this.decimal ** -exponent);
       if (this.im === 0) return this.clone(this.decimal ** exponent);
       const a = this.decimal;
       const b = this.im;
       const modulus = Math.sqrt(a * a + b * b);
       const argument = Math.atan2(b, a);
       const newModulus = modulus ** exponent;
-      const newArgument = argument ** exponent;
+      const newArgument = argument * exponent;
       return this.clone({
         re: newModulus * Math.cos(newArgument),
         im: newModulus * Math.sin(newArgument)
@@ -6792,10 +7044,10 @@ var Numerics = (() => {
     eq(other) {
       if (this.isNaN) return false;
       if (typeof other === "number")
-        return this.im === 0 && this.decimal - other === 0;
+        return this.im === 0 && this.decimal === other;
       if (other.isNaN) return false;
       if (!Number.isFinite(this.im)) return !Number.isFinite(other.im);
-      return this.decimal - other.re === 0 && this.im - other.im === 0;
+      return this.decimal === other.re && this.im === other.im;
     }
     lt(other) {
       if (this.im !== 0) return void 0;
@@ -6877,42 +7129,20 @@ var Numerics = (() => {
     return void 0;
   }
   function intervalContains(int, val) {
-    if (int.openStart) {
-      if (int.start <= val) return false;
-    }
-    if (int.start < val) return false;
-    if (int.openEnd) {
-      if (int.end >= val) return false;
-    }
-    if (int.end > val) return false;
+    if (int.openStart ? val <= int.start : val < int.start) return false;
+    if (int.openEnd ? val >= int.end : val > int.end) return false;
     return true;
   }
   function intervalSubset(int1, int2) {
-    if (int1.openStart) {
-      if (int2.openStart) {
-        if (int1.start <= int2.start) return false;
-      } else {
-        if (int1.start < int2.start) return false;
-      }
+    if (!int1.openStart && int2.openStart) {
+      if (int1.start <= int2.start) return false;
     } else {
-      if (int2.openStart) {
-        if (int1.start <= int2.start) return false;
-      } else {
-        if (int1.start < int2.start) return false;
-      }
+      if (int1.start < int2.start) return false;
     }
-    if (int1.openEnd) {
-      if (int2.openEnd) {
-        if (int1.end >= int2.end) return false;
-      } else {
-        if (int1.end > int2.end) return false;
-      }
+    if (!int1.openEnd && int2.openEnd) {
+      if (int1.end >= int2.end) return false;
     } else {
-      if (int2.openEnd) {
-        if (int1.end >= int2.end) return false;
-      } else {
-        if (int1.end > int2.end) return false;
-      }
+      if (int1.end > int2.end) return false;
     }
     return true;
   }
@@ -7095,6 +7325,7 @@ var Numerics = (() => {
   function kurtosis(values) {
     let sum = 0;
     let sum2 = 0;
+    let sum3 = 0;
     let sum4 = 0;
     let count = 0;
     for (const op of values) {
@@ -7102,16 +7333,21 @@ var Numerics = (() => {
       if (!Number.isFinite(v)) return NaN;
       sum += v;
       sum2 += v * v;
+      sum3 += v * v * v;
       sum4 += v * v * v * v;
       count++;
     }
     if (count === 0) return NaN;
-    const s2 = (sum2 - sum * sum / count) / (count - 1);
-    return (sum4 - 4 * sum * sum2 / count + 6 * sum * sum * sum / count / count - 3 * sum * sum * sum * sum / count / count / count) / (s2 * s2);
+    const n = count;
+    const m = sum / n;
+    const m2 = (sum2 - sum * sum / n) / n;
+    const m4 = (sum4 - 4 * m * sum3 + 6 * m * m * sum2 - 4 * m * m * m * sum + n * m * m * m * m) / n;
+    return m4 / (m2 * m2);
   }
   function bigKurtosis(values) {
     let sum = BigDecimal.ZERO;
     let sum2 = BigDecimal.ZERO;
+    let sum3 = BigDecimal.ZERO;
     let sum4 = BigDecimal.ZERO;
     let count = 0;
     for (const op of values) {
@@ -7119,15 +7355,15 @@ var Numerics = (() => {
       if (!v.isFinite()) return BigDecimal.NAN;
       sum = sum.add(v);
       sum2 = sum2.add(v.mul(v));
+      sum3 = sum3.add(v.mul(v).mul(v));
       sum4 = sum4.add(v.mul(v).mul(v).mul(v));
       count++;
     }
     if (count === 0) return BigDecimal.NAN;
-    const bdCount = new BigDecimal(count);
-    const s2 = sum2.sub(sum.mul(sum).div(bdCount)).div(new BigDecimal(count - 1));
-    return sum4.sub(sum.mul(sum2).mul(new BigDecimal(4)).div(bdCount)).add(sum.mul(sum).mul(sum).mul(new BigDecimal(6)).div(bdCount).div(bdCount)).sub(
-      sum.mul(sum).mul(sum).mul(sum).mul(new BigDecimal(3)).div(bdCount).div(bdCount).div(bdCount)
-    ).div(s2.mul(s2));
+    const m = sum.div(count);
+    const m2 = sum2.sub(sum.mul(sum).div(count)).div(count);
+    const m4 = sum4.sub(m.mul(sum3).mul(4)).add(m.mul(m).mul(sum2).mul(6)).sub(m.mul(m).mul(m).mul(sum).mul(4)).add(m.mul(m).mul(m).mul(m).mul(count)).div(count);
+    return m4.div(m2.mul(m2));
   }
   function skewness(values) {
     let sum = 0;
@@ -7143,9 +7379,11 @@ var Numerics = (() => {
       count++;
     }
     if (count === 0) return NaN;
-    const s2 = (sum2 - sum * sum / count) / (count - 1);
-    const s3 = (sum3 - sum2 * sum / count) / (count - 1);
-    return s3 / Math.pow(s2, 3 / 2) * Math.sqrt(count * 1);
+    const n = count;
+    const m = sum / n;
+    const m2 = (sum2 - sum * sum / n) / n;
+    const m3 = (sum3 - 3 * m * sum2 + 3 * m * m * sum - n * m * m * m) / n;
+    return m3 / Math.pow(m2, 3 / 2);
   }
   function bigSkewness(values) {
     let sum = BigDecimal.ZERO;
@@ -7161,10 +7399,10 @@ var Numerics = (() => {
       count++;
     }
     if (count === 0) return BigDecimal.NAN;
-    const bdCount = new BigDecimal(count);
-    const s2 = sum2.sub(sum.mul(sum).div(bdCount)).div(new BigDecimal(count - 1));
-    const s3 = sum3.sub(sum2.mul(sum).div(bdCount)).div(new BigDecimal(count - 1));
-    return s3.div(s2.pow(new BigDecimal(1.5))).mul(bdCount.sqrt());
+    const m = sum.div(count);
+    const m2 = sum2.sub(sum.mul(sum).div(count)).div(count);
+    const m3 = sum3.sub(m.mul(sum2).mul(3)).add(m.mul(m).mul(sum).mul(3)).sub(m.mul(m).mul(m).mul(count)).div(count);
+    return m3.div(m2.mul(m2.sqrt()));
   }
   function mode(values) {
     const counts = {};
@@ -7215,18 +7453,12 @@ var Numerics = (() => {
     return [q1, q2, q3];
   }
   function interquartileRange(values) {
-    const sorted = [...values].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    const lower = sorted.slice(0, mid);
-    const upper = sorted.slice(mid + 1);
-    return median(upper) - median(lower);
+    const [q1, , q3] = quartiles(values);
+    return q3 - q1;
   }
   function bigInterquartileRange(values) {
-    const sorted = [...values].sort((a, b) => a.cmp(b));
-    const mid = Math.floor(sorted.length / 2);
-    const lower = sorted.slice(0, mid);
-    const upper = sorted.slice(mid + 1);
-    return bigMedian(upper).sub(bigMedian(lower));
+    const [q1, , q3] = bigQuartiles(values);
+    return q3.sub(q1);
   }
 
   // src/compute-engine/numerics/unit-data.ts
@@ -7601,9 +7833,14 @@ var Numerics = (() => {
   ];
   function gammaln(z) {
     if (z < 0) return NaN;
+    let shift = 0;
+    while (z < 10) {
+      shift += Math.log(z);
+      z += 1;
+    }
     const pi = Math.PI;
     const z3 = z * z * z;
-    return z * Math.log(z) - z - 0.5 * Math.log(z) + 0.5 * Math.log(2 * pi) + 1 / (12 * z) - 1 / (360 * z3) + 1 / (1260 * z3 * z * z);
+    return z * Math.log(z) - z - 0.5 * Math.log(z) + 0.5 * Math.log(2 * pi) + 1 / (12 * z) - 1 / (360 * z3) + 1 / (1260 * z3 * z * z) - shift;
   }
   function gamma(z) {
     if (z < 0.5) return Math.PI / (Math.sin(Math.PI * z) * gamma(1 - z));
@@ -7614,31 +7851,62 @@ var Numerics = (() => {
     const t = z + gammaG + 0.5;
     return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * x;
   }
+  function erfInvApprox(x) {
+    const a = 0.147;
+    const ln1mx2 = Math.log(1 - x * x);
+    const b = 2 / (Math.PI * a) + ln1mx2 / 2;
+    return Math.sign(x) * Math.sqrt(Math.sqrt(b * b - ln1mx2 / a) - b);
+  }
   function erfInv(x) {
-    const pi = Math.PI;
-    const pi2 = pi * pi;
-    const pi3 = pi2 * pi;
-    const x2 = x * x;
-    const x3 = x * x2;
-    const x5 = x3 * x2;
-    const x7 = x5 * x2;
-    return Math.sqrt(pi) / 2 * (x + pi / 12 * x3 + 7 * pi2 / 480 * x5 + 127 * pi3 / 40320 * x7 + 4369 * pi2 * pi2 / 5806080 * x7 * x2 + 34807 * pi3 * pi2 / 182476800 * x7 * x2 * x2);
+    if (Number.isNaN(x) || x < -1 || x > 1) return NaN;
+    if (x === 0) return 0;
+    if (x === 1) return Infinity;
+    if (x === -1) return -Infinity;
+    const sign = x < 0 ? -1 : 1;
+    const ax = Math.abs(x);
+    let y = erfInvApprox(ax);
+    const c = Math.sqrt(Math.PI) / 2;
+    for (let i = 0; i < 4; i++) y -= (erf(y) - ax) * c * Math.exp(y * y);
+    return sign * y;
   }
   function erfc(x) {
-    return 1 - erf(x);
+    if (Number.isNaN(x)) return NaN;
+    if (!Number.isFinite(x)) return x > 0 ? 0 : 2;
+    if (x < 0) return 2 - erfc(-x);
+    if (x < 2) return 1 - erf(x);
+    const tiny = 1e-300;
+    let f = x === 0 ? tiny : x;
+    let c = f;
+    let d = 0;
+    for (let k = 1; k <= 500; k++) {
+      const a = k / 2;
+      d = x + a * d;
+      if (d === 0) d = tiny;
+      d = 1 / d;
+      c = x + a / c;
+      if (c === 0) c = tiny;
+      const delta = c * d;
+      f *= delta;
+      if (Math.abs(delta - 1) < 1e-17) break;
+    }
+    return Math.exp(-x * x) / (Math.sqrt(Math.PI) * f);
   }
   function erf(x) {
-    const a1 = 0.254829592;
-    const a2 = -0.284496736;
-    const a3 = 1.421413741;
-    const a4 = -1.453152027;
-    const a5 = 1.061405429;
-    const p = 0.3275911;
+    if (Number.isNaN(x)) return NaN;
+    if (x === 0) return 0;
+    if (!Number.isFinite(x)) return x > 0 ? 1 : -1;
     const sign = x < 0 ? -1 : 1;
-    x = Math.abs(x);
-    const t = 1 / (1 + p * x);
-    const y = ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t;
-    return sign * (1 - y * Math.exp(-x * x));
+    const ax = Math.abs(x);
+    if (ax >= 6) return sign;
+    const x2 = ax * ax;
+    let term = ax;
+    let sum = ax;
+    for (let n = 1; n < 200; n++) {
+      term *= 2 * x2 / (2 * n + 1);
+      sum += term;
+      if (term < sum * 1e-18) break;
+    }
+    return sign * (2 / Math.sqrt(Math.PI)) * Math.exp(-x2) * sum;
   }
   function bigGammaln(ce, z) {
     if (!z.isFinite()) return BigDecimal.NAN;
@@ -8588,7 +8856,7 @@ var Numerics = (() => {
       const t = x2 * x2;
       return sign * x * x2 * polevl(t, SN) / polevl(t, SD);
     }
-    if (x < 36) {
+    if (x < 36974) {
       const x2 = x * x;
       const t = Math.PI * x2;
       const u = 1 / (t * t);
@@ -8613,7 +8881,7 @@ var Numerics = (() => {
       const t = x2 * x2;
       return sign * x * polevl(t, CN) / polevl(t, CD);
     }
-    if (x < 36) {
+    if (x < 36974) {
       const x2 = x * x;
       const t = Math.PI * x2;
       const u = 1 / (t * t);
@@ -8630,16 +8898,904 @@ var Numerics = (() => {
     return x === 0 ? 1 : Math.sin(x) / x;
   }
 
+  // node_modules/complex-esm/dist/src/complex.js
+  var cosh = Math.cosh || function(x) {
+    return Math.abs(x) < 1e-9 ? 1 - x : (Math.exp(x) + Math.exp(-x)) * 0.5;
+  };
+  var sinh = Math.sinh || function(x) {
+    return Math.abs(x) < 1e-9 ? x : (Math.exp(x) - Math.exp(-x)) * 0.5;
+  };
+  var cosm1 = function(x) {
+    var b = Math.PI / 4;
+    if (-b > x || x > b) {
+      return Math.cos(x) - 1;
+    }
+    var xx = x * x;
+    return xx * (xx * (xx * (xx * (xx * (xx * (xx * (xx / 20922789888e3 - 1 / 87178291200) + 1 / 479001600) - 1 / 3628800) + 1 / 40320) - 1 / 720) + 1 / 24) - 1 / 2);
+  };
+  var hypot = function(x, y) {
+    var a = Math.abs(x);
+    var b = Math.abs(y);
+    if (a < 3e3 && b < 3e3) {
+      return Math.sqrt(a * a + b * b);
+    }
+    if (a < b) {
+      a = b;
+      b = x / y;
+    } else {
+      b = y / x;
+    }
+    return a * Math.sqrt(1 + b * b);
+  };
+  var parser_exit = function() {
+    throw SyntaxError("Invalid Param");
+  };
+  function logHypot(a, b) {
+    var _a = Math.abs(a);
+    var _b = Math.abs(b);
+    if (a === 0) {
+      return Math.log(_b);
+    }
+    if (b === 0) {
+      return Math.log(_a);
+    }
+    if (_a < 3e3 && _b < 3e3) {
+      return Math.log(a * a + b * b) * 0.5;
+    }
+    a = a / 2;
+    b = b / 2;
+    return 0.5 * Math.log(a * a + b * b) + Math.LN2;
+  }
+  var parse = function(a, b) {
+    var z = { "re": 0, "im": 0 };
+    if (a === void 0 || a === null) {
+      z["re"] = z["im"] = 0;
+    } else if (b !== void 0) {
+      z["re"] = a;
+      z["im"] = b;
+    } else
+      switch (typeof a) {
+        case "object":
+          if ("im" in a && "re" in a) {
+            z["re"] = a["re"];
+            z["im"] = a["im"];
+          } else if ("abs" in a && "arg" in a) {
+            if (!Number.isFinite(a["abs"]) && Number.isFinite(a["arg"])) {
+              return Complex["INFINITY"];
+            }
+            z["re"] = a["abs"] * Math.cos(a["arg"]);
+            z["im"] = a["abs"] * Math.sin(a["arg"]);
+          } else if ("r" in a && "phi" in a) {
+            if (!Number.isFinite(a["r"]) && Number.isFinite(a["phi"])) {
+              return Complex["INFINITY"];
+            }
+            z["re"] = a["r"] * Math.cos(a["phi"]);
+            z["im"] = a["r"] * Math.sin(a["phi"]);
+          } else if (a.length === 2) {
+            z["re"] = a[0];
+            z["im"] = a[1];
+          } else {
+            parser_exit();
+          }
+          break;
+        case "string":
+          z["im"] = /* void */
+          z["re"] = 0;
+          var tokens = a.match(/\d+\.?\d*e[+-]?\d+|\d+\.?\d*|\.\d+|./g);
+          var plus = 1;
+          var minus = 0;
+          if (tokens === null) {
+            parser_exit();
+          }
+          for (var i = 0; i < tokens.length; i++) {
+            var c = tokens[i];
+            if (c === " " || c === "	" || c === "\n") {
+            } else if (c === "+") {
+              plus++;
+            } else if (c === "-") {
+              minus++;
+            } else if (c === "i" || c === "I") {
+              if (plus + minus === 0) {
+                parser_exit();
+              }
+              if (tokens[i + 1] !== " " && !isNaN(Number(tokens[i + 1]))) {
+                z["im"] += parseFloat((minus % 2 ? "-" : "") + tokens[i + 1]);
+                i++;
+              } else {
+                z["im"] += parseFloat((minus % 2 ? "-" : "") + "1");
+              }
+              plus = minus = 0;
+            } else {
+              if (plus + minus === 0 || isNaN(Number(c))) {
+                parser_exit();
+              }
+              if (tokens[i + 1] === "i" || tokens[i + 1] === "I") {
+                z["im"] += parseFloat((minus % 2 ? "-" : "") + c);
+                i++;
+              } else {
+                z["re"] += parseFloat((minus % 2 ? "-" : "") + c);
+              }
+              plus = minus = 0;
+            }
+          }
+          if (plus + minus > 0) {
+            parser_exit();
+          }
+          break;
+        case "number":
+          z["im"] = 0;
+          z["re"] = a;
+          break;
+        default:
+          parser_exit();
+      }
+    if (isNaN(z["re"]) || isNaN(z["im"])) {
+    }
+    return z;
+  };
+  var Complex = class _Complex {
+    constructor(a, b) {
+      this.re = 0;
+      this.im = 0;
+      var z = parse(a, b);
+      this["re"] = z["re"];
+      this["im"] = z["im"];
+    }
+    /**
+     * Calculates the sign of a complex number, which is a normalized complex
+     *
+     * @returns {Complex}
+     */
+    sign() {
+      var abs = this["abs"]();
+      return new _Complex(this["re"] / abs, this["im"] / abs);
+    }
+    /**
+     * Adds two complex numbers
+     *
+     * @returns {Complex}
+     */
+    add(a, b) {
+      var z = new _Complex(a, b);
+      if (this["isInfinite"]() && z["isInfinite"]()) {
+        return _Complex["NAN"];
+      }
+      if (this["isInfinite"]() || z["isInfinite"]()) {
+        return _Complex["INFINITY"];
+      }
+      return new _Complex(this["re"] + z["re"], this["im"] + z["im"]);
+    }
+    /**
+     * Subtracts two complex numbers
+     *
+     * @returns {Complex}
+     */
+    sub(a, b) {
+      var z = new _Complex(a, b);
+      if (this["isInfinite"]() && z["isInfinite"]()) {
+        return _Complex["NAN"];
+      }
+      if (this["isInfinite"]() || z["isInfinite"]()) {
+        return _Complex["INFINITY"];
+      }
+      return new _Complex(this["re"] - z["re"], this["im"] - z["im"]);
+    }
+    /**
+     * Multiplies two complex numbers
+     *
+     * @returns {Complex}
+     */
+    mul(a, b) {
+      var z = new _Complex(a, b);
+      if (this["isInfinite"]() && z["isZero"]() || this["isZero"]() && z["isInfinite"]()) {
+        return _Complex["NAN"];
+      }
+      if (this["isInfinite"]() || z["isInfinite"]()) {
+        return _Complex["INFINITY"];
+      }
+      if (z["im"] === 0 && this["im"] === 0) {
+        return new _Complex(this["re"] * z["re"], 0);
+      }
+      return new _Complex(this["re"] * z["re"] - this["im"] * z["im"], this["re"] * z["im"] + this["im"] * z["re"]);
+    }
+    /**
+     * Divides two complex numbers
+     *
+     * @returns {Complex}
+     */
+    div(a, b) {
+      var z = new _Complex(a, b);
+      if (this["isZero"]() && z["isZero"]() || this["isInfinite"]() && z["isInfinite"]()) {
+        return _Complex["NAN"];
+      }
+      if (this["isInfinite"]() || z["isZero"]()) {
+        return _Complex["INFINITY"];
+      }
+      if (this["isZero"]() || z["isInfinite"]()) {
+        return _Complex["ZERO"];
+      }
+      a = this["re"];
+      b = this["im"];
+      var c = z["re"];
+      var d = z["im"];
+      var t, x;
+      if (0 === d) {
+        return new _Complex(a / c, b / c);
+      }
+      if (Math.abs(c) < Math.abs(d)) {
+        x = c / d;
+        t = c * x + d;
+        return new _Complex((a * x + b) / t, (b * x - a) / t);
+      } else {
+        x = d / c;
+        t = d * x + c;
+        return new _Complex((a + b * x) / t, (b - a * x) / t);
+      }
+    }
+    /**
+     * Calculate the power of two complex numbers
+     *
+     * @returns {Complex}
+     */
+    pow(a, b) {
+      var z = new _Complex(a, b);
+      a = this["re"];
+      b = this["im"];
+      if (z["isZero"]()) {
+        return _Complex["ONE"];
+      }
+      if (z["im"] === 0) {
+        if (b === 0 && a > 0) {
+          return new _Complex(Math.pow(a, z["re"]), 0);
+        } else if (a === 0) {
+          switch ((z["re"] % 4 + 4) % 4) {
+            case 0:
+              return new _Complex(Math.pow(b, z["re"]), 0);
+            case 1:
+              return new _Complex(0, Math.pow(b, z["re"]));
+            case 2:
+              return new _Complex(-Math.pow(b, z["re"]), 0);
+            case 3:
+              return new _Complex(0, -Math.pow(b, z["re"]));
+          }
+        }
+      }
+      if (a === 0 && b === 0 && z["re"] > 0 && z["im"] >= 0) {
+        return _Complex["ZERO"];
+      }
+      var arg = Math.atan2(b, a);
+      var loh = logHypot(a, b);
+      a = Math.exp(z["re"] * loh - z["im"] * arg);
+      b = z["im"] * loh + z["re"] * arg;
+      return new _Complex(a * Math.cos(b), a * Math.sin(b));
+    }
+    /**
+     * Calculate the complex square root
+     *
+     * @returns {Complex}
+     */
+    sqrt() {
+      var a = this["re"];
+      var b = this["im"];
+      var r = this["abs"]();
+      var re, im;
+      if (a >= 0) {
+        if (b === 0) {
+          return new _Complex(Math.sqrt(a), 0);
+        }
+        re = 0.5 * Math.sqrt(2 * (r + a));
+      } else {
+        re = Math.abs(b) / Math.sqrt(2 * (r - a));
+      }
+      if (a <= 0) {
+        im = 0.5 * Math.sqrt(2 * (r - a));
+      } else {
+        im = Math.abs(b) / Math.sqrt(2 * (r + a));
+      }
+      return new _Complex(re, b < 0 ? -im : im);
+    }
+    /**
+     * Calculate the complex exponent
+     *
+     * @returns {Complex}
+     */
+    exp() {
+      var tmp = Math.exp(this["re"]);
+      if (this["im"] === 0) {
+      }
+      return new _Complex(tmp * Math.cos(this["im"]), tmp * Math.sin(this["im"]));
+    }
+    /**
+     * Calculate the complex exponent and subtracts one.
+     *
+     * This may be more accurate than `Complex(x).exp().sub(1)` if
+     * `x` is small.
+     *
+     * @returns {Complex}
+     */
+    expm1() {
+      var a = this["re"];
+      var b = this["im"];
+      return new _Complex(Math.expm1(a) * Math.cos(b) + cosm1(b), Math.exp(a) * Math.sin(b));
+    }
+    /**
+     * Calculate the natural log
+     *
+     * @returns {Complex}
+     */
+    log() {
+      var a = this["re"];
+      var b = this["im"];
+      if (b === 0 && a > 0) {
+      }
+      return new _Complex(logHypot(a, b), Math.atan2(b, a));
+    }
+    /**
+     * Calculate the magnitude of the complex number
+     *
+     * @returns {number}
+     */
+    abs() {
+      return hypot(this["re"], this["im"]);
+    }
+    /**
+     * Calculate the angle of the complex number
+     *
+     * @returns {number}
+     */
+    arg() {
+      return Math.atan2(this["im"], this["re"]);
+    }
+    /**
+     * Calculate the sine of the complex number
+     *
+     * @returns {Complex}
+     */
+    sin() {
+      var a = this["re"];
+      var b = this["im"];
+      return new _Complex(Math.sin(a) * cosh(b), Math.cos(a) * sinh(b));
+    }
+    /**
+     * Calculate the cosine
+     *
+     * @returns {Complex}
+     */
+    cos() {
+      var a = this["re"];
+      var b = this["im"];
+      return new _Complex(Math.cos(a) * cosh(b), -Math.sin(a) * sinh(b));
+    }
+    /**
+     * Calculate the tangent
+     *
+     * @returns {Complex}
+     */
+    tan() {
+      var a = 2 * this["re"];
+      var b = 2 * this["im"];
+      var d = Math.cos(a) + cosh(b);
+      return new _Complex(Math.sin(a) / d, sinh(b) / d);
+    }
+    /**
+     * Calculate the cotangent
+     *
+     * @returns {Complex}
+     */
+    cot() {
+      var a = 2 * this["re"];
+      var b = 2 * this["im"];
+      var d = Math.cos(a) - cosh(b);
+      return new _Complex(-Math.sin(a) / d, sinh(b) / d);
+    }
+    /**
+     * Calculate the secant
+     *
+     * @returns {Complex}
+     */
+    sec() {
+      var a = this["re"];
+      var b = this["im"];
+      var d = 0.5 * cosh(2 * b) + 0.5 * Math.cos(2 * a);
+      return new _Complex(Math.cos(a) * cosh(b) / d, Math.sin(a) * sinh(b) / d);
+    }
+    /**
+     * Calculate the cosecans
+     *
+     * @returns {Complex}
+     */
+    csc() {
+      var a = this["re"];
+      var b = this["im"];
+      var d = 0.5 * cosh(2 * b) - 0.5 * Math.cos(2 * a);
+      return new _Complex(Math.sin(a) * cosh(b) / d, -Math.cos(a) * sinh(b) / d);
+    }
+    /**
+     * Calculate the complex arcus sinus
+     *
+     * @returns {Complex}
+     */
+    asin() {
+      var a = this["re"];
+      var b = this["im"];
+      var t1 = new _Complex(b * b - a * a + 1, -2 * a * b)["sqrt"]();
+      var t2 = new _Complex(t1["re"] - b, t1["im"] + a)["log"]();
+      return new _Complex(t2["im"], -t2["re"]);
+    }
+    /**
+     * Calculate the complex arcus cosinus
+     *
+     * @returns {Complex}
+     */
+    acos() {
+      var a = this["re"];
+      var b = this["im"];
+      var t1 = new _Complex(b * b - a * a + 1, -2 * a * b)["sqrt"]();
+      var t2 = new _Complex(t1["re"] - b, t1["im"] + a)["log"]();
+      return new _Complex(Math.PI / 2 - t2["im"], t2["re"]);
+    }
+    /**
+     * Calculate the complex arcus tangent
+     *
+     * @returns {Complex}
+     */
+    atan() {
+      var a = this["re"];
+      var b = this["im"];
+      if (a === 0) {
+        if (b === 1) {
+          return new _Complex(0, Infinity);
+        }
+        if (b === -1) {
+          return new _Complex(0, -Infinity);
+        }
+      }
+      var d = a * a + (1 - b) * (1 - b);
+      var t1 = new _Complex((1 - b * b - a * a) / d, -2 * a / d).log();
+      return new _Complex(-0.5 * t1["im"], 0.5 * t1["re"]);
+    }
+    /**
+     * Calculate the complex arcus cotangent
+     *
+     * @returns {Complex}
+     */
+    acot() {
+      var a = this["re"];
+      var b = this["im"];
+      if (b === 0) {
+        return new _Complex(Math.atan2(1, a), 0);
+      }
+      var d = a * a + b * b;
+      return d !== 0 ? new _Complex(a / d, -b / d).atan() : new _Complex(a !== 0 ? a / 0 : 0, b !== 0 ? -b / 0 : 0).atan();
+    }
+    /**
+     * Calculate the complex arcus secant
+     *
+     * @returns {Complex}
+     */
+    asec() {
+      var a = this["re"];
+      var b = this["im"];
+      if (a === 0 && b === 0) {
+        return new _Complex(0, Infinity);
+      }
+      var d = a * a + b * b;
+      return d !== 0 ? new _Complex(a / d, -b / d).acos() : new _Complex(a !== 0 ? a / 0 : 0, b !== 0 ? -b / 0 : 0).acos();
+    }
+    /**
+     * Calculate the complex arcus cosecans
+     *
+     * @returns {Complex}
+     */
+    acsc() {
+      var a = this["re"];
+      var b = this["im"];
+      if (a === 0 && b === 0) {
+        return new _Complex(Math.PI / 2, Infinity);
+      }
+      var d = a * a + b * b;
+      return d !== 0 ? new _Complex(a / d, -b / d).asin() : new _Complex(a !== 0 ? a / 0 : 0, b !== 0 ? -b / 0 : 0).asin();
+    }
+    /**
+     * Calculate the complex sinh
+     *
+     * @returns {Complex}
+     */
+    sinh() {
+      var a = this["re"];
+      var b = this["im"];
+      return new _Complex(sinh(a) * Math.cos(b), cosh(a) * Math.sin(b));
+    }
+    /**
+     * Calculate the complex cosh
+     *
+     * @returns {Complex}
+     */
+    cosh() {
+      var a = this["re"];
+      var b = this["im"];
+      return new _Complex(cosh(a) * Math.cos(b), sinh(a) * Math.sin(b));
+    }
+    /**
+     * Calculate the complex tanh
+     *
+     * @returns {Complex}
+     */
+    tanh() {
+      var a = 2 * this["re"];
+      var b = 2 * this["im"];
+      var d = cosh(a) + Math.cos(b);
+      return new _Complex(sinh(a) / d, Math.sin(b) / d);
+    }
+    /**
+     * Calculate the complex coth
+     *
+     * @returns {Complex}
+     */
+    coth() {
+      var a = 2 * this["re"];
+      var b = 2 * this["im"];
+      var d = cosh(a) - Math.cos(b);
+      return new _Complex(sinh(a) / d, -Math.sin(b) / d);
+    }
+    /**
+     * Calculate the complex coth
+     *
+     * @returns {Complex}
+     */
+    csch() {
+      var a = this["re"];
+      var b = this["im"];
+      var d = Math.cos(2 * b) - cosh(2 * a);
+      return new _Complex(-2 * sinh(a) * Math.cos(b) / d, 2 * cosh(a) * Math.sin(b) / d);
+    }
+    /**
+     * Calculate the complex sech
+     *
+     * @returns {Complex}
+     */
+    sech() {
+      var a = this["re"];
+      var b = this["im"];
+      var d = Math.cos(2 * b) + cosh(2 * a);
+      return new _Complex(2 * cosh(a) * Math.cos(b) / d, -2 * sinh(a) * Math.sin(b) / d);
+    }
+    /**
+     * Calculate the complex asinh
+     *
+     * @returns {Complex}
+     */
+    asinh() {
+      var tmp = this["im"];
+      this["im"] = -this["re"];
+      this["re"] = tmp;
+      var res = this["asin"]();
+      this["re"] = -this["im"];
+      this["im"] = tmp;
+      tmp = res["re"];
+      res["re"] = -res["im"];
+      res["im"] = tmp;
+      return res;
+    }
+    /**
+     * Calculate the complex acosh
+     *
+     * @returns {Complex}
+     */
+    acosh() {
+      var res = this["acos"]();
+      if (res["im"] <= 0) {
+        var tmp = res["re"];
+        res["re"] = -res["im"];
+        res["im"] = tmp;
+      } else {
+        var tmp = res["im"];
+        res["im"] = -res["re"];
+        res["re"] = tmp;
+      }
+      return res;
+    }
+    /**
+     * Calculate the complex atanh
+     *
+     * @returns {Complex}
+     */
+    atanh() {
+      var a = this["re"];
+      var b = this["im"];
+      var noIM = a > 1 && b === 0;
+      var oneMinus = 1 - a;
+      var onePlus = 1 + a;
+      var d = oneMinus * oneMinus + b * b;
+      var x = d !== 0 ? new _Complex((onePlus * oneMinus - b * b) / d, (b * oneMinus + onePlus * b) / d) : new _Complex(a !== -1 ? a / 0 : 0, b !== 0 ? b / 0 : 0);
+      var temp = x["re"];
+      x["re"] = logHypot(x["re"], x["im"]) / 2;
+      x["im"] = Math.atan2(x["im"], temp) / 2;
+      if (noIM) {
+        x["im"] = -x["im"];
+      }
+      return x;
+    }
+    /**
+     * Calculate the complex acoth
+     *
+     * @returns {Complex}
+     */
+    acoth() {
+      var a = this["re"];
+      var b = this["im"];
+      if (a === 0 && b === 0) {
+        return new _Complex(0, Math.PI / 2);
+      }
+      var d = a * a + b * b;
+      return d !== 0 ? new _Complex(a / d, -b / d).atanh() : new _Complex(a !== 0 ? a / 0 : 0, b !== 0 ? -b / 0 : 0).atanh();
+    }
+    /**
+     * Calculate the complex acsch
+     *
+     * @returns {Complex}
+     */
+    acsch() {
+      var a = this["re"];
+      var b = this["im"];
+      if (b === 0) {
+        return new _Complex(a !== 0 ? Math.log(a + Math.sqrt(a * a + 1)) : Infinity, 0);
+      }
+      var d = a * a + b * b;
+      return d !== 0 ? new _Complex(a / d, -b / d).asinh() : new _Complex(a !== 0 ? a / 0 : 0, b !== 0 ? -b / 0 : 0).asinh();
+    }
+    /**
+     * Calculate the complex asech
+     *
+     * @returns {Complex}
+     */
+    asech() {
+      var a = this["re"];
+      var b = this["im"];
+      if (this["isZero"]()) {
+        return _Complex["INFINITY"];
+      }
+      var d = a * a + b * b;
+      return d !== 0 ? new _Complex(a / d, -b / d).acosh() : new _Complex(a !== 0 ? a / 0 : 0, b !== 0 ? -b / 0 : 0).acosh();
+    }
+    /**
+     * Calculate the complex inverse 1/z
+     *
+     * @returns {Complex}
+     */
+    inverse() {
+      if (this["isZero"]()) {
+        return _Complex["INFINITY"];
+      }
+      if (this["isInfinite"]()) {
+        return _Complex["ZERO"];
+      }
+      var a = this["re"];
+      var b = this["im"];
+      var d = a * a + b * b;
+      return new _Complex(a / d, -b / d);
+    }
+    /**
+     * Returns the complex conjugate
+     *
+     * @returns {Complex}
+     */
+    conjugate() {
+      return new _Complex(this["re"], -this["im"]);
+    }
+    /**
+     * Gets the negated complex number
+     *
+     * @returns {Complex}
+     */
+    neg() {
+      return new _Complex(-this["re"], -this["im"]);
+    }
+    /**
+     * Ceils the actual complex number
+     *
+     * @returns {Complex}
+     */
+    ceil(places) {
+      places = Math.pow(10, places || 0);
+      return new _Complex(Math.ceil(this["re"] * places) / places, Math.ceil(this["im"] * places) / places);
+    }
+    /**
+     * Floors the actual complex number
+     *
+     * @returns {Complex}
+     */
+    floor(places) {
+      places = Math.pow(10, places || 0);
+      return new _Complex(Math.floor(this["re"] * places) / places, Math.floor(this["im"] * places) / places);
+    }
+    /**
+     * Ceils the actual complex number
+     *
+     * @returns {Complex}
+     */
+    round(places) {
+      places = Math.pow(10, places || 0);
+      return new _Complex(Math.round(this["re"] * places) / places, Math.round(this["im"] * places) / places);
+    }
+    /**
+     * Compares two complex numbers
+     *
+     * **Note:** new Complex(Infinity).equals(Infinity) === false
+     *
+     * @returns {boolean}
+     */
+    equals(a, b) {
+      var z = new _Complex(a, b);
+      return Math.abs(z["re"] - this["re"]) <= _Complex["EPSILON"] && Math.abs(z["im"] - this["im"]) <= _Complex["EPSILON"];
+    }
+    /**
+     * Clones the actual object
+     *
+     * @returns {Complex}
+     */
+    clone() {
+      return new _Complex(this["re"], this["im"]);
+    }
+    /**
+     * Gets a string of the actual complex number
+     *
+     * @returns {string}
+     */
+    toString() {
+      var a = this["re"];
+      var b = this["im"];
+      var ret = "";
+      if (this["isNaN"]()) {
+        return "NaN";
+      }
+      if (this["isInfinite"]()) {
+        return "Infinity";
+      }
+      if (Math.abs(a) < _Complex["EPSILON"]) {
+        a = 0;
+      }
+      if (Math.abs(b) < _Complex["EPSILON"]) {
+        b = 0;
+      }
+      if (b === 0) {
+        return ret + a;
+      }
+      if (a !== 0) {
+        ret += a;
+        ret += " ";
+        if (b < 0) {
+          b = -b;
+          ret += "-";
+        } else {
+          ret += "+";
+        }
+        ret += " ";
+      } else if (b < 0) {
+        b = -b;
+        ret += "-";
+      }
+      if (1 !== b) {
+        ret += b;
+      }
+      return ret + "i";
+    }
+    /**
+     * Returns the actual number as a vector
+     *
+     * @returns {Array}
+     */
+    toVector() {
+      return [this["re"], this["im"]];
+    }
+    /**
+     * Returns the actual real value of the current object
+     *
+     * @returns {number|null}
+     */
+    valueOf() {
+      if (this["im"] === 0) {
+        return this["re"];
+      }
+      return null;
+    }
+    /**
+     * Determines whether a complex number is not on the Riemann sphere.
+     *
+     * @returns {boolean}
+     */
+    isNaN() {
+      return isNaN(this["re"]) || isNaN(this["im"]);
+    }
+    /**
+     * Determines whether or not a complex number is at the zero pole of the
+     * Riemann sphere.
+     *
+     * @returns {boolean}
+     */
+    isZero() {
+      return this["im"] === 0 && this["re"] === 0;
+    }
+    /**
+     * Determines whether a complex number is not at the infinity pole of the
+     * Riemann sphere.
+     *
+     * @returns {boolean}
+     */
+    isFinite() {
+      return isFinite(this["re"]) && isFinite(this["im"]);
+    }
+    /**
+     * Determines whether or not a complex number is at the infinity pole of the
+     * Riemann sphere.
+     *
+     * @returns {boolean}
+     */
+    isInfinite() {
+      return !(this["isNaN"]() || this["isFinite"]());
+    }
+  };
+  Complex["ZERO"] = new Complex(0, 0);
+  Complex["ONE"] = new Complex(1, 0);
+  Complex["I"] = new Complex(0, 1);
+  Complex["PI"] = new Complex(Math.PI, 0);
+  Complex["E"] = new Complex(Math.E, 0);
+  Complex["INFINITY"] = new Complex(Infinity, Infinity);
+  Complex["NAN"] = new Complex(NaN, NaN);
+  Complex["EPSILON"] = 1e-15;
+
   // src/compute-engine/numerics/numeric-complex.ts
+  var LANCZOS_G = 7;
+  var LANCZOS_P = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    9984369578019572e-21,
+    15056327351493116e-23
+  ];
+  var SQRT_2PI = Math.sqrt(2 * Math.PI);
+  var HALF_LOG_2PI = 0.5 * Math.log(2 * Math.PI);
   function gamma2(c) {
-    return c;
+    if (c.re < 0.5) {
+      const sinPiZ = c.mul(Math.PI).sin();
+      return new Complex(Math.PI, 0).div(sinPiZ.mul(gamma2(new Complex(1, 0).sub(c))));
+    }
+    const z = c.sub(1);
+    let x = new Complex(LANCZOS_P[0], 0);
+    for (let i = 1; i < LANCZOS_G + 2; i++)
+      x = x.add(new Complex(LANCZOS_P[i], 0).div(z.add(i)));
+    const t = z.add(LANCZOS_G + 0.5);
+    return new Complex(SQRT_2PI, 0).mul(t.pow(z.add(0.5))).mul(t.neg().exp()).mul(x);
   }
   function gammaln2(c) {
-    return c;
+    if (c.re < 0.5) {
+      const sinPiZ = c.mul(Math.PI).sin();
+      return new Complex(Math.PI, 0).div(sinPiZ).log().sub(gammaln2(new Complex(1, 0).sub(c)));
+    }
+    const z = c.sub(1);
+    let x = new Complex(LANCZOS_P[0], 0);
+    for (let i = 1; i < LANCZOS_G + 2; i++)
+      x = x.add(new Complex(LANCZOS_P[i], 0).div(z.add(i)));
+    const t = z.add(LANCZOS_G + 0.5);
+    return new Complex(HALF_LOG_2PI, 0).add(z.add(0.5).mul(t.log())).sub(t).add(x.log());
   }
 
   // src/numerics.ts
-  var version = "0.57.0";
+  var version = "0.59.0";
   return __toCommonJS(numerics_exports);
 })();
+/*! Bundled license information:
+
+complex-esm/dist/src/complex.js:
+  (**
+   * @license Complex.js v2.1.1 12/05/2020
+   *
+   * Copyright (c) 2020, Robert Eisele (robert@xarg.org)
+   * Dual licensed under the MIT or GPL Version 2 licenses.
+   **)
+*/
 Object.assign(exports, Numerics); Object.defineProperty(exports, '__esModule', { value: true });}));