mathjs 10.0.0 → 10.6.4

package/lib/esm/function/algebra/{simplify/simplifyCore.js → simplifyCore.js}

@@ -1,7 +1,8 @@
-import { isConstantNode, isFunctionNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
-import { factory } from '../../../utils/factory.js';
+import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, isOperatorNode } from '../../utils/is.js';
+import { createUtil } from './simplify/util.js';
+import { factory } from '../../utils/factory.js';
 var name = 'simplifyCore';
-var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'ParenthesisNode'];
+var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     equal,
@@ -11,13 +12,26 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
     multiply,
     divide,
     pow,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
-    ParenthesisNode
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
+    ParenthesisNode,
+    SymbolNode
   } = _ref;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
+  var {
+    hasProperty,
+    isCommutative
+  } = createUtil({
+    FunctionNode,
+    OperatorNode,
+    SymbolNode
+  });
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. In contrast, simplify()
@@ -26,30 +40,53 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
    *
    * Syntax:
    *
-   *     simplify.simplifyCore(expr)
+   *     simplifyCore(expr)
    *
    * Examples:
    *
    *     const f = math.parse('2 * 1 * x ^ (2 - 1)')
-   *     math.simplify.simpifyCore(f)                          // Node {2 * x}
-   *     math.simplify('2 * 1 * x ^ (2 - 1)', [math.simplify.simpifyCore]) // Node {2 * x}
+   *     math.simpifyCore(f)                          // Node {2 * x}
+   *     math.simplify('2 * 1 * x ^ (2 - 1)', [math.simplifyCore]) // Node {2 * x}
    *
    * See also:
    *
-   *     derivative
+   *     simplify, resolve, derivative
    *
    * @param {Node} node
    *     The expression to be simplified
+   * @param {Object} options
+   *     Simplification options, as per simplify()
+   * @return {Node} Returns expression with basic simplifications applied
    */
 
-  function simplifyCore(node) {
-    if (isOperatorNode(node) && node.isUnary()) {
-      var a0 = simplifyCore(node.args[0]);
+  function simplifyCore(node, options) {
+    var context = options ? options.context : undefined;
 
-      if (node.op === '+') {
-        // unary plus
-        return a0;
+    if (hasProperty(node, 'trivial', context)) {
+      // This node does nothing if it has only one argument, so if so,
+      // return that argument simplified
+      if (isFunctionNode(node) && node.args.length === 1) {
+        return simplifyCore(node.args[0], options);
+      } // For other node types, we try the generic methods
+
+
+      var simpChild = false;
+      var childCount = 0;
+      node.forEach(c => {
+        ++childCount;
+
+        if (childCount === 1) {
+          simpChild = simplifyCore(c, options);
+        }
+      });
+
+      if (childCount === 1) {
+        return simpChild;
       }
+    }
+
+    if (isOperatorNode(node) && node.isUnary()) {
+      var a0 = simplifyCore(node.args[0], options);
 
       if (node.op === '-') {
         // unary minus
@@ -64,9 +101,9 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
         return new OperatorNode(node.op, node.fn, [a0]);
       }
     } else if (isOperatorNode(node) && node.isBinary()) {
-      var _a = simplifyCore(node.args[0]);
+      var _a = simplifyCore(node.args[0], options);
 
-      var a1 = simplifyCore(node.args[1]);
+      var a1 = simplifyCore(node.args[1], options);
 
       if (node.op === '+') {
         if (isConstantNode(_a)) {
@@ -102,7 +139,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
 
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
-            return simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]));
+            return simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
           }
 
           return new OperatorNode(node.op, node.fn, [_a, a1]);
@@ -123,7 +160,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
-          } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === node.op) {
+          } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === node.op && isCommutative(node, context)) {
             var a00 = _a.args[0];
 
             if (isConstantNode(a00)) {
@@ -132,7 +169,11 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             }
           }
 
