mathjs 11.12.0 → 12.1.0

package/lib/cjs/entry/dependenciesAny/dependenciesEigs.generated.js

@@ -27,7 +27,9 @@ var _dependenciesMultiplyScalarGenerated = require("./dependenciesMultiplyScalar
 var _dependenciesNumberGenerated = require("./dependenciesNumber.generated.js");
 var _dependenciesQrGenerated = require("./dependenciesQr.generated.js");
 var _dependenciesReGenerated = require("./dependenciesRe.generated.js");
+var _dependenciesReshapeGenerated = require("./dependenciesReshape.generated.js");
 var _dependenciesSinGenerated = require("./dependenciesSin.generated.js");
+var _dependenciesSizeGenerated = require("./dependenciesSize.generated.js");
 var _dependenciesSmallerGenerated = require("./dependenciesSmaller.generated.js");
 var _dependenciesSqrtGenerated = require("./dependenciesSqrt.generated.js");
 var _dependenciesSubtractGenerated = require("./dependenciesSubtract.generated.js");
@@ -64,7 +66,9 @@ var eigsDependencies = exports.eigsDependencies = {
   numberDependencies: _dependenciesNumberGenerated.numberDependencies,
   qrDependencies: _dependenciesQrGenerated.qrDependencies,
   reDependencies: _dependenciesReGenerated.reDependencies,
+  reshapeDependencies: _dependenciesReshapeGenerated.reshapeDependencies,
   sinDependencies: _dependenciesSinGenerated.sinDependencies,
+  sizeDependencies: _dependenciesSizeGenerated.sizeDependencies,
   smallerDependencies: _dependenciesSmallerGenerated.smallerDependencies,
   sqrtDependencies: _dependenciesSqrtGenerated.sqrtDependencies,
   subtractDependencies: _dependenciesSubtractGenerated.subtractDependencies,

package/lib/cjs/entry/pureFunctionsAny.generated.js

@@ -1590,7 +1590,9 @@ var eigs = exports.eigs = /* #__PURE__ */(0, _factoriesAny.createEigs)({
   number: number,
   qr: qr,
   re: re,
+  reshape: reshape,
   sin: sin,
+  size: size,
   smaller: smaller,
   sqrt: sqrt,
   subtract: subtract,

package/lib/cjs/expression/embeddedDocs/function/arithmetic/round.js

@@ -7,8 +7,8 @@ exports.roundDocs = void 0;
 var roundDocs = exports.roundDocs = {
   name: 'round',
   category: 'Arithmetic',
-  syntax: ['round(x)', 'round(x, n)'],
+  syntax: ['round(x)', 'round(x, n)', 'round(unit, valuelessUnit)', 'round(unit, n, valuelessUnit)'],
   description: 'round a value towards the nearest integer.If x is complex, both real and imaginary part are rounded towards the nearest integer. When n is specified, the value is rounded to n decimals.',
-  examples: ['round(3.2)', 'round(3.8)', 'round(-4.2)', 'round(-4.8)', 'round(pi, 3)', 'round(123.45678, 2)'],
+  examples: ['round(3.2)', 'round(3.8)', 'round(-4.2)', 'round(-4.8)', 'round(pi, 3)', 'round(123.45678, 2)', 'round(3.241cm, 2, cm)', 'round([3.2, 3.8, -4.7])'],
   seealso: ['ceil', 'floor', 'fix']
 };

package/lib/cjs/expression/embeddedDocs/function/matrix/eigs.js

@@ -8,7 +8,7 @@ var eigsDocs = exports.eigsDocs = {
   name: 'eigs',
   category: 'Matrix',
   syntax: ['eigs(x)'],
-  description: 'Calculate the eigenvalues and eigenvectors of a real symmetric matrix',
-  examples: ['eigs([[5, 2.3], [2.3, 1]])'],
+  description: 'Calculate the eigenvalues and optionally eigenvectors of a square matrix',
+  examples: ['eigs([[5, 2.3], [2.3, 1]])', 'eigs([[1, 2, 3], [4, 5, 6], [7, 8, 9]], { precision: 1e-6, eigenvectors: false }'],
   seealso: ['inv']
 };

package/lib/cjs/expression/node/AssignmentNode.js

@@ -331,7 +331,7 @@ var createAssignmentNode = exports.createAssignmentNode = /* #__PURE__ */(0, _fa
         if (needParenthesis(this, options && options.parenthesis, options && options.implicit)) {
           value = "\\left(".concat(value, "\\right)");
         }
-        return object + index + ':=' + value;
+        return object + index + '=' + value;
       }
     }], [{
       key: "fromJSON",

package/lib/cjs/expression/node/FunctionAssignmentNode.js

@@ -270,7 +270,7 @@ var createFunctionAssignmentNode = exports.createFunctionAssignmentNode = /* #__
         if (needParenthesis(this, parenthesis, options && options.implicit)) {
           expr = "\\left(".concat(expr, "\\right)");
         }
-        return '\\mathrm{' + this.name + '}\\left(' + this.params.map(_latex.toSymbol).join(',') + '\\right):=' + expr;
+        return '\\mathrm{' + this.name + '}\\left(' + this.params.map(_latex.toSymbol).join(',') + '\\right)=' + expr;
       }
     }], [{
       key: "fromJSON",

package/lib/cjs/function/algebra/derivative.js

@@ -212,9 +212,6 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
       return _derivative(node.expr, constNodes);
     },
     'FunctionNode, Object': function FunctionNodeObject(node, constNodes) {
-      if (node.args.length !== 1) {
-        funcArgsCheck(node);
-      }
       if (constNodes[node] !== undefined) {
         return createConstantNode(0);
       }
@@ -263,9 +260,12 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
           }
           break;
         case 'pow':
-          constNodes[arg1] = constNodes[node.args[1]];
-          // Pass to pow operator node parser
-          return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]), constNodes);
+          if (node.args.length === 2) {
+            constNodes[arg1] = constNodes[node.args[1]];
+            // Pass to pow operator node parser
+            return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]), constNodes);
+          }
+          break;
         case 'exp':
           // d/dx(e^x) = e^x
           funcDerivative = new FunctionNode('exp', [arg0.clone()]);
@@ -395,7 +395,7 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
           break;
         case 'gamma': // Needs digamma function, d/dx(gamma(x)) = gamma(x)digamma(x)
         default:
-          throw new Error('Function "' + node.name + '" is not supported by derivative, or a wrong number of arguments is passed');
+          throw new Error('Cannot process function "' + node.name + '" in derivative: ' + 'the function is not supported, undefined, or the number of arguments passed to it are not supported');
       }
       var op, func;
       if (div) {
@@ -506,33 +506,10 @@ var createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.fa
         // Functional Power Rule, d/dx(f^g) = f^g*[f'*(g/f) + g'ln(f)]
         return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [_arg.clone(), _arg2.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(_arg, constNodes), new OperatorNode('/', 'divide', [_arg2.clone(), _arg.clone()])]), new OperatorNode('*', 'multiply', [_derivative(_arg2, constNodes), new FunctionNode('log', [_arg.clone()])])])]);
       }
-      throw new Error('Operator "' + node.op + '" is not supported by derivative, or a wrong number of arguments is passed');
+      throw new Error('Cannot process operator "' + node.op + '" in derivative: ' + 'the operator is not supported, undefined, or the number of arguments passed to it are not supported');
     }
   });
 
-  /**
-   * Ensures the number of arguments for a function are correct,
-   * and will throw an error otherwise.
-   *
-   * @param {FunctionNode} node
-   */
-  function funcArgsCheck(node) {
-    // TODO add min, max etc
-    if ((node.name === 'log' || node.name === 'nthRoot' || node.name === 'pow') && node.args.length === 2) {
-      return;
-    }
-
-    // There should be an incorrect number of arguments if we reach here
-
-    // Change all args to constants to avoid unidentified
-    // symbol error when compiling function
-    for (var i = 0; i < node.args.length; ++i) {
-      node.args[i] = createConstantNode(0);
-    }
-    node.compile().evaluate();
-    throw new Error('Function "' + node.name + '" is not supported by derivative, or a wrong number of arguments is passed');
-  }
-
   /**
    * Helper function to create a constant node with a specific type
    * (number, BigNumber, Fraction)

package/lib/cjs/function/arithmetic/gcd.js

@@ -25,7 +25,6 @@ function is1d(array) {
   });
 }
 var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var _typed;
   var typed = _ref.typed,
     matrix = _ref.matrix,
     config = _ref.config,
@@ -97,7 +96,7 @@ var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, d
     SS: matAlgo04xSidSid,
     DS: matAlgo01xDSid,
     Ss: matAlgo10xSids
-  }), (_typed = {}, (0, _defineProperty2["default"])(_typed, gcdManyTypesSignature, typed.referToSelf(function (self) {
+  }), (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, gcdManyTypesSignature, typed.referToSelf(function (self) {
     return function (a, b, args) {
       var res = self(a, b);
       for (var i = 0; i < args.length; i++) {
@@ -105,7 +104,7 @@ var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, d
       }
       return res;
     };
-  })), (0, _defineProperty2["default"])(_typed, "Array", typed.referToSelf(function (self) {
+  })), "Array", typed.referToSelf(function (self) {
     return function (array) {
       if (array.length === 1 && Array.isArray(array[0]) && is1d(array[0])) {
         return self.apply(void 0, (0, _toConsumableArray2["default"])(array[0]));
@@ -115,11 +114,11 @@ var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, d
       }
       throw new _ArgumentsError.ArgumentsError('gcd() supports only 1d matrices!');
     };
-  })), (0, _defineProperty2["default"])(_typed, "Matrix", typed.referToSelf(function (self) {
+  })), "Matrix", typed.referToSelf(function (self) {
     return function (matrix) {
       return self(matrix.toArray());
     };
-  })), _typed));
+  })));
 
   /**
   * Calculate gcd for numbers

package/lib/cjs/function/arithmetic/mod.js

@@ -95,17 +95,10 @@ var createMod = exports.createMod = /* #__PURE__ */(0, _factory.factory)(name, d
   return typed(name, {
     'number, number': _modNumber,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      if (y.isNeg()) {
-        throw new Error('Cannot calculate mod for a negative divisor');
-      }
-      return y.isZero() ? x : x.mod(y);
+      return y.isZero() ? x : x.sub(y.mul(floor(x.div(y))));
     },
     'Fraction, Fraction': function FractionFraction(x, y) {
-      if (y.compare(0) < 0) {
-        throw new Error('Cannot calculate mod for a negative divisor');
-      }
-      // Workaround suggested in Fraction.js library to calculate correct modulo for negative dividend
-      return x.compare(0) >= 0 ? x.mod(y) : x.mod(y).add(y).mod(y);
+      return y.equals(0) ? x : x.sub(y.mul(floor(x.div(y))));
     }
   }, matrixAlgorithmSuite({
     SS: matAlgo05xSfSf,

package/lib/cjs/function/arithmetic/round.js

@@ -40,6 +40,8 @@ var createRound = exports.createRound = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    math.round(x)
    *    math.round(x, n)
+   *    math.round(unit, valuelessUnit)
+   *    math.round(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -57,14 +59,21 @@ var createRound = exports.createRound = /* #__PURE__ */(0, _factory.factory)(nam
    *    const c = math.complex(3.2, -2.7)
    *    math.round(c)                // returns Complex 3 - 3i
    *
+   *    const unit = math.unit('3.241 cm')
+   *    const cm = math.unit('cm')
+   *    const mm = math.unit('mm')
+   *    math.round(unit, 1, cm)      // returns Unit 3.2 cm
+   *    math.round(unit, 1, mm)      // returns Unit 32.4 mm
+   *
    *    math.round([3.2, 3.8, -4.7]) // returns Array [3, 4, -5]
    *
    * See also:
    *
    *    ceil, fix, floor
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
+   * @param  {Unit} [valuelessUnit]                                        A valueless unit
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
   return typed(name, {
@@ -116,52 +125,86 @@ var createRound = exports.createRound = /* #__PURE__ */(0, _factory.factory)(nam
       }
       return x.round(n.toNumber());
     },
-    // deep map collection, skip zeros since round(0) = 0
+    'Unit, number, Unit': typed.referToSelf(function (self) {
+      return function (x, n, unit) {
+        var valueless = x.toNumeric(unit);
+        return unit.multiply(self(valueless, n));
+      };
+    }),
+    'Unit, BigNumber, Unit': typed.referToSelf(function (self) {
+      return function (x, n, unit) {
+        return self(x, n.toNumber(), unit);
+      };
+    }),
+    'Unit, Unit': typed.referToSelf(function (self) {
+      return function (x, unit) {
+        return self(x, 0, unit);
+      };
+    }),
+    'Array | Matrix, number, Unit': typed.referToSelf(function (self) {
+      return function (x, n, unit) {
+        // deep map collection, skip zeros since round(0) = 0
+        return (0, _collection.deepMap)(x, function (value) {
+          return self(value, n, unit);
+        }, true);
+      };
+    }),
+    'Array | Matrix, BigNumber, Unit': typed.referToSelf(function (self) {
+      return function (x, n, unit) {
+        return self(x, n.toNumber(), unit);
+      };
+    }),
+    'Array | Matrix, Unit': typed.referToSelf(function (self) {
+      return function (x, unit) {
+        return self(x, 0, unit);
+      };
+    }),
     'Array | Matrix': typed.referToSelf(function (self) {
       return function (x) {
+        // deep map collection, skip zeros since round(0) = 0
         return (0, _collection.deepMap)(x, self, true);
       };
     }),
     'SparseMatrix, number | BigNumber': typed.referToSelf(function (self) {
-      return function (x, y) {
-        return matAlgo11xS0s(x, y, self, false);
+      return function (x, n) {
+        return matAlgo11xS0s(x, n, self, false);
       };
     }),
     'DenseMatrix, number | BigNumber': typed.referToSelf(function (self) {
-      return function (x, y) {
-        return matAlgo14xDs(x, y, self, false);
+      return function (x, n) {
+        return matAlgo14xDs(x, n, self, false);
       };
     }),
     'Array, number | BigNumber': typed.referToSelf(function (self) {
-      return function (x, y) {
+      return function (x, n) {
         // use matrix implementation
-        return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+        return matAlgo14xDs(matrix(x), n, self, false).valueOf();
       };
     }),
     'number | Complex | BigNumber | Fraction, SparseMatrix': typed.referToSelf(function (self) {
-      return function (x, y) {
+      return function (x, n) {
         // check scalar is zero
         if (equalScalar(x, 0)) {
           // do not execute algorithm, result will be a zero matrix
-          return zeros(y.size(), y.storage());
+          return zeros(n.size(), n.storage());
         }
-        return matAlgo12xSfs(y, x, self, true);
+        return matAlgo12xSfs(n, x, self, true);
       };
     }),
     'number | Complex | BigNumber | Fraction, DenseMatrix': typed.referToSelf(function (self) {
-      return function (x, y) {
+      return function (x, n) {
         // check scalar is zero
         if (equalScalar(x, 0)) {
           // do not execute algorithm, result will be a zero matrix
-          return zeros(y.size(), y.storage());
+          return zeros(n.size(), n.storage());
         }
-        return matAlgo14xDs(y, x, self, true);
+        return matAlgo14xDs(n, x, self, true);
       };
     }),
     'number | Complex | BigNumber | Fraction, Array': typed.referToSelf(function (self) {
-      return function (x, y) {
+      return function (x, n) {
         // use matrix implementation
-        return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+        return matAlgo14xDs(matrix(n), x, self, true).valueOf();
       };
     })
   });