solve-engine 1.0.2 → 1.1.1

package/dist/{chunk-Y7FT4IQT.js → chunk-NKW7LKYU.js}

@@ -1,10 +1,10 @@
 import { VariableResolver } from './chunk-GCM5JHMX.js';
-import { sharedCurrencyExchange } from './chunk-TMA4RCEN.js';
-import { powNode, callNode, simplifySymbolic, sameShape, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, matrixPower, constNode, rationalToNumber, toPolynomial, polyDegree, polyCoefficients, rationalNeg, substitute, rationalDiv, isRationalZero, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, rationalMul, fromPolynomial, coefficientGcd, polynomialDivide, isZeroPolynomial, rationalCompare, rationalSub, exactIntegerSqrt, rationalAdd, surdNode, compareMonomials, COMPLEX_I, squareFreePart, exactRationalSqrt, symbolicKey, monomialFromKey, monomialToKey, signedSurdNode, exactIntegerCbrt } from './chunk-O3ANBHSA.js';
-import { faultedOperand, errorValue, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, percentageValue, stringValue, hexValue } from './chunk-GQCOSXMG.js';
-import { getMeasure, convertUnit } from './chunk-R3PY4G7J.js';
+import { sharedCurrencyExchange } from './chunk-Z7XGGLI2.js';
+import { decimalFromInteger, toPolynomial, polyDegree, polyCoefficients, fromPolynomial, constNode, rationalDiv, rationalNeg, powNode, callNode, decimalCompare, isRationalZero, rationalMul, rationalSub, rationalAdd, rationalToNumber, rationalCompare, simplifySymbolic, sameShape, decimalFromNumberIfExact, decimalMultiply, decimalToNumber, decimalAdd, decimalNegate, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, matrixPower, exactIntegerSqrt, surdNode, rational, decimalIsZero, decimalDivide, decimalSubtract, decimalFromLiteral, decimalRound, substitute, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, COMPLEX_I, squareFreePart, coefficientGcd, polynomialDivide, isZeroPolynomial, exactRationalSqrt, symbolicKey, compareMonomials, signedSurdNode, monomialFromKey, monomialToKey, exactIntegerCbrt } from './chunk-NNQ2TYDF.js';
+import { faultedOperand, errorValue, numberValueRational, numberValueUncertain, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, uomValueExact, percentageValue, stringValue, hexValue } from './chunk-267JPOTF.js';
+import { getMeasure, convertUnit } from './chunk-MVTOCRV2.js';
 import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
