@cortex-js/compute-engine 0.35.1 → 0.35.2

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.1 */
+/** Compute Engine 0.35.2 */
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -5441,15 +5441,14 @@ function bigint(a) {
   }
   if (a instanceof Decimal) {
     if (!a.isInteger()) return null;
-    return bigint(a.toString());
+    return BigInt(a.toFixed(0));
   }
   let s = a.toLowerCase();
-  const m = s.match(/([+-]?[0-9]*)(?:\.([0-9]+))?e([+-]?[0-9]+)$/);
+  const m = s.match(/^([+-]?[0-9]+)e([+-]?[0-9]+)$/);
   if (m) {
-    const exp3 = parseInt(m[3]);
-    const pad = exp3 - (m[2] ? m[2].length : 0);
-    if (pad < 0) return null;
-    s = (m[1] ?? "") + (m[2] ?? "") + "0".repeat(pad);
+    const exp3 = parseInt(m[2]);
+    if (exp3 < 0) return null;
+    s = m[1] + "0".repeat(exp3);
   }
   const i = s.indexOf(".");
   if (i >= 0) return null;
@@ -9760,6 +9759,23 @@ function serializeScientificNotationNumber(valString, options, expMultiple = 1)
   if (!m) return serializeAutoNotationNumber(valString, options);
   let exponent = parseInt(m[2]);
   let mantissa = m[1];
