@cortex-js/compute-engine 0.57.0 → 0.59.0

package/dist/numerics.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.57.0 */
+/** Compute Engine 0.59.0 */
 
 // src/compute-engine/numeric-value/types.ts
 var NumericValue = class {
@@ -153,6 +153,7 @@ function fpexp(x, scale) {
   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);
@@ -802,9 +803,11 @@ var BigDecimal = class _BigDecimal {
     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;
@@ -849,7 +852,10 @@ var BigDecimal = class _BigDecimal {
         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;
@@ -882,7 +888,19 @@ var BigDecimal = class _BigDecimal {
       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. */
@@ -1123,6 +1141,20 @@ function fromFixedPoint(fp, scale, targetPrecision) {
   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;
@@ -1133,9 +1165,13 @@ BigDecimal.prototype.sqrt = function() {
   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;
@@ -1149,10 +1185,13 @@ BigDecimal.prototype.cbrt = function() {
   }
   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);
@@ -1181,7 +1220,8 @@ BigDecimal.prototype.cbrt = function() {
     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();
@@ -1196,11 +1236,27 @@ BigDecimal.prototype.exp = function() {
     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;
@@ -1212,10 +1268,16 @@ BigDecimal.prototype.ln = function() {
   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);
@@ -1235,7 +1297,10 @@ BigDecimal.prototype.sin = function() {
   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);
@@ -1246,6 +1311,8 @@ BigDecimal.prototype.cos = function() {
   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);
@@ -1255,7 +1322,10 @@ BigDecimal.prototype.tan = function() {
   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) {
@@ -1273,7 +1343,9 @@ BigDecimal.prototype.atan = function() {
     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);
@@ -1290,7 +1362,9 @@ BigDecimal.prototype.asin = function() {
     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;
@@ -1353,6 +1427,23 @@ BigDecimal.prototype.sinh = function() {
     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);
@@ -1363,6 +1454,9 @@ BigDecimal.prototype.cosh = function() {
   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);
@@ -1374,6 +1468,21 @@ BigDecimal.prototype.tanh = function() {
     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));
 };
@@ -1460,9 +1569,7 @@ function bigint(a) {
   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;
@@ -2743,7 +2850,8 @@ function canonicalInteger(n, exponent) {
       [1, 5],
       [1, 6],
       [1, 7],
-      [1, 8],
+      [2, 2],
+      // √8 = 2√2
       [3, 1],
       [1, 10],
       [1, 11],
@@ -2755,7 +2863,8 @@ function canonicalInteger(n, exponent) {
       [1, 17],
       [3, 2],
       [1, 19],
-      [1, 20]
+      [2, 5]
+      // √20 = 2√5
     ][n];
     if (result) return result;
   }
@@ -2780,7 +2889,8 @@ function gcd(a, b) {
 }
 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) {
@@ -3335,12 +3445,23 @@ var PRIMITIVE_TYPES = [
   "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
@@ -4050,19 +4171,13 @@ var Parser = class {
     );
     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();
           }
         }
       }
@@ -4103,19 +4218,13 @@ var Parser = class {
     );
     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();
           }
         }
       }
@@ -4146,16 +4255,30 @@ var Parser = class {
     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;
   }
@@ -4169,35 +4292,11 @@ var Parser = class {
     }
     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") {
@@ -4382,6 +4481,18 @@ var Parser = class {
           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,
@@ -4396,7 +4507,7 @@ var Parser = class {
   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 });
       }
@@ -4730,14 +4841,32 @@ function buildTypeFromAST(node, typeResolver) {
 }
 
 // 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(
@@ -4812,19 +4941,36 @@ var PRIMITIVE_SUBTYPES = {
   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";
@@ -4839,7 +4985,7 @@ function isSubtype(lhs, rhs) {
       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);
@@ -5069,7 +5215,7 @@ function isSubtype(lhs, rhs) {
 }
 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;
@@ -5077,7 +5223,7 @@ function isNumeric(type) {
 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;
@@ -5085,7 +5231,7 @@ function isScalar(type) {
 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) {
@@ -5124,13 +5270,75 @@ function widen2(a, b) {
   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";
@@ -5140,35 +5348,26 @@ function superType(a, b) {
   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 {
@@ -5386,6 +5585,10 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     });
   }
   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({
@@ -5504,7 +5707,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
       } 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;
       }
@@ -5639,19 +5842,52 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     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) {
@@ -5750,7 +5986,7 @@ function gcd3(a, b) {
   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;
@@ -5930,8 +6166,8 @@ var BigNumericValue = class _BigNumericValue extends NumericValue {
     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) {
@@ -5958,7 +6194,7 @@ var BigNumericValue = class _BigNumericValue extends NumericValue {
     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);
     }
@@ -5988,7 +6224,7 @@ var BigNumericValue = class _BigNumericValue extends NumericValue {
     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);
     }
@@ -6011,7 +6247,11 @@ var BigNumericValue = class _BigNumericValue extends NumericValue {
     }
     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];
@@ -6045,13 +6285,18 @@ var BigNumericValue = class _BigNumericValue extends NumericValue {
         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) {
@@ -6095,13 +6340,13 @@ var BigNumericValue = class _BigNumericValue extends NumericValue {
       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()),
@@ -6367,7 +6612,7 @@ var MachineNumericValue = class _MachineNumericValue extends NumericValue {
     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) {
@@ -6477,11 +6722,17 @@ var MachineNumericValue = class _MachineNumericValue extends NumericValue {
         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))
         });
       }
     }
@@ -6500,14 +6751,15 @@ var MachineNumericValue = class _MachineNumericValue extends NumericValue {
       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)
@@ -6628,10 +6880,10 @@ var MachineNumericValue = class _MachineNumericValue extends NumericValue {
   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;
@@ -6713,42 +6965,20 @@ function interval(expr) {
   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;
 }
@@ -6931,6 +7161,7 @@ function bigPopulationStandardDeviation(values) {
 function kurtosis(values) {
   let sum = 0;
   let sum2 = 0;
+  let sum3 = 0;
   let sum4 = 0;
   let count = 0;
   for (const op of values) {
@@ -6938,16 +7169,21 @@ function kurtosis(values) {
     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) {
@@ -6955,15 +7191,15 @@ function bigKurtosis(values) {
     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;
@@ -6979,9 +7215,11 @@ function skewness(values) {
     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;
@@ -6997,10 +7235,10 @@ function bigSkewness(values) {
     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 = {};
@@ -7051,18 +7289,12 @@ function bigQuartiles(values) {
   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
@@ -7437,9 +7669,14 @@ var lanczos_7_c = [
 ];
 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));
@@ -7450,31 +7687,62 @@ function gamma(z) {
   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;
@@ -8424,7 +8692,7 @@ function fresnelS(x) {
     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);
@@ -8449,7 +8717,7 @@ function fresnelC(x) {
     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);
@@ -8466,16 +8734,894 @@ function sinc(x) {
   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";
 export {
   BigNumericValue,
   DEFAULT_PRECISION,
@@ -8618,3 +9764,13 @@ export {
   version,
   zeta
 };
+/*! 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.
+   **)
+*/