@cortex-js/compute-engine 0.9.0 → 0.10.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.9.0 */
+/** CortexJS Compute Engine 0.10.0 */
 /** @internal */
 function isSymbolEntry(entry) {
     return !('kind' in entry) || entry.kind === 'symbol';
@@ -13988,6 +13988,8 @@ function primeFactors$1(n) {
  *
  */
 function factorPower$1(n, exponent) {
+    if (n >= Number.MAX_SAFE_INTEGER)
+        return [1, n];
     // @todo: handle negative n
     console.assert(Number.isInteger(n) && n > 0 && n < Number.MAX_SAFE_INTEGER);
     const factors = primeFactors$1(n);
@@ -14562,6 +14564,9 @@ function validateArgumentCount(ce, ops, count) {
  * the number of expected arguments.
  */
 function validateNumericArgs(ce, ops, count) {
+    // @fastpath
+    if (!ce.strict)
+        return ops.map((x) => ce.box(x));
     let xs = [];
     if (count === undefined) {
         xs = ops.map((x) => ce.box(x));
@@ -14585,6 +14590,9 @@ function validateNumericArgs(ce, ops, count) {
  */
 function validateSignature(sig, ops, codomain) {
     const ce = sig.engine;
+    // @fastpath
+    if (!ce.strict)
+        return ops;
     const opsDomain = ops.map((x) => x.domain);
     const targetSig = ce.domain([
         'Function',
@@ -14996,7 +15004,8 @@ function asMachineRational(r) {
  * @returns
  */
 function add(lhs, rhs) {
-    console.assert(Array.isArray(rhs) || (rhs.isLiteral && !(rhs instanceof Complex)));
+    console.assert(Array.isArray(rhs) ||
+        (rhs.numericValue !== null && !(rhs instanceof Complex)));
     if (Array.isArray(rhs)) {
         if (isBigRational(rhs))
             return [rhs[1].mul(lhs[0]).add(rhs[0].mul(lhs[1])), rhs[1].mul(lhs[1])];
@@ -15034,7 +15043,8 @@ function add(lhs, rhs) {
     return lhs;
 }
 function mul(lhs, rhs) {
-    console.assert(Array.isArray(rhs) || (rhs.isLiteral && !(rhs instanceof Complex)));
+    console.assert(Array.isArray(rhs) ||
+        (rhs.numericValue !== null && !(rhs instanceof Complex)));
     if (Array.isArray(rhs)) {
         if (isBigRational(lhs))
             return [lhs[0].mul(rhs[0]), lhs[1].mul(rhs[1])];
@@ -15199,7 +15209,7 @@ function asCoefficient(expr) {
     //
     if (expr.head === 'Power') {
         // We can only extract a coef if the exponent is a literal
-        if (!expr.op2.isLiteral)
+        if (expr.op2.numericValue === null)
             return [[1, 1], expr];
         // eslint-disable-next-line prefer-const
         let [coef, base] = asCoefficient(expr.op1);
@@ -15274,7 +15284,9 @@ function signDiff(lhs, rhs, tolerance) {
         return 0;
     const lhsN = lhs.N();
     const rhsN = rhs.N();
-    if (!lhsN.isLiteral || !rhsN.isLiteral) {
+    const lhsNum = lhsN.numericValue;
+    const rhsNum = rhsN.numericValue;
+    if (lhsNum === null || rhsNum === null) {
         // Couldn't calculate a numeric value, use the `sgn`
         const lhsS = lhs.sgn;
         const rhsS = rhs.sgn;
@@ -15289,8 +15301,6 @@ function signDiff(lhs, rhs, tolerance) {
         return undefined;
     }
     tolerance ?? (tolerance = lhs.engine.tolerance);
-    const lhsNum = lhsN.numericValue;
-    const rhsNum = rhsN.numericValue;
     if (lhsNum instanceof Complex && rhsNum instanceof Complex)
         return chop(lhsNum.re - rhsNum.re, tolerance) === 0 &&
             chop(lhsNum.im - rhsNum.im, tolerance) === 0
@@ -15322,11 +15332,11 @@ function negateLiteral(expr, metadata) {
         return null;
     if (typeof n === 'number')
         n = -n;
-    if (n instanceof Decimal)
+    else if (n instanceof Decimal)
         n = n.neg();
-    if (n instanceof complex.exports.Complex)
+    else if (n instanceof complex.exports.Complex)
         n = n.neg();
-    if (Array.isArray(n))
+    else if (Array.isArray(n))
         n = neg(n);
     return expr.engine.number(n, { metadata });
 }
@@ -15344,7 +15354,7 @@ function canonicalNegate(expr, metadata) {
     if (expr.head === 'Negate')
         return validateArgument(expr.engine, expr.op1?.canonical, 'Number');
     expr = validateArgument(expr.engine, expr.canonical, 'Number');
-    if (expr.isLiteral)
+    if (expr.numericValue !== null)
         return negateLiteral(expr, metadata);
     // Distribute over addition
     // Negate(Add(a, b)) -> Add(Negate(a), Negate(b))
@@ -15369,10 +15379,10 @@ function canonicalNegate(expr, metadata) {
  * `canonical` chain.
  */
 function distributeNegate(expr) {
+    if (expr.numericValue !== null)
+        return negateLiteral(expr);
     if (expr.head === 'Negate')
         return expr.op1;
-    if (expr.isLiteral)
-        return negateLiteral(expr);
     const ce = expr.engine;
     // Distribute over addition
     // Negate(Add(a, b)) -> Add(Negate(a), Negate(b))
@@ -15414,7 +15424,7 @@ function negateProduct(ce, args) {
     // else If there is a literal integer, negate it
     result = [];
     for (const arg of args) {
-        if (done || !arg.isLiteral || !arg.isInteger)
+        if (done || arg.numericValue === null || !arg.isInteger)
             result.push(arg);
         else {
             done = true;
@@ -15426,7 +15436,7 @@ function negateProduct(ce, args) {
     // else If there is a literal number, negate it
     result = [];
     for (const arg of args) {
-        if (done || !arg.isLiteral || !arg.isNumber)
+        if (done || arg.numericValue === null || !arg.isNumber)
             result.push(arg);
         else {
             done = true;
@@ -16185,9 +16195,6 @@ class AbstractBoxedExpression {
     get url() {
         return undefined;
     }
-    get isLiteral() {
-        return false;
-    }
     get wikidata() {
         return this._wikidata;
     }
@@ -16285,7 +16292,7 @@ class AbstractBoxedExpression {
  * `3√2x^5y^3` -> 8 (5 + 3)
  */
 function totalDegree(expr) {
-    if (expr.head === 'Power' && expr.op2.isLiteral) {
+    if (expr.head === 'Power' && expr.op2.numericValue !== null) {
         const deg = asSmallInteger(expr.op2);
         if (deg !== null && deg > 0)
             return deg;
@@ -16310,7 +16317,7 @@ function totalDegree(expr) {
  *
  */
 function maxDegree(expr) {
-    if (expr.head === 'Power' && expr.op2.isLiteral) {
+    if (expr.head === 'Power' && expr.op2.numericValue !== null) {
         const deg = asSmallInteger(expr.op2);
         if (deg !== null && deg > 0)
             return deg;
@@ -16404,17 +16411,17 @@ function order(a, b) {
     //  1/ Literal numeric values
     //
     const af = asFloat(a);
-    if (a.isLiteral && af !== null) {
+    if (af !== null) {
         const bf = asFloat(b);
-        if (b.isLiteral && bf !== null)
+        if (bf !== null)
             return af - bf;
         return -1;
     }
     //
     // 2/ Complex numbers
     //
-    if (a.isLiteral && a.numericValue instanceof Complex) {
-        if (b.isLiteral && b.numericValue instanceof Complex) {
+    if (a.numericValue instanceof Complex) {
+        if (b.numericValue instanceof Complex) {
             if (a.numericValue.re === b.numericValue.re) {
                 if (Math.abs(a.numericValue.im) === Math.abs(b.numericValue.im)) {
                     return a.numericValue.im - b.numericValue.im;
@@ -16423,7 +16430,7 @@ function order(a, b) {
             }
             return a.numericValue.re - b.numericValue.re;
         }
-        if (b.isLiteral && b.isNumber)
+        if (b.numericValue !== null)
             return +1;
         return -1;
     }
@@ -16436,7 +16443,7 @@ function order(a, b) {
                 return 0;
             return a.symbol > b.symbol ? 1 : -1;
         }
-        if (b.isLiteral && b.isNumber)
+        if (b.numericValue !== null)
             return +1;
         return -1;
     }
@@ -16466,7 +16473,7 @@ function order(a, b) {
             }
             return aComplexity - bComplexity;
         }
-        if ((b.isLiteral && b.isNumber) || b.symbol)
+        if (b.numericValue !== null || b.symbol)
             return +1;
         return -1;
     }
@@ -16589,7 +16596,7 @@ class Product {
             // }
             // If we're calculation a canonical  product, fold exact literals into
             // running terms
-            if (term.isLiteral) {
+            if (term.numericValue !== null) {
                 if (term.isOne)
                     return;
                 if (term.isZero) {
@@ -16608,9 +16615,10 @@ class Product {
                 }
                 let num = term.numericValue;
                 if (typeof num === 'number') {
-                    if (num < 0)
+                    if (num < 0) {
                         this._sign *= -1;
-                    num = Math.abs(num);
+                        num = -num;
+                    }
                     if (Number.isInteger(num))
                         this._rational = mul(this._rational, [num, 1]);
                     else if (bignumPreferred(this.engine))
@@ -16661,11 +16669,11 @@ class Product {
             }
         }
         // Note: rest should be positive, so no need to handle the -1 case
-        if (rest.isLiteral && rest.isOne)
+        if (rest.numericValue !== null && rest.isOne)
             return;
         // If this is a power expression, extract the exponent
         let exponent = [1, 1];
-        if (rest.head === 'Power' && rest.op2.isLiteral) {
+        if (rest.head === 'Power') {
             // Term is `Power(op1, op2)`
             const r = asRational(rest.op2);
             if (r) {
@@ -16726,38 +16734,36 @@ class Product {
                     return [];
                 return [{ exponent: [1, 1], terms: [ce.number(b)] }];
             }
-            else {
-                // Machine preferred
-                let n = 1;
-                if (!isRationalOne(this._rational)) {
-                    if (isBigRational(this._rational))
-                        n = this._rational[0].toNumber() / this._rational[1].toNumber();
-                    else
-                        n = this._rational[0] / this._rational[1];
-                }
-                // if (!isRationalOne(this._squareRootRational)) {
-                //   if (isBigRational(this._squareRootRational))
-                //     n *= Math.sqrt(
-                //       this._squareRootRational[0].toNumber() /
-                //         this._squareRootRational[1].toNumber()
-                //     );
-                //   else
-                //     n *= Math.sqrt(
-                //       this._squareRootRational[0] / this._squareRootRational[1]
-                //     );
-                // }
-                n *= this._sign * this._number * this._bignum.toNumber();
-                if (this._complex.im !== 0) {
-                    const z = this._complex.mul(n);
-                    if (z.equals(1))
-                        return [];
-                    return [{ exponent: [1, 1], terms: [ce.number(z)] }];
-                }
-                n *= this._complex.re;
-                if (n === 1)
+            // Machine preferred
+            let n = 1;
+            if (!isRationalOne(this._rational)) {
+                if (isBigRational(this._rational))
+                    n = this._rational[0].toNumber() / this._rational[1].toNumber();
+                else
+                    n = this._rational[0] / this._rational[1];
+            }
+            // if (!isRationalOne(this._squareRootRational)) {
+            //   if (isBigRational(this._squareRootRational))
+            //     n *= Math.sqrt(
+            //       this._squareRootRational[0].toNumber() /
+            //         this._squareRootRational[1].toNumber()
+            //     );
+            //   else
+            //     n *= Math.sqrt(
+            //       this._squareRootRational[0] / this._squareRootRational[1]
+            //     );
+            // }
+            n *= this._sign * this._number * this._bignum.toNumber();
+            if (this._complex.im !== 0) {
+                const z = this._complex.mul(n);
+                if (z.equals(1))
                     return [];
-                return [{ exponent: [1, 1], terms: [ce.number(n)] }];
+                return [{ exponent: [1, 1], terms: [ce.number(z)] }];
             }
+            n *= this._complex.re;
+            if (n === 1)
+                return [];
+            return [{ exponent: [1, 1], terms: [ce.number(n)] }];
         }
         //
         // Terms of degree 1 (exponent = [1,1])
@@ -16795,7 +16801,12 @@ class Product {
                     });
             }
             else {
-                unitTerms.push(ce.number(this._rational));
+                if (n === -1) {
+                    unitTerms.push(ce.number(neg(this._rational)));
+                    n = 1;
+                }
+                else
+                    unitTerms.push(ce.number(this._rational));
             }
         }
         // if (!isRationalOne(this._squareRootRational)) {
@@ -16926,7 +16937,7 @@ class Product {
     }
     asRationalExpression() {
         const [numerator, denominator] = this.asNumeratorDenominator();
-        if (denominator.isLiteral) {
+        if (denominator.numericValue !== null) {
             if (denominator.isOne)
                 return numerator;
             if (denominator.isNegativeOne)
@@ -16992,7 +17003,7 @@ function termsAsExpressions(ce, terms) {
 }
 
 function subtract(ce, a, b, metadata) {
-    if (a.isLiteral) {
+    if (a.numericValue !== null) {
         if (isRational(a.numericValue)) {
             if (machineNumerator(a.numericValue) < 0) {
                 return serializeJsonFunction(ce, 'Subtract', [b, ce.number(neg(a.numericValue))], metadata);
@@ -17025,7 +17036,7 @@ function serializeJsonCanonicalFunction(ce, head, args, metadata) {
         return serializeJsonFunction(ce, 'Multiply', [args[0], ce._fn('Power', [args[1], ce._NEGATIVE_ONE])], metadata);
     }
     if (head === 'Multiply' && !exclusions.includes('Negate')) {
-        if (args[0]?.isLiteral && asFloat(args[0]) === -1)
+        if (asFloat(args[0]) === -1)
             return serializeJsonFunction(ce, 'Negate', [ce._fn('Multiply', args.slice(1))], metadata);
     }
     if (head === 'Multiply' && !exclusions.includes('Divide')) {
@@ -17040,7 +17051,7 @@ function serializeJsonCanonicalFunction(ce, head, args, metadata) {
     if (head === 'Power') {
         if (!exclusions.includes('Exp') && args[0]?.symbol === 'ExponentialE')
             return serializeJsonFunction(ce, 'Exp', [args[1]], metadata);
-        if (args[1]?.isLiteral) {
+        if (args[1]?.numericValue !== null) {
             const exp = asSmallInteger(args[1]);
             if (exp === 2 && !exclusions.includes('Square'))
                 return serializeJsonFunction(ce, 'Square', [args[0]], metadata);
@@ -17105,7 +17116,7 @@ function serializeJsonFunction(ce, head, args, metadata) {
             return serializeJsonFunction(ce, 'Add', [args[0], ce._fn('Multiply', [args[1], ce.symbol('ImaginaryUnit')])], metadata);
         if (head === 'Sqrt' && args.length === 1)
             return serializeJsonFunction(ce, 'Power', [args[0], exclusions.includes('Half') ? ce.number([1, 2]) : ce._HALF], metadata);
-        if (head === 'Root' && args.length === 2 && args[1].isLiteral) {
+        if (head === 'Root' && args.length === 2 && args[1].numericValue !== null) {
             const n = asSmallInteger(args[1]);
             if (n === 2)
                 return serializeJsonFunction(ce, 'Sqrt', [args[0]]);
@@ -17127,7 +17138,7 @@ function serializeJsonFunction(ce, head, args, metadata) {
             return serializeJsonFunction(ce, 'Negate', args, metadata);
     }
     if (head === 'Add' && args.length === 2 && !exclusions.includes('Subtract')) {
-        if (args[1].isLiteral) {
+        if (args[1].numericValue !== null) {
             const t1 = asSmallInteger(args[1]);
             if (t1 !== null && t1 < 0)
                 return serializeJsonFunction(ce, 'Subtract', [args[0], ce.number(-t1)], metadata);
@@ -17900,14 +17911,13 @@ class BoxedFunction extends AbstractBoxedExpression {
     set isCanonical(val) {
         this._canonical = val ? this : undefined;
     }
-    get isLiteral() {
-        return false;
-    }
     get isPure() {
-        if (!this.isCanonical)
-            return false;
         if (this._isPure !== undefined)
             return this._isPure;
+        if (!this.isCanonical) {
+            this._isPure = false;
+            return false;
+        }
         let result = undefined;
         if (this.functionDefinition?.pure !== undefined)
             result = this.functionDefinition.pure;
@@ -18113,9 +18123,7 @@ class BoxedFunction extends AbstractBoxedExpression {
         debugger;
     }
     get value() {
-        if (!this.isCanonical)
-            return undefined;
-        if (!this.isPure)
+        if (!this.isCanonical || !this.isPure)
             return undefined;
         // Use cached value if the function is pure
         if (!this._value)
@@ -18459,12 +18467,12 @@ class BoxedFunction extends AbstractBoxedExpression {
         //
         // 1/ Use canonical form
         //
-        if (!this.isValid)
+        if (this._numericValue)
+            return this._numericValue;
+        if (this.engine.strict && !this.isValid)
             return this;
         if (!this.isCanonical)
             return this.canonical.N(options);
-        if (this._numericValue)
-            return this._numericValue;
         //
         // 2/ Evaluate the applicable operands
         //
@@ -18541,7 +18549,7 @@ function makeNumericFunction(ce, head, semiOps, metadata) {
         return ce.power(ops[0], ce.number(2), metadata);
     if (head === 'Sqrt') {
         const op = ops[0].canonical;
-        if (op.isLiteral && op.isRational)
+        if (isRational(op.numericValue))
             return new BoxedFunction(ce, 'Sqrt', [op], { metadata, canonical: true });
         return ce.power(op, ce.number([1, 2]), metadata);
     }
@@ -18895,12 +18903,13 @@ class BoxedNumber extends AbstractBoxedExpression {
      * range
      */
     constructor(ce, value, options) {
-        options ?? (options = {});
-        super(ce, options.metadata);
-        this._isCanonical = true;
+        super(ce, options?.metadata);
+        if (typeof value === 'number') {
+            this._value = value;
+            this._isCanonical = true;
+            return;
+        }
         if (isRational(value)) {
-            if (!('canonical' in options))
-                options.canonical = true;
             //
             // This is a rational (or big rational)
             //
@@ -18909,7 +18918,7 @@ class BoxedNumber extends AbstractBoxedExpression {
                 (Number.isInteger(n) && Number.isInteger(d) && d !== n && d !== 1));
             console.assert(!(n instanceof Decimal && d instanceof Decimal) ||
                 (n.isInteger() && d.isInteger() && !d.eq(n) && !d.eq(1)));
-            if (options.canonical) {
+            if (options?.canonical ?? true) {
                 this._value = canonicalNumber(ce, value);
                 this._isCanonical = true;
             }
@@ -18931,7 +18940,6 @@ class BoxedNumber extends AbstractBoxedExpression {
             this._value = canonicalNumber(ce, value);
             this._isCanonical = true;
         }
-        ce._register(this);
     }
     get hash() {
         if (this._hash !== undefined)
@@ -18954,9 +18962,6 @@ class BoxedNumber extends AbstractBoxedExpression {
     get isPure() {
         return true;
     }
-    get isLiteral() {
-        return true;
-    }
     get isExact() {
         if (typeof this._value === 'number')
             return Number.isInteger(this._value);
@@ -19386,9 +19391,6 @@ class BoxedString extends AbstractBoxedExpression {
     get isPure() {
         return true;
     }
-    get isLiteral() {
-        return true;
-    }
     get isCanonical() {
         return true;
     }
@@ -19722,7 +19724,7 @@ function boxFunction(ce, head, ops, options) {
                 if (key.isValid && !key.isNothing) {
                     const value = arg.op2;
                     let k = key.symbol ?? key.string;
-                    if (!k && key.isLiteral) {
+                    if (!k && (key.numericValue !== null || key.string)) {
                         const n = typeof key.numericValue === 'number'
                             ? key.numericValue
                             : asSmallInteger(key);
@@ -19923,7 +19925,7 @@ class Sum {
         if (this._isCanonical) {
             if (term.isNothing)
                 return;
-            if (term.isLiteral) {
+            if (term.numericValue !== null) {
                 if (term.isInfinity) {
                     if (term.isPositive)
                         this._posInfinityCount += 1;
@@ -19995,13 +19997,13 @@ class Sum {
             return;
         }
         let hasTerm = false;
-        if (!term.isLiteral) {
+        if (term.numericValue === null) {
             // There's an overhead to calculate the hash.
             // For best results, only use the hash if there are many terms
             if (this._terms.length > 500) {
                 const h = term.hash;
                 for (let i = 0; i < this._terms.length; i++) {
-                    if (!this._terms[i].term.isLiteral &&
+                    if (this._terms[i].term.numericValue === null &&
                         h === this._terms[i].term.hash &&
                         term.isSame(this._terms[i].term)) {
                         this._terms[i].coef = add(this._terms[i].coef, coef);
@@ -20012,7 +20014,7 @@ class Sum {
             }
             else {
                 for (let i = 0; i < this._terms.length; i++) {
-                    if (!this._terms[i].term.isLiteral &&
+                    if (this._terms[i].term.numericValue === null &&
                         term.isSame(this._terms[i].term)) {
                         this._terms[i].coef = add(this._terms[i].coef, coef);
                         hasTerm = true;
@@ -21034,7 +21036,7 @@ function canonicalAdd(ce, ops) {
     console.assert(ops.every((x) => x.isCanonical));
     ops = flattenOps(flattenSequence(ops.map((x) => x.canonical)), 'Add') ?? ops;
     // Remove literal 0
-    ops = ops.filter((x) => !(x.isLiteral && x.isZero));
+    ops = ops.filter((x) => x.numericValue === null || !x.isZero);
     if (ops.length === 0)
         return ce.number(0);
     if (ops.length === 1)
@@ -21045,8 +21047,7 @@ function canonicalAdd(ce, ops) {
     if (ops.length === 2) {
         let im = 0;
         let re = 0;
-        if (ops[0].numericValue !== null)
-            re = asFloat(ops[0]);
+        re = asFloat(ops[0]);
         if (re !== null && re !== 0)
             im = getImaginaryCoef(ops[1]);
         else {
@@ -21077,7 +21078,8 @@ function domainAdd(_ce, args) {
 function simplifyAdd(ce, args) {
     console.assert(args.length > 1, `simplifyAdd: not enough args`);
     const sum = new Sum(ce);
-    for (const arg of args) {
+    for (let arg of args) {
+        arg = arg.simplify();
         if (arg.isImaginary && arg.isInfinity)
             return ce.symbol('ComplexInfinity');
         if (arg.isNaN || arg.symbol === 'Undefined')
@@ -21087,7 +21089,25 @@ function simplifyAdd(ce, args) {
     }
     return sum.asExpression('expression');
 }
+function evalAddNum(ops) {
+    let sum = 0;
+    for (const op of ops) {
+        const v = op.numericValue;
+        if (typeof v === 'number')
+            sum += v;
+        else
+            return null;
+    }
+    return sum;
+}
 function evalAdd(ce, ops, mode = 'evaluate') {
+    // @fastpath
+    if (mode === 'N' && ce.numericMode === 'machine') {
+        ops = ops.map((x) => x.N());
+        const sum = evalAddNum(ops);
+        if (sum !== null)
+            return ce.number(sum);
+    }
     //
     // First pass: looking for early exits
     //
@@ -21102,6 +21122,8 @@ function evalAdd(ce, ops, mode = 'evaluate') {
     console.assert(flattenOps(ops, 'Add') === null);
     if (mode === 'N')
         ops = ops.map((x) => x.N());
+    else
+        ops = ops.map((x) => x.evaluate());
     return new Sum(ce, ops).asExpression(mode === 'N' ? 'numeric' : 'expression');
 }
 function canonicalSummation(ce, body, range) {
@@ -21198,7 +21220,7 @@ function evalSummation(ce, expr, range, mode) {
     if (!fn.scope)
         for (let i = lower; i <= upper; i++) {
             const term = fn.N();
-            if (!term.isLiteral)
+            if (term.numericValue === null)
                 return undefined;
             sum = add(sum, term);
         }
@@ -21206,7 +21228,7 @@ function evalSummation(ce, expr, range, mode) {
         for (let i = lower; i <= upper; i++) {
             ce.set({ [index]: i });
             const term = fn.N();
-            if (!term.isLiteral) {
+            if (term.numericValue === null) {
                 ce.context = savedContext;
                 return undefined;
             }
@@ -21241,8 +21263,8 @@ function makePositive(expr) {
     return [1, expr];
 }
 function apply(expr, fn, bigFn, complexFn) {
-    console.assert(expr.isLiteral);
     const n = expr.numericValue;
+    console.assert(n !== null);
     if (typeof n === 'number') {
         if (bignumPreferred(expr.engine) && bigFn)
             return expr.engine.chop(bigFn(expr.engine.bignum(n)));
@@ -21269,12 +21291,12 @@ function apply(expr, fn, bigFn, complexFn) {
     return NaN;
 }
 function applyN(expr, fn, bigFn, complexFn) {
-    if (!expr.isLiteral)
+    if (expr.numericValue === null)
         return undefined;
     return expr.engine.number(apply(expr, fn, bigFn, complexFn));
 }
 function apply2(expr1, expr2, fn, bigFn, complexFn) {
-    console.assert(expr1.isLiteral && expr2.isLiteral);
+    console.assert(expr1.numericValue !== null && expr2.numericValue !== null);
     const ce = expr1.engine;
     let m1 = expr1.numericValue;
     if (isMachineRational(m1))
@@ -21309,7 +21331,7 @@ function apply2(expr1, expr2, fn, bigFn, complexFn) {
     return NaN;
 }
 function apply2N(expr1, expr2, fn, bigFn, complexFn) {
-    if (!expr1.isLiteral || !expr2.isLiteral)
+    if (expr1.numericValue === null || expr2.numericValue === null)
         return undefined;
     return expr1.engine.number(apply2(expr1, expr2, fn, bigFn, complexFn));
 }
@@ -21324,11 +21346,11 @@ function canonicalPower(ce, base, exponent, metadata) {
     exponent = validateArgument(ce, exponent?.canonical, 'Number');
     if (exponent.symbol === 'ComplexInfinity')
         return ce._NAN;
-    if (exponent.isLiteral) {
+    if (exponent.numericValue !== null) {
         if (exponent.isZero)
             return ce._ONE;
-        if (base.isLiteral) {
-            const smallBase = asFloat(base);
+        if (base.numericValue !== null) {
+            const numBase = asFloat(base);
             //
             // Special cases
             //
@@ -21336,10 +21358,10 @@ function canonicalPower(ce, base, exponent, metadata) {
             // See https://docs.sympy.org/1.6/modules/core.html#pow
             //
             // if (base.isOne) return ce._ONE;
-            if (smallBase === 1)
+            if (numBase === 1)
                 return ce._ONE;
             // if (base.isZero) {
-            if (smallBase === 0) {
+            if (numBase === 0) {
                 if (exponent.isPositive)
                     return ce._ZERO;
                 if (exponent.isNegative)
@@ -21351,21 +21373,19 @@ function canonicalPower(ce, base, exponent, metadata) {
                 //  x^(-1)
                 // if (base.isOne) return ce._ONE;
                 // if (base.isNegativeOne) return ce._NEGATIVE_ONE;
-                if (smallBase === 1)
+                if (numBase === 1)
                     return ce._ONE;
-                if (smallBase === -1)
+                if (numBase === -1)
                     return ce._NEGATIVE_ONE;
                 if (base.isInfinity)
                     return ce._ZERO;
                 const r = base.numericValue;
-                if (r !== null) {
-                    if (typeof r === 'number' && Number.isInteger(r))
-                        return ce.number([1, r], { metadata });
-                    if (r instanceof Decimal && r.isInteger())
-                        return ce.number([ce._BIGNUM_ONE, r], { metadata });
-                    if (isRational(r))
-                        return ce.number(inverse(r), { metadata });
-                }
+                if (typeof r === 'number' && Number.isInteger(r))
+                    return ce.number([1, r], { metadata });
+                if (r instanceof Decimal && r.isInteger())
+                    return ce.number([ce._BIGNUM_ONE, r], { metadata });
+                if (isRational(r))
+                    return ce.number(inverse(r), { metadata });
                 return ce._fn('Power', [base, ce._NEGATIVE_ONE], metadata);
             }
             // x^{0.5}, x^{1/2} -> Square Root
@@ -21597,7 +21617,7 @@ function processPower(ce, base, exponent, mode) {
     // If square root or cube root, attempt to factor out the perfect
     // factors: sqrt(75) -> 5^2 * 3
     //
-    if (mode !== 'N' && base.isLiteral && base.isInteger) {
+    if (mode !== 'N' && base.numericValue !== null && base.isInteger) {
         const smallExpr = asSmallInteger(exponent);
         if (smallExpr)
             return numEvalPower(ce, base, exponent);
@@ -21632,7 +21652,8 @@ function processPower(ce, base, exponent, mode) {
                     }
                 }
                 else if (typeof base.numericValue === 'number') {
-                    if (d % 2 === 0 && base.numericValue < 0 && !complexAllowed(ce))
+                    // Square root of a negative number, and no complex allowed
+                    if (base.numericValue < 0 && d % 2 === 0 && !complexAllowed(ce))
                         return ce._NAN;
                     const [factor, root] = factorPower$1(Math.abs(base.numericValue), d);
                     const sign = base.numericValue < 0
@@ -21662,7 +21683,9 @@ function processPower(ce, base, exponent, mode) {
             return undefined;
         }
     }
-    if (mode !== 'simplify' && base.isLiteral && exponent.isLiteral)
+    if (mode !== 'simplify' &&
+        base.numericValue !== null &&
+        exponent.numericValue !== null)
         return numEvalPower(ce, base, exponent);
     return undefined;
 }
@@ -21777,22 +21800,46 @@ function canonicalMultiply(ce, ops) {
         return ops[0];
     if (ops.length === 2)
         return multiply2(ops[0], ops[1]);
-    return simplifyMultiply(ce, ops);
-    // return new Product(ce, ops).asExpression();
+    const product = new Product(ce);
+    for (const op of ops) {
+        if (op.isNaN || op.symbol === 'Undefined')
+            return ce._NAN;
+        product.addTerm(op);
+    }
+    return product.asExpression();
 }
 function simplifyMultiply(ce, ops) {
     console.assert(flattenOps(ops, 'Multiply') === null);
     const product = new Product(ce);
-    for (const op of ops) {
+    for (let op of ops) {
+        op = op.simplify();
         if (op.isNaN || op.symbol === 'Undefined')
             return ce._NAN;
         product.addTerm(op);
     }
     return product.asExpression();
 }
+function fastEvalMultiply(ops) {
+    let prod = 1;
+    for (const op of ops) {
+        if (typeof op.numericValue !== 'number')
+            return null;
+        prod *= op.numericValue;
+    }
+    return prod;
+}
 function evalMultiply(ce, ops, mode = 'evaluate') {
     console.assert(ops.length > 1, 'evalMultiply(): no arguments');
     //
+    // @fastpath
+    //
+    if (mode === 'N' && ce.numericMode === 'machine') {
+        ops = ops.map((x) => x.N());
+        const result = fastEvalMultiply(ops);
+        if (result !== null)
+            return ce.number(result);
+    }
+    //
     // First pass: looking for early exits
     //
     for (const op of ops) {
@@ -21804,6 +21851,8 @@ function evalMultiply(ce, ops, mode = 'evaluate') {
     console.assert(flattenOps(ops, 'Multiply') === null);
     if (mode === 'N')
         ops = ops.map((x) => x.N());
+    else
+        ops = ops.map((x) => x.evaluate());
     //
     // Second pass
     //
@@ -21822,34 +21871,41 @@ function multiply2(op1, op2, metadata) {
     console.assert(op1.isCanonical);
     console.assert(op2.isCanonical);
     const ce = op1.engine;
-    if (op1.isLiteral && op2.isLiteral && op1.isInteger && op2.isInteger) {
+    if (op1.numericValue !== null &&
+        op2.numericValue !== null &&
+        op1.isInteger &&
+        op2.isInteger) {
         return (apply2N(op1, op2, (a, b) => a * b, (a, b) => a.mul(b)) ?? ce._NAN);
     }
+    if (op1.isNaN ||
+        op2.isNaN ||
+        op1.symbol === 'Undefined' ||
+        op2.symbol === 'Undefined')
+        return ce._NAN;
     if (op1.isNothing)
         return op2;
     if (op2.isNothing)
         return op1;
-    if (op1.isLiteral && op1.isOne)
-        return op2;
-    if (op2.isLiteral && op2.isOne)
-        return op1;
-    if (op1.isLiteral && op1.isNegativeOne)
-        return canonicalNegate(op2);
-    if (op2.isLiteral && op2.isNegativeOne)
-        return canonicalNegate(op1);
-    let sign = 1;
-    let c = op1;
-    let t = op2;
-    if (!c.isLiteral) {
-        t = op2;
-        c = op1;
+    if (op1.numericValue !== null) {
+        if (op1.isOne)
+            return op2;
+        if (op1.isNegativeOne)
+            return canonicalNegate(op2);
+    }
+    if (op2.numericValue !== null) {
+        if (op2.isOne)
+            return op1;
+        if (op2.isNegativeOne)
+            return canonicalNegate(op1);
     }
+    let sign = 1;
+    let [t, c] = op1.numericValue !== null ? [op1, op2] : [op2, op1];
     console.assert(t.head !== 'Subtract');
     if (t.head === 'Negate') {
         t = t.op1;
         sign = -sign;
     }
-    if (c.isLiteral) {
+    if (c.numericValue !== null) {
         const r = asRational(c);
         if (r) {
             if (isRationalOne(r))
@@ -21861,12 +21917,10 @@ function multiply2(op1, op2, metadata) {
                     c = canonicalNegate(c);
                 return ce.add(t.ops.map((x) => multiply2(c, x)), metadata);
             }
-            if (t.isLiteral) {
-                const tr = asRational(t);
-                if (tr) {
-                    const p = mul(r, tr);
-                    return ce.number(sign < 0 ? neg(p) : p, { metadata });
-                }
+            const tr = asRational(t);
+            if (tr) {
+                const p = mul(r, tr);
+                return ce.number(sign < 0 ? neg(p) : p, { metadata });
             }
             if (sign < 0)
                 return ce._fn('Multiply', [canonicalNegate(c), t], metadata);
@@ -21958,7 +22012,7 @@ function evalMultiplication(ce, expr, range, mode) {
         const n = ce.number(i);
         const r = fn.subs({ _1: n, _: n });
         const term = r.N();
-        if (!term.isLiteral)
+        if (term.numericValue === null)
             return undefined;
         product = mul(product, term);
     }
@@ -21981,7 +22035,7 @@ function canonicalDivide(ce, op1, op2) {
     op2 = validateArgument(ce, op2, 'Number');
     if (!op1.isValid || !op2.isValid)
         return ce._fn('Divide', [op1, op2]);
-    if (op1.isLiteral && op2.isLiteral) {
+    if (op1.numericValue !== null && op2.numericValue !== null) {
         if (op2.isOne)
             return op1;
         if (op2.isNegativeOne)
@@ -21999,25 +22053,25 @@ function canonicalDivide(ce, op1, op2) {
         (op2.head === 'Divide' || op2.head === 'Rational')) {
         return canonicalDivide(ce, ce.mul([op1.op1, op2.op2]), ce.mul([op1.op2, op2.op1]));
     }
-    if (op1.isLiteral) {
-        const r = op1.numericValue;
-        if (isMachineRational(r)) {
-            const [a, b] = r;
+    const num1 = op1.numericValue;
+    if (num1 !== null) {
+        if (isMachineRational(num1)) {
+            const [a, b] = num1;
             return canonicalDivide(ce, ce.mul([ce.number(a), op2]), ce.number(b));
         }
-        if (isBigRational(r)) {
-            const [a, b] = r;
+        if (isBigRational(num1)) {
+            const [a, b] = num1;
             return canonicalDivide(ce, ce.mul([ce.number(a), op2]), ce.number(b));
         }
     }
-    if (op2.isLiteral) {
-        const r = op2.numericValue;
-        if (isMachineRational(r)) {
-            const [a, b] = r;
+    const num2 = op2.numericValue;
+    if (num2 !== null) {
+        if (isMachineRational(num2)) {
+            const [a, b] = num2;
             return canonicalDivide(ce, ce.mul([op1, ce.number(b)]), ce.number(a));
         }
-        if (isBigRational(r)) {
-            const [a, b] = r;
+        if (isBigRational(num2)) {
+            const [a, b] = num2;
             return canonicalDivide(ce, ce.mul([op1, ce.number(b)]), ce.number(a));
         }
     }
@@ -22031,11 +22085,11 @@ function canonicalDivide(ce, op1, op2) {
     let [dSign, d] = makePositive(op2);
     n = n.canonical;
     d = d.canonical;
-    if (d.isLiteral && d.isOne)
+    if (d.numericValue !== null && d.isOne)
         return nSign * dSign < 0 ? canonicalNegate(n) : n;
     // Divide: transform into multiply/power
     d = ce.inverse(d);
-    if (n.isLiteral) {
+    if (n.numericValue !== null) {
         if (n.isOne)
             return d;
         if (n.isNegativeOne)
@@ -22049,7 +22103,7 @@ function canonicalDivide(ce, op1, op2) {
  * Simplify form of 'Divide' (and 'Rational')
  */
 function simplifyDivide(ce, op1, op2) {
-    if (op1.isLiteral && op2.isLiteral) {
+    if (op1.numericValue !== null && op2.numericValue !== null) {
         const r1 = asRational(op1);
         const r2 = asRational(op2);
         if (r1 && r2 && !isRationalZero(r2))
@@ -22112,6 +22166,7 @@ const ARITHMETIC_LIBRARY = [
                 threadable: true,
                 idempotent: true,
                 complexity: 1300,
+                hold: 'all',
                 signature: {
                     domain: 'NumericFunction',
                     codomain: (ce, args) => domainAdd(ce, args.map((x) => x.domain)),
@@ -22366,6 +22421,7 @@ const ARITHMETIC_LIBRARY = [
                 commutative: true,
                 idempotent: true,
                 complexity: 2100,
+                hold: 'all',
                 signature: {
                     domain: 'NumericFunction',
                     canonical: (ce, args) => canonicalMultiply(ce, args),
@@ -22427,7 +22483,14 @@ const ARITHMETIC_LIBRARY = [
                     canonical: (ce, args) => canonicalPower(ce, args[0], args[1]) ?? ce._fn('Power', args),
                     simplify: (ce, ops) => processPower(ce, ops[0], ops[1], 'simplify'),
                     evaluate: (ce, ops) => processPower(ce, ops[0], ops[1], 'evaluate'),
-                    N: (ce, ops) => processPower(ce, ops[0], ops[1], 'N'),
+                    N: (ce, ops) => {
+                        // @fastpath
+                        if (ce.numericMode === 'machine' &&
+                            typeof ops[0].numericValue === 'number' &&
+                            typeof ops[1].numericValue === 'number')
+                            return ce.number(Math.pow(ops[0].numericValue, ops[1].numericValue));
+                        return processPower(ce, ops[0], ops[1], 'N');
+                    },
                     // Defined as RealNumber for all power in RealNumber when base > 0;
                     // when x < 0, only defined if n is an integer
                     // if x is a non-zero complex, defined as ComplexNumber
@@ -23262,8 +23325,8 @@ const CORE_LIBRARY = [
                         // Is it a string in a base form:
                         // `"deadbeef"_{16}` `"0101010"_2?
                         if (op1.string) {
-                            if (op2.isLiteral && asSmallInteger(op2) !== null) {
-                                const base = asSmallInteger(op2);
+                            const base = asSmallInteger(op2);
+                            if (base !== null) {
                                 if (base > 1 && base <= 36) {
                                     const [value, rest] = fromDigits(op1.string, base);
                                     if (rest) {
@@ -23280,9 +23343,7 @@ const CORE_LIBRARY = [
                             if (op1.symbolDefinition?.at)
                                 return ce._fn('At', [op1, op2.canonical]);
                             // Maybe a compound symbol
-                            let sub = op2.string ?? op2.symbol;
-                            if (!sub && op2.isLiteral && asSmallInteger(op2) !== null)
-                                sub = asSmallInteger(op2).toString();
+                            const sub = op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
                             if (sub)
                                 return ce.symbol(op1.symbol + '_' + sub);
                         }
@@ -23304,10 +23365,7 @@ const CORE_LIBRARY = [
                         if (ops.length === 0)
                             return ce.symbol('Nothing');
                         const arg = ops
-                            .map((x) => x.symbol ??
-                            x.string ??
-                            (x.isLiteral ? asSmallInteger(x)?.toString() : null) ??
-                            '')
+                            .map((x) => x.symbol ?? x.string ?? asSmallInteger(x)?.toString() ?? '')
                             .join('');
                         if (arg.length > 0)
                             return ce.symbol(arg);
@@ -24445,7 +24503,7 @@ const TRIGONOMETRY_LIBRARY = [
                         if (ops.length !== 1)
                             return ce.box(['Degrees', ops]);
                         const arg = validateArgument(ce, ops[0].canonical, 'Number');
-                        if (!arg.isValid || !arg.isLiteral)
+                        if (arg.numericValue === null || !arg.isValid)
                             return ce.box(['Degrees', arg]);
                         return ce.mul([arg, ce.box(['Divide', 'Pi', 180])]);
                     },
@@ -25066,7 +25124,7 @@ function constructibleValues(ce, head, x) {
         return cache;
     });
     x = x.N();
-    if (!x.isLiteral)
+    if (x.numericValue === null)
         return undefined;
     let theta = asFloat(x) ?? null;
     if (theta === null)
@@ -25163,7 +25221,10 @@ function evalTrig(ce, mode, head, op) {
         case 'Artanh':
             return applyN(op, Math.atanh, (x) => x.atanh(), (x) => x.atanh());
         case 'Cos':
-            return applyN(op, Math.cos, (x) => x.cos(), (x) => x.cos());
+            return applyN(op, Math.cos, (x) => x
+                .toSignificantDigits(ce.precision + 4)
+                .cos()
+                .toSignificantDigits(ce.precision), (x) => x.cos());
         case 'Cosh':
             return applyN(op, Math.cosh, (x) => x.cosh(), (x) => x.cosh());
         case 'Cot':
@@ -25179,11 +25240,17 @@ function evalTrig(ce, mode, head, op) {
         case 'Sech':
             return applyN(op, (x) => 1 / Math.cosh(x), (x) => ce._BIGNUM_ONE.div(x.cosh()), (x) => x.cosh().inverse());
         case 'Sin':
-            return applyN(op, Math.sin, (x) => x.sin(), (x) => x.sin());
+            return applyN(op, Math.sin, (x) => x
+                .toSignificantDigits(ce.precision + 4)
+                .sin()
+                .toSignificantDigits(ce.precision), (x) => x.sin());
         case 'Sinh':
             return applyN(op, Math.sinh, (x) => x.sinh(), (x) => x.sinh());
         case 'Tan':
-            return applyN(op, Math.tan, (x) => x.tan(), (x) => x.tan());
+            return applyN(op, Math.tan, (x) => x
+                .toSignificantDigits(ce.precision + 4)
+                .tan()
+                .toSignificantDigits(ce.precision), (x) => x.tan());
         case 'Tanh':
             return applyN(op, Math.tanh, (x) => x.tanh(), (x) => x.tanh());
     }
@@ -25429,8 +25496,6 @@ function valueToFlags(value) {
         finite: value.isFinite,
         even: value.isEven,
         odd: value.isOdd,
-        prime: value.isPrime,
-        composite: value.isComposite,
     });
 }
 class BoxedSymbolDefinitionImpl {
@@ -25549,11 +25614,47 @@ class BoxedSymbolDefinitionImpl {
             this.bind();
         if (this.constant)
             throw new Error(`The value of the constant "${this.name}" cannot be changed`);
-        if (typeof val === 'number')
+        if (typeof val === 'number') {
+            if (typeof this._value?.numericValue === 'number') {
+                this._value['_value'] = val;
+            }
+            else {
+                this._value = this._engine.number(val);
+            }
+            // this.setProps(valueToFlags(val));
+            this._number = undefined;
+            this._integer = undefined;
+            this._rational = undefined;
+            this._algebraic = undefined;
+            this._real = undefined;
+            this._extendedReal = undefined;
+            this._complex = undefined;
+            this._extendedComplex = undefined;
+            this._imaginary = undefined;
+            this._positive = undefined;
+            this._nonPositive = undefined;
+            this._negative = undefined;
+            this._nonNegative = undefined;
+            this._zero = undefined;
+            this._notZero = undefined;
+            this._one = undefined;
+            this._negativeOne = undefined;
+            this._infinity = undefined;
+            this._finite = undefined;
+            this._NaN = undefined;
+            this._even = undefined;
+            this._odd = undefined;
+            this._prime = undefined;
+            this._composite = undefined;
+        }
+        else if (val) {
             val = this._engine.box(val);
-        this._value = val ?? null;
-        if (val)
-            this.setProps(valueToFlags(val));
+            this._value = val;
+            if (val)
+                this.setProps(valueToFlags(val));
+        }
+        else
+            this._value = null;
     }
     get domain() {
         if (this._domain === null)
@@ -26200,12 +26301,12 @@ function costFunction(expr) {
     //
     // 2/ Literal Numeric Values
     //
-    if (expr.isLiteral) {
+    const num = expr.numericValue;
+    if (num !== null) {
         if (expr.isZero)
             return 1;
-        if (expr.isInteger && asFloat(expr) !== null)
+        if (expr.isInteger)
             return numericCostFunction(asFloat(expr));
-        const num = expr.numericValue;
         if (isRational(num)) {
             if (isMachineRational(num))
                 return numericCostFunction(num[0]) + numericCostFunction(num[1]) + 1;
@@ -26725,9 +26826,6 @@ class BoxedSymbol extends AbstractBoxedExpression {
     get isNothing() {
         return this._name === 'Nothing';
     }
-    get isLiteral() {
-        return false;
-    }
     //  A base definition is the base class of both symbol and function definition
     get baseDefinition() {
         if (this._def === null)
@@ -27124,7 +27222,7 @@ function makeCanonicalSymbol(ce, name) {
     const def = ce.lookupSymbol(name, undefined, ce.context);
     if (def) {
         if (def.hold === false && def.value)
-            return ce.box(def.value);
+            return def.value;
     }
     return new BoxedSymbol(ce, name, { canonical: true });
 }
@@ -27245,6 +27343,7 @@ class ComputeEngine {
         };
         if (options !== undefined && typeof options !== 'object')
             throw Error('Unexpected argument');
+        this.strict = true;
         this._latexDictionary = options?.latexDictionary;
         this._jsonSerializationOptions = {
             exclude: [],
@@ -27627,6 +27726,16 @@ class ComputeEngine {
      * wikidata, if provided.
      */
     lookupSymbol(symbol, wikidata, scope) {
+        // @fastpath
+        if (!this.strict) {
+            scope ?? (scope = this.context ?? undefined);
+            let def = undefined;
+            while (scope && !def) {
+                def = scope.symbolTable?.symbols.get(symbol);
+                scope = scope.parentScope;
+            }
+            return def;
+        }
         if (typeof symbol !== 'string')
             throw Error('Expected a string');
         // Wildcards never have definitions
@@ -27795,20 +27904,46 @@ class ComputeEngine {
         console.assert(this.context !== null);
     }
     set(identifiers) {
+        // @fastpath
+        if (!this.strict) {
+            for (const k of Object.keys(identifiers)) {
+                if (k !== 'Nothing') {
+                    const def = this.lookupSymbol(k);
+                    const idk = identifiers[k];
+                    if (def)
+                        def.value = idk ?? undefined;
+                    else if (idk !== undefined && idk !== null) {
+                        const val = this.box(idk);
+                        if (val.domain.isNumeric)
+                            this.defineSymbol({ name: k, value: val, domain: 'Number' });
+                        else
+                            this.defineSymbol({ name: k, value: val });
+                    }
+                }
+            }
+            return;
+        }
         for (const k of Object.keys(identifiers)) {
             if (k !== 'Nothing') {
                 const def = this.lookupSymbol(k);
-                const val = this.box(identifiers[k]);
-                if (def) {
-                    if (def.domain && !val.domain.isCompatible(def.domain))
-                        throw Error(`Expected value with domain ${def.domain.toString()} for "${k}"`);
-                    def.value = val;
+                const idk = identifiers[k];
+                if (idk === undefined || idk === null) {
+                    if (def)
+                        def.value = undefined;
                 }
                 else {
-                    if (val.domain.isNumeric)
-                        this.defineSymbol({ name: k, value: val, domain: 'Number' });
-                    else
-                        this.defineSymbol({ name: k, value: val });
+                    const val = this.box(idk);
+                    if (def) {
+                        if (def.domain && !val.domain.isCompatible(def.domain))
+                            throw Error(`Expected value with domain ${def.domain.toString()} for "${k}"`);
+                        def.value = val;
+                    }
+                    else {
+                        if (val.domain.isNumeric)
+                            this.defineSymbol({ name: k, value: val, domain: 'Number' });
+                        else
+                            this.defineSymbol({ name: k, value: val });
+                    }
                 }
             }
         }
@@ -27938,7 +28073,7 @@ class ComputeEngine {
     }
     add(ops, metadata) {
         // Short path. Note that are arguments are **not** validated.
-        ops = flattenSequence(ops);
+        // ops = flattenSequence(ops);
         const result = canonicalAdd(this, ops);
         if (metadata?.latex !== undefined)
             result.latex = metadata.latex;
@@ -28062,7 +28197,7 @@ class ComputeEngine {
         // `Half` is a synonym for the rational 1/2
         if (name === 'Half')
             return this._HALF;
-        if (!isValidIdentifier(name)) {
+        if (this.strict && !isValidIdentifier(name)) {
             const where = options?.metadata?.latex;
             const nameStr = `'${name}'`;
             if (where)
@@ -28128,16 +28263,15 @@ class ComputeEngine {
                 return this._ZERO;
             if (n === -1)
                 return this._NEGATIVE_ONE;
-            if (isNaN(n))
-                return this._NAN;
-            if (!Number.isFinite(n))
-                return n < 0 ? this._NEGATIVE_INFINITY : this._POSITIVE_INFINITY;
-            if (Number.isInteger(n) && this._commonNumbers[n] === null) {
-                this._commonNumbers[n] = boxNumber(this, value);
+            if (Number.isInteger(n) && this._commonNumbers[n] !== undefined) {
                 if (this._commonNumbers[n] === null)
-                    return this._NAN;
+                    this._commonNumbers[n] = boxNumber(this, value) ?? this._NAN;
                 return this._commonNumbers[n];
             }
+            if (Number.isNaN(n))
+                return this._NAN;
+            if (!Number.isFinite(n))
+                return n < 0 ? this._NEGATIVE_INFINITY : this._POSITIVE_INFINITY;
         }
         return boxNumber(this, value, options) ?? this._NAN;
     }
@@ -28271,8 +28405,20 @@ class ComputeEngine {
     forget(symbol) {
         if (!this.context)
             throw Error('No scope available');
+        //
+        // Theory of Operations
+        //
+        // When forgeting we need to preserve existing definitions for symbols,
+        // as some expressions may be pointing to them. Instead, we
+        // reset the value/domain of those definitions.
+        //
         if (symbol === undefined) {
-            this.context.symbolTable = undefined;
+            if (this.context.symbolTable?.symbols)
+                for (const k of this.context.symbolTable.symbols.keys())
+                    this.forget(k);
+            if (this.context.symbolTable?.functions)
+                for (const k of this.context.symbolTable.functions.keys())
+                    this.forget(k);
             this.assumptions.clear();
             return;
         }
@@ -28284,13 +28430,17 @@ class ComputeEngine {
         if (typeof symbol === 'string') {
             // Remove symbol definition in the current scope (if any)
             if (this.context.symbolTable) {
-                this.context.symbolTable.symbols.delete(symbol);
+                const sdef = this.context.symbolTable.symbols.get(symbol);
+                if (sdef) {
+                    sdef.value = undefined;
+                    sdef.domain = undefined;
+                }
+                this.context.symbolTable.functions.get(symbol);
                 this.context.symbolTable.symbolWikidata.delete(symbol);
-                this.context.symbolTable.functions.delete(symbol);
                 this.context.symbolTable.functionWikidata.delete(symbol);
             }
             // Remove any assumptions that make a reference to this symbol
-            // (note that when a scope if created, any assumptions from the
+            // (note that when a scope is created, any assumptions from the
             // parent scope are copied over, so this effectively removes any
             // reference to this symbol, even if there are assumptions about
             // it in a parent scope. However, when the current scope exits,
@@ -28305,6 +28455,6 @@ class ComputeEngine {
 }
 
 // This file is the root of the `compute-engine` package
-const version = '0.9.0';
+const version = '0.10.0';
 
 export { ComputeEngine, getVars, isEnvironmentEntry, isFunctionEntry, isInfixEntry, isMatchfixEntry, isPostfixEntry, isPrefixEntry, isSymbolEntry, version };