-          return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
+          if (isCommutative(node, context)) {
+            return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
+          } else {
+            return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
+          }
         }
 
         return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
@@ -165,22 +206,25 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             }
           }
         }
-
-        return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-    } else if (isParenthesisNode(node)) {
-      var c = simplifyCore(node.content);
 
-      if (isParenthesisNode(c) || isSymbolNode(c) || isConstantNode(c)) {
-        return c;
+      return new OperatorNode(node.op, node.fn, [_a, a1]);
+    } else if (isFunctionNode(node)) {
+      return new FunctionNode(simplifyCore(node.fn), node.args.map(n => simplifyCore(n, options)));
+    } else if (isArrayNode(node)) {
+      return new ArrayNode(node.items.map(n => simplifyCore(n, options)));
+    } else if (isAccessorNode(node)) {
+      return new AccessorNode(simplifyCore(node.object, options), simplifyCore(node.index, options));
+    } else if (isIndexNode(node)) {
+      return new IndexNode(node.dimensions.map(n => simplifyCore(n, options)));
+    } else if (isObjectNode(node)) {
+      var newProps = {};
+
+      for (var prop in node.properties) {
+        newProps[prop] = simplifyCore(node.properties[prop], options);
       }
 
-      return new ParenthesisNode(c);
-    } else if (isFunctionNode(node)) {
-      var args = node.args.map(simplifyCore).map(function (arg) {
-        return isParenthesisNode(arg) ? arg.content : arg;
-      });
-      return new FunctionNode(simplifyCore(node.fn), args);
+      return new ObjectNode(newProps);
     } else {// cannot simplify
     }
 

package/lib/esm/function/algebra/solver/utils/solveValidation.js

@@ -45,7 +45,7 @@ export function createSolveValidation(_ref) {
         }
 
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1],
           datatype: b._datatype
         });
@@ -66,7 +66,7 @@ export function createSolveValidation(_ref) {
             }
 
             return new DenseMatrix({
-              data: data,
+              data,
               size: [rows, 1],
               datatype: b._datatype
             });
@@ -90,7 +90,7 @@ export function createSolveValidation(_ref) {
           }
 
           return new DenseMatrix({
-            data: data,
+            data,
             size: [rows, 1],
             datatype: b._datatype
           });
@@ -113,7 +113,7 @@ export function createSolveValidation(_ref) {
         }
 
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }
@@ -128,7 +128,7 @@ export function createSolveValidation(_ref) {
         }
 
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }

package/lib/esm/function/algebra/sparse/csChol.js

@@ -161,8 +161,8 @@ export var createCsChol = /* #__PURE__ */factory(name, dependencies, _ref => {
 
 
     return {
-      L: L,
-      P: P
+      L,
+      P
     };
   };
 });

package/lib/esm/function/algebra/sparse/csLeaf.js

@@ -50,7 +50,7 @@ export function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
   }
 
   return {
-    jleaf: jleaf,
-    q: q
+    jleaf,
+    q
   };
 }

package/lib/esm/function/algebra/sparse/csLu.js

@@ -190,9 +190,9 @@ export var createCsLu = /* #__PURE__ */factory(name, dependencies, _ref => {
     uindex.splice(unz, uindex.length - unz); // return LU factor
 
     return {
-      L: L,
-      U: U,
-      pinv: pinv
+      L,
+      U,
+      pinv
     };
   };
 });

package/lib/esm/function/algebra/symbolicEqual.js