+  {
+    const signMatch = mantissa.match(/^(-?)/);
+    const sign3 = signMatch ? signMatch[1] : "";
+    const unsigned = sign3 ? mantissa.substring(1) : mantissa;
+    const parts = unsigned.match(/^(\d+)(?:\.(\d*))?$/);
+    if (parts) {
+      let whole = parts[1];
+      let fraction = parts[2] ?? "";
+      if (whole.length > 1) {
+        fraction = whole.slice(1) + fraction;
+        exponent += whole.length - 1;
+        whole = whole[0];
+      }
+      mantissa = sign3 + whole;
+      if (fraction) mantissa += "." + fraction;
+    }
+  }
   if (Math.abs(exponent) % expMultiple !== 0) {
     const adjust = exponent > 0 ? exponent % expMultiple : -((expMultiple + exponent) % expMultiple);
     exponent = exponent >= 0 ? exponent - adjust : exponent + adjust;
@@ -11718,7 +11734,8 @@ var init_exact_numeric_value = __esm({
             }
           } else {
             console.assert(isSubtype(value.type, "integer"));
-            rationalSum = add2(rationalSum, [value.re, 1]);
+            const intValue = BigInt(value.bignumRe.toFixed(0));
+            rationalSum = add2(rationalSum, [intValue, BigInt(1)]);
           }
         }
         if (isZero(rationalSum) && radicals.length === 0) {
@@ -12084,11 +12101,14 @@ function canonicalDivide(op1, op2) {
   const ce = op1.engine;
   if (!op1.isValid || !op2.isValid) return ce._fn("Divide", [op1, op2]);
   if (op1.isNaN || op2.isNaN) return ce.NaN;
-  const op2IsConstantExpression = op2.symbols.length === 0 && !op2.isNumberLiteral;
+  const op2IsConstantExpression = op2.unknowns.length === 0 && !op2.isNumberLiteral;
   if (op2.is(0)) return op1.is(0) ? ce.NaN : ce.ComplexInfinity;
   if (op1.is(0) && op2.isFinite !== false) {
     if (op2IsConstantExpression)
-      return ce._fn("Divide", [op1, op2], { canonical: false });
+      return ce.function("Divide", [op1, op2], {
+        canonical: false,
+        structural: true
+      });
     return ce.Zero;
   }
   if (op2.isInfinity) return op1.isInfinity ? ce.NaN : ce.Zero;
@@ -12097,7 +12117,10 @@ function canonicalDivide(op1, op2) {
       return ce.One;
     if (op1.isSame(op2)) {
       if (op2IsConstantExpression)
-        return ce._fn("Divide", [op1, op2], { canonical: false });
+        return ce.function("Divide", [op1, op2], {
+          canonical: false,
+          structural: true
+        });
       return ce.One;
     }
   }
@@ -15248,7 +15271,7 @@ function asRadical(expr) {
 }
 function canonicalPower(a, b) {
   const ce = a.engine;
-  const fullyCanonical = a.isCanonical && b.isCanonical;
+  const fullyCanonical = (a.isCanonical || a.isStructural) && (b.isCanonical || b.isStructural);
   const unchanged = () => ce._fn("Power", [a, b], { canonical: fullyCanonical });
   if (a.operator === "Power") {
     const [base, aPow] = a.ops;
@@ -15294,7 +15317,7 @@ function canonicalPower(a, b) {
       if (a.is(-1)) return ce.NegativeOne;
       if (a.is(1)) return ce.One;
     }
-    if (!a.isCanonical)
+    if (!(a.isCanonical || a.isStructural))
       return ce._fn("Power", [a, ce.number(-1)], { canonical: false });
     return a.inv();
   }
@@ -15350,10 +15373,10 @@ function canonicalPower(a, b) {
     }
   }
   if (b.is(0.5))
-    return a.isCanonical ? canonicalRoot(a, 2) : ce._fn("Sqrt", [a], { canonical: false });
+    return a.isCanonical || a.isStructural ? canonicalRoot(a, 2) : ce._fn("Sqrt", [a], { canonical: false });
   const r = asRational(b);
   if (r !== void 0 && r[0] === 1 && r[1] !== 1)
-    return a.isCanonical ? canonicalRoot(a, ce.number(r[1])) : ce._fn("Root", [a, ce.number(r[1])], { canonical: false });
+    return a.isCanonical || a.isStructural ? canonicalRoot(a, ce.number(r[1])) : ce._fn("Root", [a, ce.number(r[1])], { canonical: false });
   return unchanged();
 }
 function canonicalRoot(a, b) {
@@ -15372,14 +15395,14 @@ function canonicalRoot(a, b) {
         if (v.numericValue.isExact) return v;
       }
     }
-    return ce._fn("Sqrt", [a], { canonical: a.isCanonical });
+    return ce._fn("Sqrt", [a], { canonical: a.isCanonical || a.isStructural });
   }
   return ce._fn("Root", [a, typeof b === "number" ? ce.number(b) : b], {
-    canonical: a.isCanonical && (typeof b === "number" || b.isCanonical)
+    canonical: (a.isCanonical || a.isStructural) && (typeof b === "number" || b.isCanonical || b.isStructural)
   });
 }
 function pow2(x, exp3, { numericApproximation }) {
-  if (!x.isCanonical || typeof exp3 !== "number" && !exp3.isCanonical)
+  if (!(x.isCanonical || x.isStructural) || typeof exp3 !== "number" && !(exp3.isCanonical || exp3.isStructural))
     return x.engine._fn("Power", [x, x.engine.box(exp3)], { canonical: false });
   if (numericApproximation) {
     if (x.isNumberLiteral) {
@@ -15475,7 +15498,7 @@ function pow2(x, exp3, { numericApproximation }) {
   return ce._fn("Power", [x, ce.box(exp3)]);
 }
 function root(a, b, { numericApproximation }) {
-  if (!a.isCanonical || !b.isCanonical)
+  if (!(a.isCanonical || a.isStructural) || !(b.isCanonical || b.isStructural))
     return a.engine._fn("Root", [a, b], { canonical: false });
   if (numericApproximation) {
     if (a.isNumberLiteral && b.isNumberLiteral) {
@@ -15681,7 +15704,7 @@ function order(a, b) {
   return (a.complexity ?? DEFAULT_COMPLEXITY) - (b.complexity ?? DEFAULT_COMPLEXITY);
 }
 function canonicalOrder(expr, { recursive = false }) {
-  if (expr.isCanonical || !expr.ops) return expr;
+  if (expr.isCanonical || expr.isStructural || !expr.ops) return expr;
   let ops = expr.ops;
   if (recursive) ops = ops.map((x) => canonicalOrder(x, { recursive }));
   ops = sortOperands(expr.operator, ops);
@@ -23795,6 +23818,24 @@ var init_utils5 = __esm({
 });
 
 // src/compute-engine/boxed-expression/validate.ts
+function typeCouldBeCollection(type2) {
+  if (typeof type2 === "string") {
+    return type2 === "collection" || type2 === "indexed_collection" || type2 === "list" || type2 === "set" || type2 === "tuple" || type2 === "any";
+  }
+  if (type2.kind === "list" || type2.kind === "set" || type2.kind === "tuple")
+    return true;
+  if (type2.kind === "union") return type2.types.some((t) => typeCouldBeCollection(t));
+  return false;
+}
+function typeCouldBeNumericCollection(type2) {
+  if (typeof type2 === "string") {
+    return type2 === "list" || type2 === "set" || type2 === "collection" || type2 === "indexed_collection";
+  }
+  if (type2.kind === "list" || type2.kind === "set") return true;
+  if (type2.kind === "union")
+    return type2.types.some((t) => typeCouldBeNumericCollection(t));
+  return false;
+}
 function checkArity(ce, ops, count) {
   ops = flatten(ops);
   if (!ce.strict) return ops;
@@ -23844,7 +23885,9 @@ function checkNumericArgs(ce, ops, options) {
       xs.push(op);
     } else if (op.symbol && !ce.lookupDefinition(op.symbol)) {
       xs.push(op);
-    } else if (op.type.isUnknown) {
+    } else if (op.type.isUnknown || op.type.type === "any") {
+      xs.push(op);
+    } else if (typeCouldBeNumericCollection(op.type.type)) {
       xs.push(op);
     } else if (isBoxedTensor(op)) {
       xs.push(op);
@@ -23928,11 +23971,11 @@ function validateArguments(ce, ops, signature, lazy, threadable) {
       isValid = false;
       continue;
     }
-    if (op.type.isUnknown) {
+    if (op.type.isUnknown || op.type.type === "any") {
       result.push(op);
       continue;
     }
-    if (threadable && isFiniteIndexedCollection(op)) {
+    if (threadable && (isFiniteIndexedCollection(op) || typeCouldBeCollection(op.type.type))) {
       result.push(op);
       continue;
     }
@@ -23967,12 +24010,12 @@ function validateArguments(ce, ops, signature, lazy, threadable) {
       i += 1;
       continue;
     }
-    if (op.type.isUnknown) {
+    if (op.type.isUnknown || op.type.type === "any") {
       result.push(op);
       i += 1;
       continue;
     }
-    if (threadable && isFiniteIndexedCollection(op)) {
+    if (threadable && (isFiniteIndexedCollection(op) || typeCouldBeCollection(op.type.type))) {
       result.push(op);
       i += 1;
       continue;
@@ -24005,11 +24048,11 @@ function validateArguments(ce, ops, signature, lazy, threadable) {
         isValid = false;
         continue;
       }
-      if (op.type.isUnknown) {
+      if (op.type.isUnknown || op.type.type === "any") {
         result.push(op);
         continue;
       }
-      if (threadable && isFiniteIndexedCollection(op)) {
+      if (threadable && (isFiniteIndexedCollection(op) || typeCouldBeCollection(op.type.type))) {
         result.push(op);
         continue;
       }
@@ -24039,20 +24082,22 @@ function validateArguments(ce, ops, signature, lazy, threadable) {
   i = 0;
   for (const param of params) {
     if (!lazy) {
-      if (!threadable || !isFiniteIndexedCollection(ops[i]))
+      if (!threadable || !isFiniteIndexedCollection(ops[i]) && !typeCouldBeCollection(ops[i].type.type))
         ops[i].infer(param);
     }
     i += 1;
   }
   for (const param of optParams) {
     if (!ops[i]) break;
-    if (!threadable || !isFiniteIndexedCollection(ops[i])) ops[i]?.infer(param);
+    if (!threadable || !isFiniteIndexedCollection(ops[i]) && !typeCouldBeCollection(ops[i].type.type))
+      ops[i]?.infer(param);
     i += 1;
   }
   if (varParam) {
     for (const op of ops.slice(i)) {
       if (!lazy) {
-        if (!threadable || !isFiniteIndexedCollection(op)) op.infer(varParam);
+        if (!threadable || !isFiniteIndexedCollection(op) && !typeCouldBeCollection(op.type.type))
+          op.infer(varParam);
       }
       i += 1;
     }
@@ -35464,6 +35509,12 @@ function canonicalForm(expr, forms, scope) {
         throw Error("Invalid canonical form");
     }
   }
+  if (expr.isFunctionExpression && expr.isCanonical) {
+    expr = expr.engine.function(expr.operator, [...expr.ops], {
+      canonical: false,
+      structural: true
+    });
+  }
   return expr;
 }
 function flattenForm(expr) {
@@ -35545,10 +35596,7 @@ function multiplyForm(expr) {
   if (!expr.ops) return expr;
   const ops = expr.ops.map(multiplyForm);
   if (expr.operator === "Multiply")
-    return canonicalMultiply(
-      expr.engine,
-      ops.map((x) => x.canonical)
-    );
+    return canonicalMultiply(expr.engine, ops);
   if (expr.operator === "Negate")
     return canonicalMultiply(expr.engine, [ops[0], expr.engine.NegativeOne]);
   return expr;
@@ -45682,7 +45730,7 @@ var BoxedFunction = class extends _BoxedExpression {
     return void 0;
   }
   get isCanonical() {
-    return this._def !== void 0 && this._def !== null;
+    return this._def !== void 0 && this._def !== null && !this._isStructural;
   }
   get isPure() {
     if (this._isPure !== void 0) return this._isPure;
@@ -45849,7 +45897,7 @@ var BoxedFunction = class extends _BoxedExpression {
   subs(sub3, options) {
     options ??= { canonical: void 0 };
     if (options.canonical === void 0)
-      options = { canonical: this.isCanonical };
+      options = { canonical: this.isCanonical || this.isStructural };
     const ops = this._ops.map((x) => x.subs(sub3, options));
     if (!ops.every((x) => x.isValid))
       return this.engine.function(this._operator, ops, { canonical: false });
@@ -45921,7 +45969,7 @@ var BoxedFunction = class extends _BoxedExpression {
     return this.numeratorDenominator[1];
   }
   get numeratorDenominator() {
-    if (!this.isCanonical) return [this, this.engine.One];
+    if (!(this.isCanonical || this.isStructural)) return [this, this.engine.One];
     if (this.isNumber !== true)
       return [this.engine.Nothing, this.engine.Nothing];
     const operator2 = this.operator;
@@ -45959,11 +46007,11 @@ var BoxedFunction = class extends _BoxedExpression {
   // ALGEBRAIC OPERATIONS
   //
   neg() {
-    if (!this.isCanonical) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
     return negate(this);
   }
   inv() {
-    if (!this.isCanonical) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
     if (this.isOne) return this;
     if (this.isNegativeOne) return this;
     if (this.operator === "Sqrt") return this.op1.inv().sqrt();
@@ -45984,7 +46032,7 @@ var BoxedFunction = class extends _BoxedExpression {
     return this.engine._fn("Divide", [this.engine.One, this]);
   }
   abs() {
-    if (!this.isCanonical) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
     if (this.operator === "Abs" || this.operator === "Negate") return this;
     if (this.isNonNegative) return this;
     if (this.isNonPositive) return this.neg();
@@ -45992,11 +46040,11 @@ var BoxedFunction = class extends _BoxedExpression {
   }
   add(rhs) {
     if (rhs === 0) return this;
-    if (!this.isCanonical) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
     return add3(this, this.engine.box(rhs));
   }
   mul(rhs) {
-    if (!this.isCanonical) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
     if (rhs === 0) return this.engine.Zero;
     if (rhs === 1) return this;
     if (rhs === -1) return this.neg();
@@ -46008,14 +46056,14 @@ var BoxedFunction = class extends _BoxedExpression {
     return mul3(this, this.engine.box(rhs));
   }
   div(rhs) {
-    if (!this.isCanonical) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
     return div2(this, rhs);
   }
   pow(exp3) {
     return pow2(this, exp3, { numericApproximation: false });
   }
   root(exp3) {
-    if (!this.isCanonical || typeof exp3 !== "number" && !exp3.isCanonical)
+    if (!(this.isCanonical || this.isStructural) || typeof exp3 !== "number" && !(exp3.isCanonical || exp3.isStructural))
       throw new Error("Not canonical");
     const e = typeof exp3 === "number" ? exp3 : exp3.im === 0 ? exp3.re : void 0;
     if (e === 0) return this.engine.NaN;
@@ -46074,7 +46122,7 @@ var BoxedFunction = class extends _BoxedExpression {
   }
   ln(semiBase) {
     const base = semiBase ? this.engine.box(semiBase) : void 0;
-    if (!this.isCanonical) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
     if (this.is(0)) return this.engine.NegativeInfinity;
     if (this.operator === "Exp") {
       if (!base) return this.op1;
@@ -46107,7 +46155,7 @@ var BoxedFunction = class extends _BoxedExpression {
     return this.engine._fn("Ln", [this]);
   }
   get complexity() {
-    if (!this.isCanonical) return void 0;
+    if (!(this.isCanonical || this.isStructural)) return void 0;
     return this.operatorDefinition?.complexity ?? DEFAULT_COMPLEXITY;
   }
   get baseDefinition() {
@@ -54694,12 +54742,11 @@ var ComputeEngine = class _ComputeEngine {
         bignum
       );
     if (value instanceof Decimal) {
-      if (value.isInteger() && value.e <= MAX_BIGINT_DIGITS)
-        return new ExactNumericValue(
-          bigint(value.toString()),
-          makeNumericValue,
-          bignum
-        );
+      if (value.isInteger() && value.e <= MAX_BIGINT_DIGITS) {
+        const n = bigint(value.toString());
+        if (n !== null)
+          return new ExactNumericValue(n, makeNumericValue, bignum);
+      }
       return makeNumericValue(value);
     }
     if (value instanceof Complex) {
@@ -55765,10 +55812,10 @@ function defToString(name, def, v) {
 // src/compute-engine.ts
 init_types6();
 init_base_compiler();
-var version = "0.35.1";
+var version = "0.35.2";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.35.1"
+  version: "0.35.2"
 };
 export {
   BaseCompiler,