-import { ErrorFactory } from './chunk-3D7V24DG.js';
+import { ErrorFactory } from './chunk-ERCOHGXD.js';
 
 // src/symbolic/MultivariateFactor.ts
 function exactRoot(value, degree) {
@@ -1134,15 +1134,59 @@ function largestFiniteMagnitude(a, b, c) {
 function compareUom(l, r) {
   const { lv, rv, sameMeasure } = unifyUom(l, r);
   if (!sameMeasure) return { lv, rv, equal: false, sameMeasure: false };
+  if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */ && l.unit !== void 0 && l.unit === r.unit && l.exact !== void 0 && r.exact !== void 0 && sharedCurrencyExchange.isCurrency(l.unit)) {
+    return { lv, rv, equal: decimalCompare(l.exact, r.exact) === 0, sameMeasure: true };
+  }
   if (lv === rv) return { lv, rv, equal: true, sameMeasure: true };
   if (!Number.isFinite(lv) || !Number.isFinite(rv)) return { lv, rv, equal: false, sameMeasure: true };
   const scale2 = largestFiniteMagnitude(lv, rv, r.toNumber());
   return { lv, rv, equal: Math.abs(lv - rv) <= scale2 * UNIFIED_COMPARISON_TOLERANCE, sameMeasure: true };
 }
+var MEASURE_NOUNS = {
+  time: "duration",
+  luminousIntensity: "luminous intensity"
+};
+var UNCOUNTABLE_MEASURES = /* @__PURE__ */ new Set(["money", "data"]);
+var COMBINE_VERBS = {
+  add: "added",
+  sub: "subtracted",
+  mul: "multiplied",
+  div: "divided"
+};
+function describeMeasure(unit) {
+  if (sharedCurrencyExchange.isCurrency(unit)) return "money";
+  const measure = getMeasure(unit);
+  if (measure === void 0) return void 0;
+  return MEASURE_NOUNS[measure] ?? measure;
+}
+function withMeasureArticle(noun) {
+  if (UNCOUNTABLE_MEASURES.has(noun)) return noun;
+  return /^[aeiou]/.test(noun) ? `an ${noun}` : `a ${noun}`;
+}
+function describeMeasureMismatch(lUnit, rUnit, verb) {
+  const left = lUnit === void 0 ? void 0 : describeMeasure(lUnit);
+  const right = rUnit === void 0 ? void 0 : describeMeasure(rUnit);
+  if (left !== void 0 && right !== void 0 && left !== right) {
+    return `${left} and ${right} cannot be ${verb}`;
+  }
+  return void 0;
+}
+function combineVerb(op) {
+  return op !== void 0 ? COMBINE_VERBS[op] ?? "combined" : "combined";
+}
+function describeConversionMismatch(fromUnit, toUnit) {
+  const from = describeMeasure(fromUnit);
+  const to = describeMeasure(toUnit);
+  if (from !== void 0 && to !== void 0 && from !== to) {
+    return `${withMeasureArticle(from)} cannot be converted to ${withMeasureArticle(to)}`;
+  }
+  return void 0;
+}
 function incomparableUnitsError(l, r) {
   const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
   const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
-  return errorValue("INCOMPATIBLE_UNITS", `Cannot compare incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
+  const named = describeMeasureMismatch(lUnit, rUnit, "compared");
+  return errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot compare incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
 }
 function toBigIntOperand(v) {
   if (v.type === 2 /* BigInt */) return v.value;
@@ -1182,6 +1226,121 @@ function power(base, exponent) {
   if (base === -1 && !Number.isNaN(exponent)) return 1;
   return Math.pow(base, exponent);
 }
+function operandExactDecimal(v) {
+  if (v.exact !== void 0) return v.exact;
+  return decimalFromNumberIfExact(v.toNumber());
+}
+function exactMoneyOp(l, r, op) {
+  const lMoney = l.type === 6 /* Uom */ && l.unit !== void 0 && l.exact !== void 0 && sharedCurrencyExchange.isCurrency(l.unit);
+  const rMoney = r.type === 6 /* Uom */ && r.unit !== void 0 && r.exact !== void 0 && sharedCurrencyExchange.isCurrency(r.unit);
+  if (!lMoney && !rMoney) return null;
+  let ld;
+  let rd;
+  let unit;
+  if (lMoney && rMoney) {
+    if (l.unit !== r.unit || op === "div") return null;
+    ld = l.exact;
+    rd = r.exact;
+    unit = l.unit;
+  } else if (lMoney && r.type !== 6 /* Uom */) {
+    ld = l.exact;
+    unit = l.unit;
+    rd = operandExactDecimal(r);
+  } else if (rMoney && l.type !== 6 /* Uom */) {
+    rd = r.exact;
+    unit = r.unit;
+    ld = operandExactDecimal(l);
+  } else {
+    return null;
+  }
+  if (ld === null || rd === null) return null;
+  let result;
+  switch (op) {
+    case "add":
+      result = decimalAdd(ld, rd);
+      break;
+    case "sub":
+      result = decimalSubtract(ld, rd);
+      break;
+    case "mul":
+      result = decimalMultiply(ld, rd);
+      break;
+    case "div":
+      if (decimalIsZero(rd)) return null;
+      result = decimalDivide(ld, rd);
+      break;
+  }
+  return uomValueExact(decimalToNumber(result), unit, result);
+}
+function operandRational(v) {
+  if (v.rational !== void 0) return v.rational;
+  if ((v.type === 0 /* Number */ || v.type === 1 /* Hex */) && typeof v.value === "number" && Number.isInteger(v.value)) {
+    return rational(BigInt(v.value));
+  }
+  return null;
+}
+function exactRationalOp(l, r, op) {
+  const lr = operandRational(l);
+  if (lr === null) return null;
+  const rr = operandRational(r);
+  if (rr === null) return null;
+  if (op === "div" && isRationalZero(rr)) return null;
+  let result;
+  try {
+    switch (op) {
+      case "add":
+        result = rationalAdd(lr, rr);
+        break;
+      case "sub":
+        result = rationalSub(lr, rr);
+        break;
+      case "mul":
+        result = rationalMul(lr, rr);
+        break;
+      case "div":
+        result = rationalDiv(lr, rr);
+        break;
+    }
+  } catch {
+    return null;
+  }
+  return numberValueRational(rationalToNumber(result), result);
+}
+function uncertainOp(l, r, op) {
+  if (l.type !== 0 /* Number */ || r.type !== 0 /* Number */) return null;
+  const a = l.value;
+  const b = r.value;
+  const sa = l.uncertainty ?? 0;
+  const sb = r.uncertainty ?? 0;
+  let center;
+  let sigma;
+  switch (op) {
+    case "add":
+      center = a + b;
+      sigma = Math.hypot(sa, sb);
+      break;
+    case "sub":
+      center = a - b;
+      sigma = Math.hypot(sa, sb);
+      break;
+    case "mul":
+      center = a * b;
+      sigma = Math.hypot(b * sa, a * sb);
+      break;
+    case "div":
+      center = a / b;
+      sigma = Math.hypot(sa / b, a * sb / (b * b));
+      break;
+  }
+  return numberValueUncertain(center, sigma);
+}
+function compareRationalOperands(l, r) {
+  const lr = operandRational(l);
+  if (lr === null) return null;
+  const rr = operandRational(r);
+  if (rr === null) return null;
+  return rationalCompare(lr, rr);
+}
 function binaryOp(l, r, op, bigOp, symbolicOp) {
   if (l.type === 13 /* Error */) return l;
   if (r.type === 13 /* Error */) return r;
@@ -1209,11 +1368,16 @@ function binaryOp(l, r, op, bigOp, symbolicOp) {
     return bigIntValue(lb + rb);
   }
   if (l.type === 6 /* Uom */ || r.type === 6 /* Uom */) {
+    if (symbolicOp) {
+      const exactMoney = exactMoneyOp(l, r, symbolicOp);
+      if (exactMoney) return exactMoney;
+    }
     const { lv, rv, unit, sameMeasure } = unifyUom(l, r);
     if (!sameMeasure) {
       const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
       const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
-      return errorValue("INCOMPATIBLE_UNITS", `Cannot combine incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
+      const named = describeMeasureMismatch(lUnit, rUnit, combineVerb(symbolicOp));
+      return errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot combine incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
     }
     return uomValue(op(lv, rv), unit);
   }
@@ -1288,6 +1452,57 @@ var OpRegistry = class {
 };
 var sharedOpRegistry = new OpRegistry();
 
+// src/vm/MoneyExact.ts
+var ONE_DECIMAL = decimalFromInteger(1);
+function moneyExactMagnitude(operand, unit) {
+  if (!sharedCurrencyExchange.isCurrency(unit)) return null;
+  return operand.exact ?? decimalFromNumberIfExact(operand.toNumber());
+}
+function decimalFromShortDecimal(n) {
+  if (!Number.isFinite(n)) return null;
+  if (Number.isInteger(n)) return decimalFromInteger(BigInt(n));
+  const s = String(n);
+  if (!/^-?\d+\.\d+$/.test(s)) return null;
+  return decimalFromLiteral(s);
+}
+function scaleMoneyExact(amount, factor, unit) {
+  const base = moneyExactMagnitude(amount, unit);
+  const factorDecimal = decimalFromShortDecimal(factor);
+  if (base !== null && factorDecimal !== null) {
+    const result = decimalMultiply(base, factorDecimal);
+    return uomValueExact(decimalToNumber(result), unit, result);
+  }
+  return uomValue(amount.toNumber() * factor, unit);
+}
+function scaleMoneyByPercent(money, unit, percent, sign) {
+  const base = moneyExactMagnitude(money, unit);
+  const percentDecimal = decimalFromShortDecimal(percent);
+  if (base !== null && percentDecimal !== null) {
+    const factor = decimalAdd(ONE_DECIMAL, sign === 1 ? percentDecimal : decimalNegate(percentDecimal));
+    const result = decimalMultiply(base, factor);
+    return uomValueExact(decimalToNumber(result), unit, result);
+  }
+  return uomValue(money.toNumber() * (1 + sign * percent), unit);
+}
+function onePlusRateDecimal(rate) {
+  const rateDecimal = decimalFromShortDecimal(rate);
+  return rateDecimal === null ? null : decimalAdd(ONE_DECIMAL, rateDecimal);
+}
+function removeTaxExact(money, unit, rate) {
+  const base = moneyExactMagnitude(money, unit);
+  const divisor = onePlusRateDecimal(rate);
+  if (base === null || divisor === null || decimalIsZero(divisor)) return null;
+  const quotient = decimalDivide(base, divisor);
+  return uomValueExact(decimalToNumber(quotient), unit, quotient);
+}
+function taxInExact(money, unit, rate) {
+  const base = moneyExactMagnitude(money, unit);
+  const divisor = onePlusRateDecimal(rate);
+  if (base === null || divisor === null || decimalIsZero(divisor)) return null;
+  const tax = decimalSubtract(base, decimalDivide(base, divisor));
+  return uomValueExact(decimalToNumber(tax), unit, tax);
+}
+
 // src/symbolic/PartialFractions.ts
 var APART_MAX_DEGREE = 12;
 function multiply2(a, b) {
@@ -1958,9 +2173,10 @@ function extremum(args, wantLargest) {
     if (!sameMeasure) {
       const bestUnit = best.type === 6 /* Uom */ ? best.unit : void 0;
       const otherUnit = a.type === 6 /* Uom */ ? a.unit : void 0;
+      const named = describeMeasureMismatch(bestUnit, otherUnit, "compared");
       return errorValue(
         "INCOMPATIBLE_UNITS",
-        `Cannot compare incompatible units: ${bestUnit ?? "?"} and ${otherUnit ?? "?"}`
+        named ?? `Cannot compare incompatible units: ${bestUnit ?? "?"} and ${otherUnit ?? "?"}`
       );
     }
     if (wantLargest ? rv > lv : rv < lv) best = a;
@@ -1973,6 +2189,25 @@ function keepUnit(operand, magnitude2) {
   if (operand.type === 6 /* Uom */ && operand.unit !== void 0) return uomValue(magnitude2, operand.unit);
   return numberValue(magnitude2);
 }
+function roundToPlaces(source, places) {
+  const p = Number.isFinite(places) ? Math.min(100, Math.max(0, Math.trunc(places))) : 0;
+  if (source.exact !== void 0) {
+    const rounded = decimalRound(source.exact, p);
+    return withPlaces(source, decimalToNumber(rounded), p, rounded);
+  }
+  const value = source.toNumber();
+  if (!Number.isFinite(value)) return withPlaces(source, value, p);
+  const scale2 = Math.pow(10, p);
+  const scaled = value * scale2;
+  if (!Number.isFinite(scaled) || Math.abs(scaled) > Number.MAX_SAFE_INTEGER) return withPlaces(source, value, p);
+  return withPlaces(source, Math.round(scaled) / scale2, p);
+}
+function withPlaces(source, magnitude2, places, exact) {
+  const result = source.type === 6 /* Uom */ && source.unit !== void 0 ? uomValue(magnitude2, source.unit) : numberValue(magnitude2);
+  result.decimalPlaces = places;
+  if (exact !== void 0) result.exact = exact;
+  return result;
+}
 function nonFiniteEuclidOperand(a, b, name) {
   if (Number.isFinite(a) && Number.isFinite(b)) return null;
   const culprit = Number.isFinite(a) ? b : a;
@@ -2013,7 +2248,13 @@ var builtinFunctions = {
   // round/ceil/floor keep a unit for the same reason abs does; see keepUnit().
   6: (args) => keepUnit(args[0], Math.ceil(args[0].toNumber())),
   7: (args) => keepUnit(args[0], Math.floor(args[0].toNumber())),
-  8: (args) => keepUnit(args[0], Math.round(args[0].toNumber())),
+  8: (args) => args.length >= 2 ? (
+    // round(x, n): round to n decimal places and display at that precision.
+    roundToPlaces(args[0], args[1].toNumber())
+  ) : (
+    // round(x): nearest whole number, the way it always was.
+    keepUnit(args[0], Math.round(args[0].toNumber()))
+  ),
   // min/max: see extremum() for why the winner is carried around as a Value
   // rather than as a running number.
   9: (args) => extremum(args, false),
@@ -2357,8 +2598,8 @@ var builtinFunctions = {
   58: (args) => {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
-    const result = amount * (1 + rate);
-    return args[0].type === 6 /* Uom */ ? uomValue(result, args[0].unit) : numberValue(result);
+    if (args[0].type === 6 /* Uom */) return scaleMoneyByPercent(args[0], args[0].unit, rate, 1);
+    return numberValue(amount * (1 + rate));
   },
   // taxRemove(amount, rate) -> amount / (1 + rate), extracts the
   // pre-tax amount from a tax-INCLUSIVE total. Backs "tax off $X at R%" /
@@ -2369,7 +2610,10 @@ var builtinFunctions = {
     if (1 + rate <= 0) {
       return errorValue("INVALID_RATE", `taxRemove: rate ${rate} makes (1 + rate) non-positive`);
     }
-    return args[0].type === 6 /* Uom */ ? uomValue(amount / (1 + rate), args[0].unit) : numberValue(amount / (1 + rate));
+    if (args[0].type === 6 /* Uom */) {
+      return removeTaxExact(args[0], args[0].unit, rate) ?? uomValue(amount / (1 + rate), args[0].unit);
+    }
+    return numberValue(amount / (1 + rate));
   },
   // inflationAdjust(amount, fromYear, toYear) -- CPI-based inflation
   // adjustment between two arbitrary years, using the bundled CPI-U
@@ -2580,7 +2824,10 @@ var builtinFunctions = {
       return errorValue("INVALID_RATE", `taxIn: rate ${rate} makes (1 + rate) non-positive`);
     }
     const tax = amount - amount / (1 + rate);
-    return args[0].type === 6 /* Uom */ ? uomValue(tax, args[0].unit) : numberValue(tax);
+    if (args[0].type === 6 /* Uom */) {
+      return taxInExact(args[0], args[0].unit, rate) ?? uomValue(tax, args[0].unit);
+    }
+    return numberValue(tax);
   },
   // taxOn(amount, rate) -> amount * rate, the tax itself.
   //
@@ -2592,8 +2839,8 @@ var builtinFunctions = {
   86: (args) => {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
-    const tax = amount * rate;
-    return args[0].type === 6 /* Uom */ ? uomValue(tax, args[0].unit) : numberValue(tax);
+    if (args[0].type === 6 /* Uom */) return scaleMoneyExact(args[0], rate, args[0].unit);
+    return numberValue(amount * rate);
   },
   // ── Degree-taking trig (sind/cosd/tand and the inverses) ──────────────
   // The "d" spellings take and return degrees rather than radians, which is
@@ -2783,16 +3030,7 @@ var builtinFunctions = {
   // fractional part to round at all, and the round trip through 1e23 was
   // pure loss. Asking for fewer decimal places than a number has cannot
   // change it, so a value that is already whole is returned untouched.
-  97: (args) => {
-    const source = args[0];
-    const value = source.toNumber();
-    const places = args[1].toNumber();
-    if (!Number.isFinite(value) || Number.isInteger(value)) return keepUnit(source, value);
-    const scale2 = Math.pow(10, places);
-    const scaled = value * scale2;
-    if (!Number.isFinite(scaled) || Math.abs(scaled) > Number.MAX_SAFE_INTEGER) return keepUnit(source, value);
-    return keepUnit(source, Math.round(scaled) / scale2);
-  }
+  97: (args) => roundToPlaces(args[0], args[1].toNumber())
 };
 function applyComplexAccessor(name, value) {
   const node = valueToSymbolic(value);
@@ -2942,6 +3180,6 @@ function globalDagKey(name) {
   return `global:${name}`;
 }
 
-export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, bigIntDivisionByZero, binaryOp, builtinFunctions, compareBigIntOperands, compareUom, createEngineContext, defaultEngineContext, globalDagKey, incomparableUnitsError, pluginFunctionRegistry, power, registerAsConverter, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, symbolicBuiltin, symbolicNeg, symbolicPow, toBigIntOperand, unifyUom, unregisterAsConverter };
-//# sourceMappingURL=chunk-Y7FT4IQT.js.map
-//# sourceMappingURL=chunk-Y7FT4IQT.js.map
+export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, bigIntDivisionByZero, binaryOp, builtinFunctions, compareBigIntOperands, compareRationalOperands, compareUom, createEngineContext, defaultEngineContext, describeConversionMismatch, exactRationalOp, globalDagKey, incomparableUnitsError, moneyExactMagnitude, pluginFunctionRegistry, power, registerAsConverter, scaleMoneyByPercent, scaleMoneyExact, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, solveForVariable, symbolicBuiltin, symbolicNeg, symbolicPow, toBigIntOperand, uncertainOp, unifyUom, unregisterAsConverter };
+//# sourceMappingURL=chunk-NKW7LKYU.js.map
+//# sourceMappingURL=chunk-NKW7LKYU.js.map