mathjs 11.12.0 → 12.1.0

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

@@ -1,18 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createEigs = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _factory = require("../../utils/factory.js");
 var _string = require("../../utils/string.js");
 var _complexEigs = require("./eigs/complexEigs.js");
-var _realSymetric = require("./eigs/realSymetric.js");
+var _realSymmetric = require("./eigs/realSymmetric.js");
 var _is = require("../../utils/is.js");
 var name = 'eigs';
 
 // The absolute state of math.js's dependency system:
-var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'qr', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
+var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'size', 'reshape', 'qr', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
 var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var config = _ref.config,
     typed = _ref.typed,
@@ -37,6 +39,8 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     complex = _ref.complex,
     sqrt = _ref.sqrt,
     diag = _ref.diag,
+    size = _ref.size,
+    reshape = _ref.reshape,
     qr = _ref.qr,
     usolve = _ref.usolve,
     usolveAll = _ref.usolveAll,
@@ -45,7 +49,7 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     smaller = _ref.smaller,
     matrixFromColumns = _ref.matrixFromColumns,
     dot = _ref.dot;
-  var doRealSymetric = (0, _realSymetric.createRealSymmetric)({
+  var doRealSymmetric = (0, _realSymmetric.createRealSymmetric)({
     config: config,
     addScalar: addScalar,
     subtract: subtract,
@@ -75,6 +79,8 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     abs: abs,
     bignumber: bignumber,
     diag: diag,
+    size: size,
+    reshape: reshape,
     qr: qr,
     inv: inv,
     usolve: usolve,
@@ -88,26 +94,54 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
   });
 
   /**
-   * Compute eigenvalues and eigenvectors of a matrix. The eigenvalues are sorted by their absolute value, ascending.
-   * An eigenvalue with multiplicity k will be listed k times. The eigenvectors are returned as columns of a matrix –
-   * the eigenvector that belongs to the j-th eigenvalue in the list (eg. `values[j]`) is the j-th column (eg. `column(vectors, j)`).
-   * If the algorithm fails to converge, it will throw an error – in that case, however, you may still find useful information
+   * Compute eigenvalues and optionally eigenvectors of a square matrix.
+   * The eigenvalues are sorted by their absolute value, ascending, and
+   * returned as a vector in the `values` property of the returned project.
+   * An eigenvalue with algebraic multiplicity k will be listed k times, so
+   * that the returned `values` vector always has length equal to the size
+   * of the input matrix.
+   *
+   * The `eigenvectors` property of the return value provides the eigenvectors.
+   * It is an array of plain objects: the `value` property of each gives the
+   * associated eigenvalue, and the `vector` property gives the eigenvector
+   * itself. Note that the same `value` property will occur as many times in
+   * the list provided by `eigenvectors` as the geometric multiplicity of
+   * that value.
+   *
+   * If the algorithm fails to converge, it will throw an error –
+   * in that case, however, you may still find useful information
    * in `err.values` and `err.vectors`.
    *
+   * Note that the 'precision' option does not directly specify the _accuracy_
+   * of the returned eigenvalues. Rather, it determines how small an entry
+   * of the iterative approximations to an upper triangular matrix must be
+   * in order to be considered zero. The actual accuracy of the returned
+   * eigenvalues may be greater or less than the precision, depending on the
+   * conditioning of the matrix and how far apart or close the actual
+   * eigenvalues are. Note that currently, relatively simple, "traditional"
+   * methods of eigenvalue computation are being used; this is not a modern,
+   * high-precision eigenvalue computation. That said, it should typically
+   * produce fairly reasonable results.
+   *
    * Syntax:
    *
    *     math.eigs(x, [prec])
+   *     math.eigs(x, {options})
    *
    * Examples:
    *
-   *     const { eigs, multiply, column, transpose } = math
+   *     const { eigs, multiply, column, transpose, matrixFromColumns } = math
    *     const H = [[5, 2.3], [2.3, 1]]
-   *     const ans = eigs(H) // returns {values: [E1,E2...sorted], vectors: [v1,v2.... corresponding vectors as columns]}
+   *     const ans = eigs(H) // returns {values: [E1,E2...sorted], eigenvectors: [{value: E1, vector: v2}, {value: e, vector: v2}, ...]
    *     const E = ans.values
-   *     const U = ans.vectors
-   *     multiply(H, column(U, 0)) // returns multiply(E[0], column(U, 0))
-   *     const UTxHxU = multiply(transpose(U), H, U) // diagonalizes H
-   *     E[0] == UTxHxU[0][0]  // returns true
+   *     const V = ans.eigenvectors
+   *     multiply(H, V[0].vector)) // returns multiply(E[0], V[0].vector))
+   *     const U = matrixFromColumns(...V.map(obj => obj.vector))
+   *     const UTxHxU = multiply(transpose(U), H, U) // diagonalizes H if possible
+   *     E[0] == UTxHxU[0][0]  // returns true always
+   *
+   *     // Compute only approximate eigenvalues:
+   *     const {values} = eigs(H, {eigenvectors: false, precision: 1e-6})
    *
    * See also:
    *
@@ -115,57 +149,96 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
    *
    * @param {Array | Matrix} x  Matrix to be diagonalized
    *
-   * @param {number | BigNumber} [prec] Precision, default value: 1e-15
-   * @return {{values: Array|Matrix, vectors: Array|Matrix}} Object containing an array of eigenvalues and a matrix with eigenvectors as columns.
+   * @param {number | BigNumber | OptsObject} [opts] Object with keys `precision`, defaulting to config.epsilon, and `eigenvectors`, defaulting to true and specifying whether to compute eigenvectors. If just a number, specifies precision.
+   * @return {{values: Array|Matrix, eigenvectors?: Array<EVobj>}} Object containing an array of eigenvalues and an array of {value: number|BigNumber, vector: Array|Matrix} objects. The eigenvectors property is undefined if eigenvectors were not requested.
    *
    */
   return typed('eigs', {
+    // The conversion to matrix in the first two implementations,
+    // just to convert back to an array right away in
+    // computeValuesAndVectors, is unfortunate, and should perhaps be
+    // streamlined. It is done because the Matrix object carries some
+    // type information about its entries, and so constructing the matrix
+    // is a roundabout way of doing type detection.
     Array: function Array(x) {
-      var mat = matrix(x);
-      return computeValuesAndVectors(mat);
+      return doEigs(matrix(x));
     },
     'Array, number|BigNumber': function ArrayNumberBigNumber(x, prec) {
-      var mat = matrix(x);
-      return computeValuesAndVectors(mat, prec);
+      return doEigs(matrix(x), {
+        precision: prec
+      });
+    },
+    'Array, Object': function ArrayObject(x, opts) {
+      return doEigs(matrix(x), opts);
     },
     Matrix: function Matrix(mat) {
-      var _computeValuesAndVect = computeValuesAndVectors(mat),
-        values = _computeValuesAndVect.values,
-        vectors = _computeValuesAndVect.vectors;
-      return {
-        values: matrix(values),
-        vectors: matrix(vectors)
-      };
+      return doEigs(mat, {
+        matricize: true
+      });
     },
     'Matrix, number|BigNumber': function MatrixNumberBigNumber(mat, prec) {
-      var _computeValuesAndVect2 = computeValuesAndVectors(mat, prec),
-        values = _computeValuesAndVect2.values,
-        vectors = _computeValuesAndVect2.vectors;
-      return {
-        values: matrix(values),
-        vectors: matrix(vectors)
+      return doEigs(mat, {
+        precision: prec,
+        matricize: true
+      });
+    },
+    'Matrix, Object': function MatrixObject(mat, opts) {
+      var useOpts = {
+        matricize: true
       };
+      (0, _extends2["default"])(useOpts, opts);
+      return doEigs(mat, useOpts);
     }
   });
-  function computeValuesAndVectors(mat, prec) {
-    if (prec === undefined) {
-      prec = config.epsilon;
+  function doEigs(mat) {
+    var _opts$precision;
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var computeVectors = 'eigenvectors' in opts ? opts.eigenvectors : true;
+    var prec = (_opts$precision = opts.precision) !== null && _opts$precision !== void 0 ? _opts$precision : config.epsilon;
+    var result = computeValuesAndVectors(mat, prec, computeVectors);
+    if (opts.matricize) {
+      result.values = matrix(result.values);
+      if (computeVectors) {
+        result.eigenvectors = result.eigenvectors.map(function (_ref2) {
+          var value = _ref2.value,
+            vector = _ref2.vector;
+          return {
+            value: value,
+            vector: matrix(vector)
+          };
+        });
+      }
+    }
+    if (computeVectors) {
+      Object.defineProperty(result, 'vectors', {
+        enumerable: false,
+        // to make sure that the eigenvectors can still be
+        // converted to string.
+        get: function get() {
+          throw new Error('eigs(M).vectors replaced with eigs(M).eigenvectors');
+        }
+      });
     }
-    var size = mat.size();
-    if (size.length !== 2 || size[0] !== size[1]) {
-      throw new RangeError('Matrix must be square (size: ' + (0, _string.format)(size) + ')');
+    return result;
+  }
+  function computeValuesAndVectors(mat, prec, computeVectors) {
+    var arr = mat.toArray(); // NOTE: arr is guaranteed to be unaliased
+    // and so safe to modify in place
+    var asize = mat.size();
+    if (asize.length !== 2 || asize[0] !== asize[1]) {
+      throw new RangeError("Matrix must be square (size: ".concat((0, _string.format)(asize), ")"));
     }
-    var arr = mat.toArray();
-    var N = size[0];
+    var N = asize[0];
     if (isReal(arr, N, prec)) {
-      coerceReal(arr, N);
+      coerceReal(arr, N); // modifies arr by side effect
+
       if (isSymmetric(arr, N, prec)) {
-        var _type = coerceTypes(mat, arr, N);
-        return doRealSymetric(arr, N, prec, _type);
+        var _type = coerceTypes(mat, arr, N); // modifies arr by side effect
+        return doRealSymmetric(arr, N, prec, _type, computeVectors);
       }
     }
-    var type = coerceTypes(mat, arr, N);
-    return doComplexEigs(arr, N, prec, type);
+    var type = coerceTypes(mat, arr, N); // modifies arr by side effect
+    return doComplexEigs(arr, N, prec, type, computeVectors);
   }
 
   /** @return {boolean} */

package/lib/cjs/function/probability/pickRandom.js

@@ -56,8 +56,8 @@ var createPickRandom = exports.createPickRandom = /* #__PURE__ */(0, _factory.fa
    * @param {Array | Matrix} array     A one dimensional array
    * @param {Int} number               An int or float
    * @param {Array | Matrix} weights   An array of ints or floats
-   * @return {number | Array}          Returns a single random value from array when number is 1 or undefined.
-   *                                   Returns an array with the configured number of elements when number is > 1.
+   * @return {number | Array}          Returns a single random value from array when number is undefined.
+   *                                   Returns an array with the configured number of elements when number is defined.
    */
   return typed(name, {
     'Array | Matrix': function ArrayMatrix(possibles) {

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 11.12.0
- * @date    2023-10-26
+ * @version 12.1.0
+ * @date    2023-11-17
  *
  * @license
  * Copyright (C) 2013-2023 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/type/number.js

@@ -49,7 +49,7 @@ function makeNumberFromNonDecimalParts(parts) {
   }
   var result = n + f;
   if (isNaN(result)) {
-    throw new SyntaxError('String "' + parts.input + '" is no valid number');
+    throw new SyntaxError('String "' + parts.input + '" is not a valid number');
   }
   return result;
 }
@@ -103,7 +103,7 @@ var createNumber = exports.createNumber = /* #__PURE__ */(0, _factory.factory)(n
       }
       var num = Number(x);
       if (isNaN(num)) {
-        throw new SyntaxError('String "' + x + '" is no valid number');
+        throw new SyntaxError('String "' + x + '" is not a valid number');
       }
       if (wordSizeSuffixMatch) {
         // x is a signed bin, oct, or hex literal

package/lib/cjs/utils/number.js

@@ -604,7 +604,7 @@ function nearlyEqual(x, y, epsilon) {
   if (isFinite(x) && isFinite(y)) {
     // check numbers are very close, needed when comparing numbers near zero
     var diff = Math.abs(x - y);
-    if (diff < DBL_EPSILON) {
+    if (diff <= DBL_EPSILON) {
       return true;
     } else {
       // use relative error

package/lib/cjs/utils/snapshot.js

@@ -18,12 +18,12 @@ function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * This file contains helper methods to create expected snapshot structures
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * of both instance and ES6 exports.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                          *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * The files are located here and not under /test or /tools so it's transpiled
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * into ES5 code under /lib and can be used straight by node.js
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
+ * This file contains helper methods to create expected snapshot structures
+ * of both instance and ES6 exports.
+ *
+ * The files are located here and not under /test or /tools so it's transpiled
+ * into ES5 code under /lib and can be used straight by node.js
+ */
 var validateTypeOf = exports.validateTypeOf = allIsFunctions.typeOf;
 function validateBundle(expectedBundleStructure, bundle) {
   var originalWarn = console.warn;

package/lib/cjs/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = exports.version = '11.12.0';
+var version = exports.version = '12.1.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

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

@@ -25,7 +25,9 @@ import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generat
 import { numberDependencies } from './dependenciesNumber.generated.js';
 import { qrDependencies } from './dependenciesQr.generated.js';
 import { reDependencies } from './dependenciesRe.generated.js';
+import { reshapeDependencies } from './dependenciesReshape.generated.js';
 import { sinDependencies } from './dependenciesSin.generated.js';
+import { sizeDependencies } from './dependenciesSize.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
 import { sqrtDependencies } from './dependenciesSqrt.generated.js';
 import { subtractDependencies } from './dependenciesSubtract.generated.js';
@@ -57,7 +59,9 @@ export var eigsDependencies = {
   numberDependencies,
   qrDependencies,
   reDependencies,
+  reshapeDependencies,
   sinDependencies,
+  sizeDependencies,
   smallerDependencies,
   sqrtDependencies,
   subtractDependencies,

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

@@ -1582,7 +1582,9 @@ export var eigs = /* #__PURE__ */createEigs({
   number,
   qr,
   re,
+  reshape,
   sin,
+  size,
   smaller,
   sqrt,
   subtract,

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

@@ -1,8 +1,8 @@
 export var 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/esm/expression/embeddedDocs/function/matrix/eigs.js

@@ -2,7 +2,7 @@ export var 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/esm/expression/node/AssignmentNode.js

@@ -295,7 +295,7 @@ export var createAssignmentNode = /* #__PURE__ */factory(name, dependencies, _re
       if (needParenthesis(this, options && options.parenthesis, options && options.implicit)) {
         value = "\\left(".concat(value, "\\right)");
       }
-      return object + index + ':=' + value;
+      return object + index + '=' + value;
     }
   }
   _defineProperty(AssignmentNode, "name", name);

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

@@ -224,7 +224,7 @@ export var createFunctionAssignmentNode = /* #__PURE__ */factory(name, dependenc
       if (needParenthesis(this, parenthesis, options && options.implicit)) {
         expr = "\\left(".concat(expr, "\\right)");
       }
-      return '\\mathrm{' + this.name + '}\\left(' + this.params.map(toSymbol).join(',') + '\\right):=' + expr;
+      return '\\mathrm{' + this.name + '}\\left(' + this.params.map(toSymbol).join(',') + '\\right)=' + expr;
     }
   }
   _defineProperty(FunctionAssignmentNode, "name", name);

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

@@ -208,9 +208,6 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
       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);
       }
@@ -259,9 +256,12 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
           }
           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()]);
@@ -391,7 +391,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
           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) {
@@ -502,33 +502,10 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
         // 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/esm/function/arithmetic/mod.js

@@ -91,17 +91,10 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
   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/esm/function/arithmetic/round.js

@@ -36,6 +36,8 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    math.round(x)
    *    math.round(x, n)
+   *    math.round(unit, valuelessUnit)
+   *    math.round(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -53,14 +55,21 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    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, {
@@ -112,37 +121,51 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
       return x.round(n.toNumber());
     },
-    // deep map collection, skip zeros since round(0) = 0
-    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)),
-    'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
-      return matAlgo11xS0s(x, y, self, false);
+    'Unit, number, Unit': typed.referToSelf(self => function (x, n, unit) {
+      var valueless = x.toNumeric(unit);
+      return unit.multiply(self(valueless, n));
+    }),
+    'Unit, BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => self(x, n.toNumber(), unit)),
+    'Unit, Unit': typed.referToSelf(self => (x, unit) => self(x, 0, unit)),
+    'Array | Matrix, number, Unit': typed.referToSelf(self => (x, n, unit) => {
+      // deep map collection, skip zeros since round(0) = 0
+      return deepMap(x, value => self(value, n, unit), true);
+    }),
+    'Array | Matrix, BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => self(x, n.toNumber(), unit)),
+    'Array | Matrix, Unit': typed.referToSelf(self => (x, unit) => self(x, 0, unit)),
+    'Array | Matrix': typed.referToSelf(self => x => {
+      // deep map collection, skip zeros since round(0) = 0
+      return deepMap(x, self, true);
+    }),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, n) => {
+      return matAlgo11xS0s(x, n, self, false);
     }),
-    'DenseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
-      return matAlgo14xDs(x, y, self, false);
+    'DenseMatrix, number | BigNumber': typed.referToSelf(self => (x, n) => {
+      return matAlgo14xDs(x, n, self, false);
     }),
-    'Array, number | BigNumber': typed.referToSelf(self => (x, y) => {
+    'Array, number | BigNumber': typed.referToSelf(self => (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(self => (x, y) => {
+    'number | Complex | BigNumber | Fraction, SparseMatrix': typed.referToSelf(self => (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(self => (x, y) => {
+    'number | Complex | BigNumber | Fraction, DenseMatrix': typed.referToSelf(self => (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(self => (x, y) => {
+    'number | Complex | BigNumber | Fraction, Array': typed.referToSelf(self => (x, n) => {
       // use matrix implementation
-      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+      return matAlgo14xDs(matrix(n), x, self, true).valueOf();
     })
   });
 });