mathjs 11.11.2 → 12.0.0

package/lib/cjs/function/matrix/eigs/{realSymetric.js → realSymmetric.js}

@@ -27,25 +27,29 @@ function createRealSymmetric(_ref) {
   function main(arr, N) {
     var prec = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : config.epsilon;
     var type = arguments.length > 3 ? arguments[3] : undefined;
+    var computeVectors = arguments.length > 4 ? arguments[4] : undefined;
     if (type === 'number') {
-      return diag(arr, prec);
+      return diag(arr, prec, computeVectors);
     }
     if (type === 'BigNumber') {
-      return diagBig(arr, prec);
+      return diagBig(arr, prec, computeVectors);
     }
     throw TypeError('Unsupported data type: ' + type);
   }
 
   // diagonalization implementation for number (efficient)
-  function diag(x, precision) {
+  function diag(x, precision, computeVectors) {
     var N = x.length;
     var e0 = Math.abs(precision / N);
     var psi;
-    var Sij = new Array(N);
-    // Sij is Identity Matrix
-    for (var i = 0; i < N; i++) {
-      Sij[i] = createArray(N, 0);
-      Sij[i][i] = 1.0;
+    var Sij;
+    if (computeVectors) {
+      Sij = new Array(N);
+      // Sij is Identity Matrix
+      for (var i = 0; i < N; i++) {
+        Sij[i] = Array(N).fill(0);
+        Sij[i][i] = 1.0;
+      }
     }
     // initial error
     var Vab = getAij(x);
@@ -54,26 +58,29 @@ function createRealSymmetric(_ref) {
       var j = Vab[0][1];
       psi = getTheta(x[_i][_i], x[j][j], x[_i][j]);
       x = x1(x, psi, _i, j);
-      Sij = Sij1(Sij, psi, _i, j);
+      if (computeVectors) Sij = Sij1(Sij, psi, _i, j);
       Vab = getAij(x);
     }
-    var Ei = createArray(N, 0); // eigenvalues
+    var Ei = Array(N).fill(0); // eigenvalues
     for (var _i2 = 0; _i2 < N; _i2++) {
       Ei[_i2] = x[_i2][_i2];
     }
-    return sorting((0, _object.clone)(Ei), (0, _object.clone)(Sij));
+    return sorting((0, _object.clone)(Ei), Sij, computeVectors);
   }
 
   // diagonalization implementation for bigNumber
-  function diagBig(x, precision) {
+  function diagBig(x, precision, computeVectors) {
     var N = x.length;
     var e0 = abs(precision / N);
     var psi;
-    var Sij = new Array(N);
-    // Sij is Identity Matrix
-    for (var i = 0; i < N; i++) {
-      Sij[i] = createArray(N, 0);
-      Sij[i][i] = 1.0;
+    var Sij;
+    if (computeVectors) {
+      Sij = new Array(N);
+      // Sij is Identity Matrix
+      for (var i = 0; i < N; i++) {
+        Sij[i] = Array(N).fill(0);
+        Sij[i][i] = 1.0;
+      }
     }
     // initial error
     var Vab = getAijBig(x);
@@ -82,15 +89,15 @@ function createRealSymmetric(_ref) {
       var j = Vab[0][1];
       psi = getThetaBig(x[_i3][_i3], x[j][j], x[_i3][j]);
       x = x1Big(x, psi, _i3, j);
-      Sij = Sij1Big(Sij, psi, _i3, j);
+      if (computeVectors) Sij = Sij1Big(Sij, psi, _i3, j);
       Vab = getAijBig(x);
     }
-    var Ei = createArray(N, 0); // eigenvalues
+    var Ei = Array(N).fill(0); // eigenvalues
     for (var _i4 = 0; _i4 < N; _i4++) {
       Ei[_i4] = x[_i4][_i4];
     }
     // return [clone(Ei), clone(Sij)]
-    return sorting((0, _object.clone)(Ei), (0, _object.clone)(Sij));
+    return sorting((0, _object.clone)(Ei), Sij, computeVectors);
   }
 
   // get angle
@@ -118,8 +125,8 @@ function createRealSymmetric(_ref) {
     var N = Sij.length;
     var c = Math.cos(theta);
     var s = Math.sin(theta);
-    var Ski = createArray(N, 0);
-    var Skj = createArray(N, 0);
+    var Ski = Array(N).fill(0);
+    var Skj = Array(N).fill(0);
     for (var k = 0; k < N; k++) {
       Ski[k] = c * Sij[k][i] - s * Sij[k][j];
       Skj[k] = s * Sij[k][i] + c * Sij[k][j];
@@ -135,8 +142,8 @@ function createRealSymmetric(_ref) {
     var N = Sij.length;
     var c = cos(theta);
     var s = sin(theta);
-    var Ski = createArray(N, bignumber(0));
-    var Skj = createArray(N, bignumber(0));
+    var Ski = Array(N).fill(bignumber(0));
+    var Skj = Array(N).fill(bignumber(0));
     for (var k = 0; k < N; k++) {
       Ski[k] = subtract(multiplyScalar(c, Sij[k][i]), multiplyScalar(s, Sij[k][j]));
       Skj[k] = addScalar(multiplyScalar(s, Sij[k][i]), multiplyScalar(c, Sij[k][j]));
@@ -155,8 +162,8 @@ function createRealSymmetric(_ref) {
     var s = bignumber(sin(theta));
     var c2 = multiplyScalar(c, c);
     var s2 = multiplyScalar(s, s);
-    var Aki = createArray(N, bignumber(0));
-    var Akj = createArray(N, bignumber(0));
+    var Aki = Array(N).fill(bignumber(0));
+    var Akj = Array(N).fill(bignumber(0));
     // 2cs Hij
     var csHij = multiply(bignumber(2), c, s, Hij[i][j]);
     //  Aii
@@ -191,8 +198,8 @@ function createRealSymmetric(_ref) {
     var s = Math.sin(theta);
     var c2 = c * c;
     var s2 = s * s;
-    var Aki = createArray(N, 0);
-    var Akj = createArray(N, 0);
+    var Aki = Array(N).fill(0);
+    var Akj = Array(N).fill(0);
     //  Aii
     var Aii = c2 * Hij[i][i] - 2 * c * s * Hij[i][j] + s2 * Hij[j][j];
     var Ajj = s2 * Hij[i][i] + 2 * c * s * Hij[i][j] + c2 * Hij[j][j];
@@ -251,12 +258,15 @@ function createRealSymmetric(_ref) {
   }
 
   // sort results
-  function sorting(E, S) {
+  function sorting(E, S, computeVectors) {
     var N = E.length;
     var values = Array(N);
-    var vectors = Array(N);
-    for (var k = 0; k < N; k++) {
-      vectors[k] = Array(N);
+    var vecs;
+    if (computeVectors) {
+      vecs = Array(N);
+      for (var k = 0; k < N; k++) {
+        vecs[k] = Array(N);
+      }
     }
     for (var i = 0; i < N; i++) {
       var minID = 0;
@@ -268,30 +278,26 @@ function createRealSymmetric(_ref) {
         }
       }
       values[i] = E.splice(minID, 1)[0];
-      for (var _k5 = 0; _k5 < N; _k5++) {
-        vectors[_k5][i] = S[_k5][minID];
-        S[_k5].splice(minID, 1);
+      if (computeVectors) {
+        for (var _k5 = 0; _k5 < N; _k5++) {
+          vecs[i][_k5] = S[_k5][minID];
+          S[_k5].splice(minID, 1);
+        }
       }
     }
+    if (!computeVectors) return {
+      values: values
+    };
+    var eigenvectors = vecs.map(function (vector, i) {
+      return {
+        value: values[i],
+        vector: vector
+      };
+    });
     return {
       values: values,
-      vectors: vectors
+      eigenvectors: eigenvectors
     };
   }
-
-  /**
-   * Create an array of a certain size and fill all items with an initial value
-   * @param {number} size
-   * @param {number} value
-   * @return {number[]}
-   */
-  function createArray(size, value) {
-    // TODO: as soon as all browsers support Array.fill, use that instead (IE doesn't support it)
-    var array = new Array(size);
-    for (var i = 0; i < size; i++) {
-      array[i] = value;
-    }
-    return array;
-  }
   return main;
 }

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/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.11.2
- * @date    2023-10-11
+ * @version 12.0.0
+ * @date    2023-10-26
  *
  * @license
  * Copyright (C) 2013-2023 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/type/unit/Unit.js

@@ -17,12 +17,12 @@ var _constants = require("../../utils/bignumber/constants.js");
 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; }
 var name = 'Unit';
-var dependencies = ['?on', 'config', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
+var dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
 var createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var on = _ref.on,
     config = _ref.config,
     addScalar = _ref.addScalar,
-    subtract = _ref.subtract,
+    subtractScalar = _ref.subtractScalar,
     multiplyScalar = _ref.multiplyScalar,
     divideScalar = _ref.divideScalar,
     pow = _ref.pow,
@@ -753,7 +753,7 @@ var createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fact
         var unitValue = convert(ret.units[0].unit.value);
         var nominalOffset = convert(ret.units[0].unit.offset);
         var unitOffset = multiplyScalar(unitValue, nominalOffset);
-        ret.value = subtract(abs(addScalar(ret.value, unitOffset)), unitOffset);
+        ret.value = subtractScalar(abs(addScalar(ret.value, unitOffset)), unitOffset);
       }
     }
     for (var i in ret.units) {
@@ -798,7 +798,7 @@ var createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fact
       var otherUnitValue = other.units[0].unit.value;
       var otherNominalOffset = other.units[0].unit.offset;
       var otherUnitOffset = multiplyScalar(otherUnitValue, otherNominalOffset);
-      other.value = addScalar(value, convert(subtract(thisUnitOffset, otherUnitOffset)));
+      other.value = addScalar(value, convert(subtractScalar(thisUnitOffset, otherUnitOffset)));
     }
     other.fixPrefix = true;
     other.skipAutomaticSimplification = true;
@@ -1174,7 +1174,7 @@ var createUnitClass = exports.createUnitClass = /* #__PURE__ */(0, _factory.fact
       }
       var y = new Unit(xFixed, parts[i].toString());
       ret.push(y);
-      x = subtract(x, y);
+      x = subtractScalar(x, y);
     }
 
     // This little bit fixes a bug where the remainder should be 0 but is a little bit off.

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/object.js

@@ -54,10 +54,12 @@ function clone(x) {
   }
   if (x instanceof Date) return new Date(x.valueOf());
   if ((0, _is.isBigNumber)(x)) return x; // bignumbers are immutable
-  if (x instanceof RegExp) throw new TypeError('Cannot clone ' + x); // TODO: clone a RegExp
 
   // object
-  return mapObject(x, clone);
+  if ((0, _is.isObject)(x)) {
+    return mapObject(x, clone);
+  }
+  throw new TypeError("Cannot clone: unknown type of value (value: ".concat(x, ")"));
 }
 
 /**

package/lib/cjs/utils/snapshot.js

@@ -14,8 +14,8 @@ var _assert = _interopRequireDefault(require("assert"));
 var allIsFunctions = _interopRequireWildcard(require("./is.js"));
 var _create = require("../core/create.js");
 var _string = require("./string.js");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+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
@@ -141,7 +141,7 @@ function createSnapshotFromFactories(factories) {
       embeddedDocs[name] = 'Object';
     }
   });
-  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'apply', 'addScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
+  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'apply', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
   var allTypeChecks = {};
   Object.keys(allIsFunctions).forEach(function (name) {
     if (name.indexOf('is') === 0) {

package/lib/cjs/utils/string.js

@@ -92,7 +92,7 @@ function _format(value, options) {
     return formatArray(value, options);
   }
   if ((0, _is.isString)(value)) {
-    return '"' + value + '"';
+    return stringify(value);
   }
   if (typeof value === 'function') {
     return value.syntax ? String(value.syntax) : 'function';
@@ -105,7 +105,7 @@ function _format(value, options) {
       return value.toString(options);
     } else {
       var entries = Object.keys(value).map(function (key) {
-        return '"' + key + '": ' + format(value[key], options);
+        return stringify(key) + ': ' + format(value[key], options);
       });
       return '{' + entries.join(', ') + '}';
     }
@@ -125,24 +125,20 @@ function stringify(value) {
   var i = 0;
   while (i < text.length) {
     var c = text.charAt(i);
-    if (c === '\\') {
-      escaped += c;
-      i++;
-      c = text.charAt(i);
-      if (c === '' || '"\\/bfnrtu'.indexOf(c) === -1) {
-        escaped += '\\'; // no valid escape character -> escape it
-      }
-
-      escaped += c;
-    } else if (c === '"') {
-      escaped += '\\"';
-    } else {
-      escaped += c;
-    }
+    escaped += c in controlCharacters ? controlCharacters[c] : c;
     i++;
   }
   return '"' + escaped + '"';
 }
+var controlCharacters = {
+  '"': '\\"',
+  '\\': '\\\\',
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t'
+};
 
 /**
  * Escape special HTML characters

package/lib/cjs/version.js

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

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

@@ -6,7 +6,7 @@ import { divideScalarDependencies } from './dependenciesDivideScalar.generated.j
 import { isZeroDependencies } from './dependenciesIsZero.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
-import { subtractDependencies } from './dependenciesSubtract.generated.js';
+import { subtractScalarDependencies } from './dependenciesSubtractScalar.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { unaryMinusDependencies } from './dependenciesUnaryMinus.generated.js';
 import { createDet } from '../../factoriesAny.js';
@@ -15,7 +15,7 @@ export var detDependencies = {
   isZeroDependencies,
   matrixDependencies,
   multiplyDependencies,
-  subtractDependencies,
+  subtractScalarDependencies,
   typedDependencies,
   unaryMinusDependencies,
   createDet

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

@@ -8,7 +8,7 @@ import { deepEqualDependencies } from './dependenciesDeepEqual.generated.js';
 import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
 import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generated.js';
 import { sqrtDependencies } from './dependenciesSqrt.generated.js';
-import { subtractDependencies } from './dependenciesSubtract.generated.js';
+import { subtractScalarDependencies } from './dependenciesSubtractScalar.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createDistance } from '../../factoriesAny.js';
 export var distanceDependencies = {
@@ -18,7 +18,7 @@ export var distanceDependencies = {
   divideScalarDependencies,
   multiplyScalarDependencies,
   sqrtDependencies,
-  subtractDependencies,
+  subtractScalarDependencies,
   typedDependencies,
   createDistance
 };