solve-engine 1.0.0-beta.7 → 1.0.1

package/dist/{chunk-CYFK5SY2.js → chunk-O3ANBHSA.js}

@@ -1,5 +1,5 @@
-import { boolValue, symbolicValue, numberValue, matrixValue, errorValue } from './chunk-BVAR5J2F.js';
-import { ErrorFactory } from './chunk-6RDSQURE.js';
+import { boolValue, symbolicValue, numberValue, matrixValue, errorValue, checkedArray, faultedOperand } from './chunk-GQCOSXMG.js';
+import { ErrorFactory } from './chunk-3D7V24DG.js';
 
 // src/symbolic/Rational.ts
 var RATIONAL_ZERO = { n: 0n, d: 1n };
@@ -732,6 +732,17 @@ function divideOutConstant(numerator, denominator, original) {
   }
   return { kind: "div", left: fromPolynomial(numerator), right: fromPolynomial(denominator) };
 }
+function squareFreePart(coefficients) {
+  const trimmed = trim([...coefficients]);
+  if (trimmed.length <= 1) return monic(trimmed);
+  const derivative = [];
+  for (let power = 1; power < trimmed.length; power++) {
+    derivative.push(rationalMul(trimmed[power], { n: BigInt(power), d: 1n }));
+  }
+  const shared = coefficientGcd(trimmed, derivative);
+  if (shared.length <= 1) return monic(trimmed);
+  return monic(polynomialDivide(trimmed, shared).quotient);
+}
 
 // src/symbolic/Radicals.ts
 function exactIntegerSqrt(value) {
@@ -787,14 +798,15 @@ function signedSurdNode(value) {
 }
 
 // src/symbolic/Simplify.ts
-function flattenSum(node, negated, out) {
+function flattenSum(node, negated, out, depth = 0) {
+  if (depth >= MAX_SIMPLIFY_DEPTH) return false;
   switch (node.kind) {
     case "add":
-      return flattenSum(node.left, negated, out) && flattenSum(node.right, negated, out);
+      return flattenSum(node.left, negated, out, depth + 1) && flattenSum(node.right, negated, out, depth + 1);
     case "sub":
-      return flattenSum(node.left, negated, out) && flattenSum(node.right, !negated, out);
+      return flattenSum(node.left, negated, out, depth + 1) && flattenSum(node.right, !negated, out, depth + 1);
     case "neg":
-      return flattenSum(node.operand, !negated, out);
+      return flattenSum(node.operand, !negated, out, depth + 1);
     case "const":
       out.push({ coeff: negated ? rationalNeg(node.value) : node.value, name: null });
       return true;
@@ -917,7 +929,21 @@ function simplifySymbolic(node) {
       { limit: SYMBOLIC_MAX_NODES }
     );
   }
-  return simplifyNode(node);
+  const depthOnEntry = walkDepth;
+  try {
+    return simplifyNode(node);
+  } finally {
+    walkDepth = depthOnEntry;
+  }
+}
+var MAX_SIMPLIFY_DEPTH = 900;
+var walkDepth = 0;
+function simplifyNode(node) {
+  if (walkDepth >= MAX_SIMPLIFY_DEPTH) return node;
+  walkDepth++;
+  const simplified = simplifyNodeAt(node);
+  walkDepth--;
+  return simplified;
 }
 function asComplex(node) {
   if (node.kind === "complex") return node.value;
@@ -972,7 +998,7 @@ function foldComplexCall(name, args) {
       return null;
   }
 }
-function simplifyNode(node) {
+function simplifyNodeAt(node) {
   switch (node.kind) {
     case "const":
     case "complex":
@@ -1116,7 +1142,10 @@ function formatCoefficient(coeff, text) {
   if (coeff.n === -1n && coeff.d === 1n) return `-${text}`;
   return `${formatRational(coeff)}${text}`;
 }
-function formatFactor(node) {
+var MAX_FORMAT_DEPTH = 600;
+var ELIDED = "...";
+function formatFactor(node, depth) {
+  if (depth >= MAX_FORMAT_DEPTH) return ELIDED;
   switch (node.kind) {
     case "const":
       return formatRational(node.value);
@@ -1126,43 +1155,50 @@ function formatFactor(node) {
       return node.name;
     case "add":
     case "sub":
-      return `(${formatSymbolic(node)})`;
+      return `(${formatSum(node, depth)})`;
     case "neg":
-      return `-${formatFactor(node.operand)}`;
+      return `-${formatFactor(node.operand, depth + 1)}`;
     case "call":
-      return `${node.name}(${node.args.map(formatSymbolic).join(", ")})`;
+      return `${node.name}(${node.args.map((arg) => formatSum(arg, depth + 1)).join(", ")})`;
     case "pow": {
-      const base = isAtomic(node.base) ? formatFactor(node.base) : `(${formatSymbolic(node.base)})`;
-      const exponent = isAtomic(node.exponent) ? formatFactor(node.exponent) : `(${formatSymbolic(node.exponent)})`;
+      const base = isAtomic(node.base) ? formatFactor(node.base, depth + 1) : `(${formatSum(node.base, depth + 1)})`;
+      const exponent = isAtomic(node.exponent) ? formatFactor(node.exponent, depth + 1) : `(${formatSum(node.exponent, depth + 1)})`;
       return `${base}^${exponent}`;
     }
     case "mul": {
       const coeffVar = tryExtractCoeffVar(node);
       if (coeffVar) return formatCoefficient(coeffVar.coeff, coeffVar.name);
       const coeffPow = tryExtractCoeffPow(node);
-      if (coeffPow) return formatCoefficient(coeffPow.coeff, formatFactor(coeffPow.power));
+      if (coeffPow) return formatCoefficient(coeffPow.coeff, formatFactor(coeffPow.power, depth + 1));
       if (node.left.kind === "const" && node.right.kind === "mul") {
-        const inner = formatFactor(node.right);
+        const inner = formatFactor(node.right, depth + 1);
         if (!/^[\d.]/.test(inner)) return formatCoefficient(node.left.value, inner);
       }
-      return `${formatFactor(node.left)}*${formatFactor(node.right)}`;
+      return `${formatFactor(node.left, depth + 1)}*${formatFactor(node.right, depth + 1)}`;
+    }
+    case "div": {
+      const denominator = formatFactor(node.right, depth + 1);
+      const needsBrackets = node.right.kind === "mul" || node.right.kind === "div";
+      return `${formatFactor(node.left, depth + 1)}/${needsBrackets ? `(${denominator})` : denominator}`;
     }
-    case "div":
-      return `${formatFactor(node.left)}/${formatFactor(node.right)}`;
   }
 }
-function collectDisplayTerms(node, negated, out) {
+function collectDisplayTerms(node, negated, out, depth) {
+  if (depth >= MAX_FORMAT_DEPTH) {
+    out.push({ negated, text: ELIDED });
+    return;
+  }
   switch (node.kind) {
     case "add":
-      collectDisplayTerms(node.left, negated, out);
-      collectDisplayTerms(node.right, negated, out);
+      collectDisplayTerms(node.left, negated, out, depth + 1);
+      collectDisplayTerms(node.right, negated, out, depth + 1);
       return;
     case "sub":
-      collectDisplayTerms(node.left, negated, out);
-      collectDisplayTerms(node.right, !negated, out);
+      collectDisplayTerms(node.left, negated, out, depth + 1);
+      collectDisplayTerms(node.right, !negated, out, depth + 1);
       return;
     case "neg":
-      collectDisplayTerms(node.operand, !negated, out);
+      collectDisplayTerms(node.operand, !negated, out, depth + 1);
       return;
     case "const": {
       if (node.value.n === 0n) return;
@@ -1186,7 +1222,7 @@ function collectDisplayTerms(node, negated, out) {
       return;
     }
     default: {
-      const text = formatFactor(node);
+      const text = formatFactor(node, depth);
       const liftsSign = (node.kind === "mul" || node.kind === "div") && text.startsWith("-");
       if (liftsSign) out.push({ negated: !negated, text: text.slice(1) });
       else out.push({ negated, text });
@@ -1194,8 +1230,16 @@ function collectDisplayTerms(node, negated, out) {
   }
 }
 function formatSymbolic(node) {
+  try {
+    return formatSum(node, 0);
+  } catch (thrown) {
+    if (thrown instanceof RangeError) return ELIDED;
+    throw thrown;
+  }
+}
+function formatSum(node, depth) {
   const terms = [];
-  collectDisplayTerms(node, false, terms);
+  collectDisplayTerms(node, false, terms, depth);
   if (terms.length === 0) return "0";
   let out = "";
   terms.forEach((term, index) => {
@@ -1276,7 +1320,7 @@ function matrixMultiply(l, r) {
   }
   const resultRows = l.rows;
   const resultCols = r.cols;
-  const data = new Array(resultRows * resultCols);
+  const data = checkedArray(resultRows * resultCols, "matrix cells");
   for (let row = 0; row < resultRows; row++) {
     for (let col = 0; col < resultCols; col++) {
       if (useSymbolic) {
@@ -1297,6 +1341,37 @@ function matrixMultiply(l, r) {
   }
   return matrixValue(resultRows, resultCols, data);
 }
+function matrixPower(m, exponent) {
+  if (!isSquare(m)) {
+    return errorValue("MATRIX_POWER_REQUIRES_SQUARE_MATRIX", `^: only a square matrix can be raised to a power (got ${m.rows}x${m.cols}).`);
+  }
+  if (!Number.isInteger(exponent) || exponent < 0) {
+    return errorValue(
+      "MATRIX_POWER_REQUIRES_WHOLE_EXPONENT",
+      `^: a matrix can only be raised to a whole number of 0 or more (got ${exponent}); "^-1" means the inverse and "^T" the transpose.`
+    );
+  }
+  const n = m.rows;
+  const identity = new Array(n * n).fill(0);
+  for (let i = 0; i < n; i++) identity[i + i * n] = 1;
+  let accumulated = { rows: n, cols: n, data: identity, hasSymbolic: false };
+  let squared = m;
+  let remaining = exponent;
+  while (remaining > 0) {
+    if (remaining % 2 === 1) {
+      const product = matrixMultiply(accumulated, squared);
+      if (product.type === 13 /* Error */) return product;
+      accumulated = product.value;
+    }
+    remaining = Math.floor(remaining / 2);
+    if (remaining > 0) {
+      const doubled = matrixMultiply(squared, squared);
+      if (doubled.type === 13 /* Error */) return doubled;
+      squared = doubled.value;
+    }
+  }
+  return matrixValue(accumulated.rows, accumulated.cols, accumulated.data);
+}
 function matrixCompare(l, r, cmp) {
   if (!sameShape(l, r)) {
     return errorValue(
@@ -1326,7 +1401,52 @@ function toWorkingRows(m) {
   }
   return rows;
 }
+var EXACT_DETERMINANT_DIMENSION_LIMIT = 12;
+function toIntegerRows(m) {
+  if (m.rows > EXACT_DETERMINANT_DIMENSION_LIMIT) return null;
+  const rows = [];
+  for (let r = 0; r < m.rows; r++) {
+    const row = [];
+    for (let c = 0; c < m.cols; c++) {
+      const cell = matAt(m, r, c);
+      if (typeof cell !== "number" || !Number.isSafeInteger(cell)) return null;
+      row.push(BigInt(cell));
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function integerDeterminant(rows) {
+  const n = rows.length;
+  let previous = 1n;
+  let sign = 1n;
+  for (let k = 0; k < n - 1; k++) {
+    if (rows[k][k] === 0n) {
+      let candidate = -1;
+      for (let r = k + 1; r < n; r++) {
+        if (rows[r][k] !== 0n) {
+          candidate = r;
+          break;
+        }
+      }
+      if (candidate === -1) return 0n;
+      const swapped = rows[k];
+      rows[k] = rows[candidate];
+      rows[candidate] = swapped;
+      sign = -sign;
+    }
+    for (let i = k + 1; i < n; i++) {
+      for (let j = k + 1; j < n; j++) {
+        rows[i][j] = (rows[i][j] * rows[k][k] - rows[i][k] * rows[k][j]) / previous;
+      }
+    }
+    previous = rows[k][k];
+  }
+  return sign * rows[n - 1][n - 1];
+}
 function numericDeterminant(m) {
+  const integers = toIntegerRows(m);
+  if (integers !== null) return numberValue(Number(integerDeterminant(integers)));
   const n = m.rows;
   const a = toWorkingRows(m);
   let det = 1;
@@ -1445,17 +1565,17 @@ function symbolicInverse(m) {
         `Symbolic inverse: the pivot at row/col ${col} is exactly zero \u2014 this matrix's structure isn't invertible via this engine's diagonal-first symbolic elimination (no row-swapping); try reordering rows manually.`
       );
     }
-    for (let c = 0; c < 2 * n; c++) {
-      a[col][c] = simplifySymbolic({ kind: "div", left: a[col][c], right: pivot });
-    }
     for (let r = 0; r < n; r++) {
       if (r === col) continue;
-      const factor = simplifySymbolic(a[r][col]);
+      const factor = simplifySymbolic({ kind: "div", left: a[r][col], right: pivot });
       if (factor.kind === "const" && isRationalZero(factor.value)) continue;
       for (let c = 0; c < 2 * n; c++) {
         a[r][c] = simplifySymbolic({ kind: "sub", left: a[r][c], right: { kind: "mul", left: factor, right: a[col][c] } });
       }
     }
+    for (let c = 0; c < 2 * n; c++) {
+      a[col][c] = simplifySymbolic({ kind: "div", left: a[col][c], right: pivot });
+    }
   }
   const data = new Array(n * n);
   for (let r = 0; r < n; r++) {
@@ -1469,16 +1589,26 @@ function inverse(m) {
   }
   return m.hasSymbolic ? symbolicInverse(m) : numericInverse(m);
 }
-function collectionToValues(v) {
-  if (v.type === 13 /* Error */) return v;
+function tooLarge(length, maxElements) {
+  return errorValue(
+    "COLLECTION_TOO_LARGE",
+    `This collection has ${length} elements, past the limit of ${maxElements} (see the engine's vm.maxCollectionSize setting).`
+  );
+}
+function collectionToValues(v, maxElements = Number.POSITIVE_INFINITY) {
+  const faulted = faultedOperand(v);
+  if (faulted) return faulted;
   if (v.type === 7 /* Matrix */) {
     const m = v.value;
+    if (m.data.length > maxElements) return tooLarge(m.data.length, maxElements);
     return m.data.map(matrixEntryToValue);
   }
   if (v.type === 8 /* Range */) {
     const r = v.value;
-    const out = [];
-    for (let i = r.min; i <= r.max; i++) out.push(numberValue(i));
+    const length = r.max - r.min + 1;
+    if (length > maxElements) return tooLarge(length, maxElements);
+    const out = new Array(length);
+    for (let i = 0; i < length; i++) out[i] = numberValue(r.min + i);
     return out;
   }
   return errorValue(
@@ -1595,6 +1725,6 @@ var CURRENCY_DISPLAY = {
   CZK: { symbol: "K\u010D", position: "suffix", spaced: true }
 };
 
-export { COMPLEX_I, CURRENCY_DISPLAY, RATIONAL_ONE, RATIONAL_ZERO, callNode, cancelSymbolic, coefficientGcd, collectionToValues, columnMajorToRowMajor, compareMonomials, complex, complexNode, constNode, determinant, exactIntegerCbrt, exactIntegerSqrt, exactRationalSqrt2 as exactRationalSqrt, expandSymbolic, formatSymbolic, freeVariables, fromPolynomial, inBounds, inverse, isRationalOne, isRationalZero, isZeroPolynomial, matAt, matIndex, matrixCompare, matrixEntryToValue, matrixMultiply, monomialFromKey, monomialToKey, polyCoefficients, polyDegree, polyUnivariateVar, polynomialDivide, powNode, rationalAdd, rationalCompare, rationalDiv, rationalFromNumber, rationalMul, rationalNeg, rationalSub, rationalToNumber, resolveCurrencyAlias, rowMajorToColumnMajor, sameShape, signedSurdNode, simplifySymbolic, substitute, surdNode, symbolicKey, symbolicToEntry, toPolynomial, transpose, varNode };
-//# sourceMappingURL=chunk-CYFK5SY2.js.map
-//# sourceMappingURL=chunk-CYFK5SY2.js.map
+export { COMPLEX_I, CURRENCY_DISPLAY, RATIONAL_ONE, RATIONAL_ZERO, callNode, cancelSymbolic, coefficientGcd, collectionToValues, columnMajorToRowMajor, compareMonomials, complex, complexNode, constNode, determinant, exactIntegerCbrt, exactIntegerSqrt, exactRationalSqrt2 as exactRationalSqrt, expandSymbolic, formatSymbolic, freeVariables, fromPolynomial, inBounds, inverse, isRationalOne, isRationalZero, isZeroPolynomial, matAt, matIndex, matrixCompare, matrixEntryToValue, matrixMultiply, matrixPower, monomialFromKey, monomialToKey, polyCoefficients, polyDegree, polyUnivariateVar, polynomialDivide, powNode, rationalAdd, rationalCompare, rationalDiv, rationalFromNumber, rationalMul, rationalNeg, rationalSub, rationalToNumber, resolveCurrencyAlias, rowMajorToColumnMajor, sameShape, signedSurdNode, simplifySymbolic, squareFreePart, substitute, surdNode, symbolicKey, symbolicToEntry, toPolynomial, transpose, varNode };
+//# sourceMappingURL=chunk-O3ANBHSA.js.map
+//# sourceMappingURL=chunk-O3ANBHSA.js.map