Merge branch 'main' into summation_extension

Author: arnog

CHANGELOG.md

@@ -1,6 +1,26 @@
-## 0.22.0 
+## [Unreleased]
 
- **Release Date:** 2023-11-13
+## Bug Fixes
+
+- The expression `\frac5 7` is now parsed correctly as `\frac{5}{7}` instead of
+  `\frac{5}{}7`.
+- Do not sugar non-canonical expression. Previously,
+  `ce.parse('\frac{1}{2}', {canonical: false})` would return `Half` instead of
+  `['Divide', '1', '2']`.
+- **#132** Attempting to set a value to 0 with
+  `ce.defineSymbol("count", {value: 0})` would fail: the symbol would be
+  undefined.
+
+## Improvements
+
+- Significant improvements to symbolic computation. Now, boxing,
+  canonicalization and evaluation are more consistent and produce more
+  predictable results.
+- Adedd the `\neg` command, synonym for `\lnot` -> `Not`.
+
+## 0.22.0
+
+**Release Date:** 2023-11-13
 
 ### Breaking Changes
 

src/compute-engine/assume.ts

@@ -98,7 +98,7 @@ function assumeEquality(proposition: BoxedExpression): AssumeResult {
       ce.assumptions.set(
         ce.fn('Equal', [
           ce
-            .add([proposition.op1.canonical, ce.neg(proposition.op2.canonical)])
+            .add(proposition.op1.canonical, ce.neg(proposition.op2.canonical))
             .simplify(),
           0,
         ]),
@@ -193,7 +193,7 @@ function assumeInequality(proposition: BoxedExpression): AssumeResult {
     op = '<=';
   }
   if (!op) return 'internal-error';
-  const p = ce.add([lhs!.canonical, ce.neg(rhs!.canonical)]).simplify();
+  const p = ce.add(lhs!.canonical, ce.neg(rhs!.canonical)).simplify();
 
   // Case 2
   const result = ce.box([op === '<' ? 'Less' : 'LessEqual', p, 0]).evaluate();

src/compute-engine/boxed-expression/box.ts

@@ -352,7 +352,7 @@ export function boxFunction(
       const op1 = box(ce, ops[0], options);
       const im = asFloat(op1);
       if (im !== null && im !== 0) return ce.number(ce.complex(0, im), options);
-      return ce.mul([op1, ce.I]);
+      return ce.mul(op1, ce.I);
     }
     if (ops.length === 2) {
       const op1 = box(ce, ops[0], options);
@@ -365,7 +365,7 @@ export function boxFunction(
           return ce.number(ce.complex(re, im), options);
         return op1;
       }
-      return ce.add([op1, ce.mul([op2, ce.I])], options.metadata);
+      return ce.add(op1, ce.mul(op2, ce.I));
     }
   }
 

src/compute-engine/boxed-expression/boxed-function.ts

@@ -40,6 +40,11 @@ import { apply } from '../function-utils';
 import { shouldHold } from '../symbolic/utils';
 import { at, isFiniteIndexableCollection } from '../collection-utils';
 import { narrow } from './boxed-domain';
+import { canonicalAdd } from '../library/arithmetic-add';
+import { canonicalPower } from '../library/arithmetic-power';
+import { canonicalNegate } from '../symbolic/negate';
+import { canonicalDivide } from '../library/arithmetic-divide';
+import { canonicalMultiply } from '../library/arithmetic-multiply';
 
 /**
  * A boxed function represent an expression that can be
@@ -374,7 +379,7 @@ export class BoxedFunction extends _BoxedExpression {
     if (s !== undefined) return false;
 
     // Try to simplify the difference of the expressions
-    const diff = this.engine.add([this, this.engine.neg(rhs)]).simplify();
+    const diff = this.engine.add(this, this.engine.neg(rhs)).simplify();
     if (diff.isZero) return true;
 
     return this.isSame(rhs);
@@ -690,19 +695,24 @@ function makeNumericFunction(
   // Short path for some functions
   // (avoid looking up a definition)
   //
-  if (head === 'Add') return ce.add(ops, metadata);
-  if (head === 'Negate') return ce.neg(ops[0], metadata);
-  if (head === 'Multiply') return ce.mul(ops, metadata);
-  if (head === 'Divide') return ce.div(ops[0], ops[1], metadata);
-  if (head === 'Exp') return ce.pow(ce.E, ops[0], metadata);
-  if (head === 'Power') return ce.pow(ops[0], ops[1], metadata);
-  if (head === 'Square') return ce.pow(ops[0], 2, metadata);
+  if (head === 'Add')
+    return canonicalAdd(ce, flattenOps(flattenSequence(ops), 'Add'));
+  if (head === 'Negate') return canonicalNegate(ops[0]);
+  if (head === 'Multiply')
+    return canonicalMultiply(ce, flattenOps(flattenSequence(ops), 'Multiply'));
+  if (head === 'Divide')
+    return canonicalDivide(ce, ops[0].canonical, ops[1].canonical);
+  if (head === 'Exp') return canonicalPower(ce, ce.E, ops[0].canonical);
+  if (head === 'Power')
+    return canonicalPower(ce, ops[0].canonical, ops[1].canonical);
+  if (head === 'Square')
+    return canonicalPower(ce, ops[0].canonical, ce.number(2));
   if (head === 'Sqrt') {
     const op = ops[0].canonical;
     // We preserve square roots of rationals as "exact" values
     if (isRational(op.numericValue)) return ce._fn('Sqrt', [op], metadata);
 
-    return ce.pow(op, ce.Half, metadata);
+    return canonicalPower(ce, op, ce.Half);
   }
   if (head === 'Ln') return ce._fn('Ln', ops, metadata);
 

src/compute-engine/boxed-expression/boxed-symbol-definition.ts

@@ -97,7 +97,7 @@ export class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
       this._defValue = def.value;
       this._value = null;
     } else {
-      if (def.value) {
+      if (def.value !== undefined) {
         if (isLatexString(def.value))
           this._value = ce.parse(def.value) ?? ce.symbol('Undefined');
         else if (typeof def.value === 'function')

src/compute-engine/boxed-expression/serialize.ts

@@ -166,6 +166,36 @@ export function serializeJsonCanonicalFunction(
     }
   }
 
+  if (head === 'Add' && args.length === 2 && !exclusions.includes('Subtract')) {
+    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
+        );
+    }
+    if (args[1]?.head === 'Negate') {
+      return serializeJsonFunction(
+        ce,
+        'Subtract',
+        [args[0], args[1].op1],
+        metadata
+      );
+    }
+  }
+
+  if (head === 'Tuple') {
+    if (args.length === 1 && !exclusions.includes('Single'))
+      return serializeJsonFunction(ce, 'Single', args, metadata);
+    if (args.length === 2 && !exclusions.includes('Pair'))
+      return serializeJsonFunction(ce, 'Pair', args, metadata);
+    if (args.length === 3 && !exclusions.includes('Triple'))
+      return serializeJsonFunction(ce, 'Triple', args, metadata);
+  }
+
   return serializeJsonFunction(ce, head, args, metadata);
 }
 
@@ -175,32 +205,27 @@ export function serializeJsonFunction(
   args: (undefined | BoxedExpression)[],
   metadata?: Metadata
 ): Expression {
-  // Special case some functions...
-
   const exclusions = ce.jsonSerializationOptions.exclude;
 
-  if (
-    (head === 'Rational' || head === 'Divide') &&
-    args.length === 2 &&
-    asSmallInteger(args[0]) === 1 &&
-    asSmallInteger(args[1]) === 2 &&
-    !exclusions.includes('Half')
-  ) {
-    return serializeJsonSymbol(ce, 'Half', {
-      ...metadata,
-      wikidata: 'Q39373172',
-    });
-  }
-
-  if (args.length === 1) {
+  //
+  // The only sugaring done for both canonical and non-canonical expressions
+  // is for 'Negate', since `-2` gets parsed as `['Negate', 2]` and not
+  // `-2`.
+  //
+  if (head === 'Negate' && args.length === 1) {
     const num0 = args[0]?.numericValue;
-    if (head === 'Negate' && num0 !== null) {
+    if (num0 !== null) {
       if (typeof num0 === 'number') return serializeJsonNumber(ce, -num0);
       if (num0 instanceof Decimal) return serializeJsonNumber(ce, num0.neg());
       if (num0 instanceof Complex) return serializeJsonNumber(ce, num0.neg());
       if (isRational(num0)) return serializeJsonNumber(ce, neg(num0));
     }
   }
+
+  //
+  // If there are some exclusions, try to avoid them.
+  // This is done both to canonical or non-canonical expressions.
+  //
   if (typeof head === 'string' && exclusions.includes(head)) {
     if (head === 'Rational' && args.length === 2)
       return serializeJsonFunction(ce, 'Divide', args, metadata);
@@ -267,8 +292,11 @@ export function serializeJsonFunction(
     if (head === 'Exp' && args.length === 1)
       return serializeJsonFunction(ce, 'Power', [ce.E, args[0]], metadata);
 
+    if (head === 'Pair' || head == 'Single' || head === 'Triple')
+      return serializeJsonFunction(ce, 'Tuple', args, metadata);
+
     // Note: even though 'Subtract' is boxed out, we still need to handle it here
-    // because the function may be called with a 'Subtract' head.
+    // because the function may be called with a non-canonical 'Subtract' head.
     if (head === 'Subtract' && args.length === 2)
       return serializeJsonFunction(
         ce,
@@ -280,36 +308,6 @@ export function serializeJsonFunction(
       return serializeJsonFunction(ce, 'Negate', args, metadata);
   }
 
-  if (head === 'Add' && args.length === 2 && !exclusions.includes('Subtract')) {
-    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
-        );
-    }
-    if (args[1]?.head === 'Negate') {
-      return serializeJsonFunction(
-        ce,
-        'Subtract',
-        [args[0], args[1].op1],
-        metadata
-      );
-    }
-  }
-
-  if (head === 'Tuple') {
-    if (args.length === 1 && !exclusions.includes('Single'))
-      return serializeJsonFunction(ce, 'Single', args, metadata);
-    if (args.length === 2 && !exclusions.includes('Pair'))
-      return serializeJsonFunction(ce, 'Pair', args, metadata);
-    if (args.length === 3 && !exclusions.includes('Triple'))
-      return serializeJsonFunction(ce, 'Triple', args, metadata);
-  }
-
   const jsonHead =
     typeof head === 'string' ? _escapeJsonString(head) : head.json;
 

src/compute-engine/boxed-expression/utils.ts

@@ -70,13 +70,16 @@ export function getSymbols(expr: BoxedExpression, result: Set<string>): void {
  */
 export function getUnknowns(expr: BoxedExpression, result: Set<string>): void {
   if (expr.symbol) {
-    const def = expr.engine.lookupSymbol(expr.symbol);
+    const s = expr.symbol;
+    if (s === 'Unknown' || s === 'Undefined' || s === 'Nothing') return;
+
+    const def = expr.engine.lookupSymbol(s);
     if (def && def.value !== undefined) return;
 
-    const fnDef = expr.engine.lookupFunction(expr.symbol);
+    const fnDef = expr.engine.lookupFunction(s);
     if (fnDef && (fnDef.signature.evaluate || fnDef.signature.N)) return;
 
-    result.add(expr.symbol);
+    result.add(s);
     return;
   }