@@ -0,0 +1,80 @@
+import { isConstantNode } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'symbolicEqual';
+var dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
+export var createSymbolicEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    parse,
+    simplify,
+    typed,
+    OperatorNode
+  } = _ref;
+
+  /**
+   * Attempts to determine if two expressions are symbolically equal, i.e.
+   * one is the result of valid algebraic manipulations on the other.
+   * Currently, this simply checks if the difference of the two expressions
+   * simplifies down to 0. So there are two important caveats:
+   * 1. whether two expressions are symbolically equal depends on the
+   *     manipulations allowed. Therefore, this function takes an optional
+   *     third argument, which are the options that control the behavior
+   *     as documented for the `simplify()` function.
+   * 2. it is in general intractable to find the minimal simplification of
+   *     an arbitrarily complicated expression. So while a `true` value
+   *     of `symbolicEqual` ensures that the two expressions can be manipulated
+   *     to match each other, a `false` value does not absolutely rule this out.
+   *
+   * Syntax:
+   *
+   *    symbolicEqual(expr1, expr2)
+   *    symbolicEqual(expr1, expr2, options)
+   *
+   * Examples:
+   *
+   *    symbolicEqual('x*y', 'y*x') // true
+   *    symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}})
+   *        //false
+   *    symbolicEqual('x/y', '(y*x^(-1))^(-1)') // true
+   *    symbolicEqual('abs(x)','x') // false
+   *    symbolicEqual('abs(x)','x', simplify.positiveContext) // true
+   *
+   * See also:
+   *
+   *    simplify, evaluate
+   *
+   * @param {Node|string} expr1  The first expression to compare
+   * @param {Node|string} expr2  The second expression to compare
+   * @param {Object} [options] Optional option object, passed to simplify
+   * @returns {boolean}
+   *     Returns true if a valid manipulation making the expressions equal
+   *     is found.
+   */
+  return typed(name, {
+    'string, string': function stringString(s1, s2) {
+      return this(parse(s1), parse(s2), {});
+    },
+    'string, string, Object': function stringStringObject(s1, s2, options) {
+      return this(parse(s1), parse(s2), options);
+    },
+    'Node, string': function NodeString(e1, s2) {
+      return this(e1, parse(s2), {});
+    },
+    'Node, string, Object': function NodeStringObject(e1, s2, options) {
+      return this(e1, parse(s2), options);
+    },
+    'string, Node': function stringNode(s1, e2) {
+      return this(parse(s1), e2, {});
+    },
+    'string, Node, Object': function stringNodeObject(s1, e2, options) {
+      return this(parse(s1), e2, options);
+    },
+    'Node, Node': function NodeNode(e1, e2) {
+      return this(e1, e2, {});
+    },
+    'Node, Node, Object': function NodeNodeObject(e1, e2, options) {
+      var diff = new OperatorNode('-', 'subtract', [e1, e2]);
+      var simplified = simplify(diff, {}, options);
+      return isConstantNode(simplified) && !simplified.value;
+    }
+  });
+});

package/lib/esm/function/arithmetic/ceil.js

@@ -3,26 +3,63 @@ import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
 import { nearlyEqual } from '../../utils/number.js';
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
-import { ceilNumber } from '../../plain/number/index.js';
 import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
+import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
 import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
 var name = 'ceil';
-var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
-export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
+  var {
+    typed,
+    config,
+    round
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      if (nearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.ceil(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var [number, exponent] = "".concat(x, "e").split('e');
+        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        [number, exponent] = "".concat(result, "e").split('e');
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
   var {
     typed,
     config,
     round,
     matrix,
-    equalScalar
-  } = _ref;
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
   var algorithm11 = createAlgorithm11({
     typed,
     equalScalar
   });
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
   var algorithm14 = createAlgorithm14({
     typed
   });
+  var ceilNumber = createCeilNumber({
+    typed,
+    config,
+    round
+  });
   /**
    * Round a value towards plus infinity
    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
@@ -62,29 +99,17 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed('ceil', {
-    number: function number(x) {
-      if (nearlyEqual(x, round(x), config.epsilon)) {
-        return round(x);
-      } else {
-        return ceilNumber(x);
-      }
-    },
-    'number, number': function numberNumber(x, n) {
-      if (nearlyEqual(x, round(x, n), config.epsilon)) {
-        return round(x, n);
-      } else {
-        var [number, exponent] = "".concat(x, "e").split('e');
-        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        [number, exponent] = "".concat(result, "e").split('e');
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
-      }
-    },
+    number: ceilNumber.signatures.number,
+    'number,number': ceilNumber.signatures['number,number'],
     Complex: function Complex(x) {
       return x.ceil();
     },
     'Complex, number': function ComplexNumber(x, n) {
       return x.ceil(n);
     },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
     BigNumber: function BigNumber(x) {
       if (bigNearlyEqual(x, round(x), config.epsilon)) {
         return round(x);
@@ -105,11 +130,14 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Fraction, number': function FractionNumber(x, n) {
       return x.ceil(n);
     },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since ceil(0) = 0
       return deepMap(x, this, true);
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
       // deep map collection, skip zeros since ceil(0) = 0
       return deepMap(x, i => this(i, n), true);
     },
@@ -119,9 +147,18 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
     'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
       return algorithm14(x, y, this, false);
     },
-    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
+    },
+    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+
+      if (y.storage() === 'dense') {
+        return algorithm14(y, x, this, true);
+      }
+
+      return algorithm12(y, x, this, true);
     }
   });
 });

package/lib/esm/function/arithmetic/fix.js

@@ -1,19 +1,47 @@
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
+import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
 import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
 var name = 'fix';
-var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor'];
-export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
+var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createFixNumber = /* #__PURE__ */factory(name, ['typed', 'ceil', 'floor'], _ref => {
   var {
     typed,
-    Complex: _Complex,
-    matrix,
     ceil,
     floor
   } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      return x > 0 ? floor(x) : ceil(x);
+    },
+    'number, number': function numberNumber(x, n) {
+      return x > 0 ? floor(x, n) : ceil(x, n);
+    }
+  });
+});
+export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
+  var {
+    typed,
+    Complex: _Complex,
+    matrix,
+    ceil,
+    floor,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
   var algorithm14 = createAlgorithm14({
     typed
   });
+  var fixNumber = createFixNumber({
+    typed,
+    ceil,
+    floor
+  });
   /**
    * Round a value towards zero.
    * For matrices, the function is evaluated element wise.
@@ -21,6 +49,7 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Syntax:
    *
    *    math.fix(x)
+   *    math.fix(x,n)
    *
    * Examples:
    *
@@ -51,16 +80,16 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed('fix', {
-    number: function number(x) {
-      return x > 0 ? floor(x) : ceil(x);
-    },
-    'number, number | BigNumber': function numberNumberBigNumber(x, n) {
-      return x > 0 ? floor(x, n) : ceil(x, n);
-    },
+    number: fixNumber.signatures.number,
+    'number, number | BigNumber': fixNumber.signatures['number,number'],
     Complex: function Complex(x) {
       return new _Complex(x.re > 0 ? Math.floor(x.re) : Math.ceil(x.re), x.im > 0 ? Math.floor(x.im) : Math.ceil(x.im));
     },
-    'Complex, number | BigNumber': function ComplexNumberBigNumber(x, n) {
+    'Complex, number': function ComplexNumber(x, n) {
+      return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, bn) {
+      var n = bn.toNumber();
       return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
     },
     BigNumber: function BigNumber(x) {
@@ -73,7 +102,7 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x.s < 0 ? x.ceil() : x.floor();
     },
     'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
-      return x.s < 0 ? x.ceil(n) : x.floor(n);
+      return x.s < 0 ? ceil(x, n) : floor(x, n);
     },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since fix(0) = 0
@@ -83,9 +112,18 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
       // deep map collection, skip zeros since fix(0) = 0
       return deepMap(x, i => this(i, n), true);
     },
-    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
+    },
+    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+
+      if (y.storage() === 'dense') {
+        return algorithm14(y, x, this, true);
+      }
+
+      return algorithm12(y, x, this, true);
     }
   });
 });