mathjs 14.4.0 → 14.5.1

package/lib/esm/expression/embeddedDocs/function/expression/compile.js

@@ -0,0 +1,8 @@
+export var compileDocs = {
+  name: 'compile',
+  category: 'Expression',
+  syntax: ['compile(expr) ', 'compile([expr1, expr2, expr3, ...])'],
+  description: 'Parse and compile an expression. Returns a an object with a function evaluate([scope]) to evaluate the compiled expression.',
+  examples: ['code1 = compile("sqrt(3^2 + 4^2)")', 'code1.evaluate() ', 'code2 = compile("a * b")', 'code2.evaluate({a: 3, b: 4})'],
+  seealso: ['parser', 'parse', 'evaluate']
+};

package/lib/esm/expression/embeddedDocs/function/expression/evaluate.js

@@ -4,5 +4,5 @@ export var evaluateDocs = {
   syntax: ['evaluate(expression)', 'evaluate(expression, scope)', 'evaluate([expr1, expr2, expr3, ...])', 'evaluate([expr1, expr2, expr3, ...], scope)'],
   description: 'Evaluate an expression or an array with expressions.',
   examples: ['evaluate("2 + 3")', 'evaluate("sqrt(16)")', 'evaluate("2 inch to cm")', 'evaluate("sin(x * pi)", { "x": 1/2 })', 'evaluate(["width=2", "height=4","width*height"])'],
-  seealso: []
+  seealso: ['parser', 'parse', 'compile']
 };

package/lib/esm/expression/embeddedDocs/function/expression/parse.js

@@ -0,0 +1,8 @@
+export var parseDocs = {
+  name: 'parse',
+  category: 'Expression',
+  syntax: ['parse(expr)', 'parse(expr, options)', 'parse([expr1, expr2, expr3, ...])', 'parse([expr1, expr2, expr3, ...], options)'],
+  description: 'Parse an expression. Returns a node tree, which can be evaluated by invoking node.evaluate() or transformed into a functional object via node.compile().',
+  examples: ['node1 = parse("sqrt(3^2 + 4^2)")', 'node1.evaluate()', 'code1 = node1.compile()', 'code1.evaluate()', 'scope = {a: 3, b: 4}', 'node2 = parse("a * b")', 'node2.evaluate(scope)', 'code2 = node2.compile()', 'code2.evaluate(scope)'],
+  seealso: ['parser', 'evaluate', 'compile']
+};

package/lib/esm/expression/embeddedDocs/function/expression/parser.js

@@ -0,0 +1,8 @@
+export var parserDocs = {
+  name: 'parser',
+  category: 'Expression',
+  syntax: ['parser()'],
+  description: 'Create a parser object that keeps a context of variables and their values, allowing the evaluation of expressions in that context.',
+  examples: ['myParser = parser()', 'myParser.evaluate("sqrt(3^2 + 4^2)")', 'myParser.set("x", 3)', 'myParser.evaluate("y = x + 3")', 'myParser.evaluate(["y = x + 3", "y = y + 1"])', 'myParser.get("y")'],
+  seealso: ['evaluate', 'parse', 'compile']
+};

package/lib/esm/expression/embeddedDocs/function/statistics/sum.js

@@ -4,5 +4,5 @@ export var sumDocs = {
   syntax: ['sum(a, b, c, ...)', 'sum(A)', 'sum(A, dimension)'],
   description: 'Compute the sum of all values.',
   examples: ['sum(2, 3, 4, 1)', 'sum([2, 3, 4, 1])', 'sum([2, 5; 4, 3])'],
-  seealso: ['max', 'mean', 'median', 'min', 'prod', 'std', 'sum', 'variance']
+  seealso: ['max', 'mean', 'median', 'min', 'prod', 'std', 'variance']
 };

package/lib/esm/expression/function/parser.js

@@ -7,7 +7,7 @@ export var createParser = /* #__PURE__ */factory(name, dependencies, _ref => {
     Parser
   } = _ref;
   /**
-   * Create a parser. The function creates a new `math.Parser` object.
+   * Create a `math.Parser` object that keeps a context of variables and their values, allowing the evaluation of expressions in that context.
    *
    * Syntax:
    *

package/lib/esm/expression/parse.js

@@ -29,7 +29,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
   /**
    * Parse an expression. Returns a node tree, which can be evaluated by
-   * invoking node.evaluate().
+   * invoking node.evaluate() or transformed into a functional object via node.compile().
    *
    * Note the evaluating arbitrary expressions may involve security risks,
    * see [https://mathjs.org/docs/expressions/security.html](https://mathjs.org/docs/expressions/security.html) for more information.
@@ -48,6 +48,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *     let scope = {a:3, b:4}
    *     const node2 = math.parse('a * b') // 12
+   *     node2.evaluate(scope) // 12
    *     const code2 = node2.compile()
    *     code2.evaluate(scope) // 12
    *     scope.a = 5
@@ -870,7 +871,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       name = state.token;
       fn = operators[name];
       getTokenSkipNewline(state);
-      if (name === 'in' && state.token === '') {
+      if (name === 'in' && '])},;'.includes(state.token)) {
         // end of expression -> this is the unit 'in' ('inch')
         node = new OperatorNode('*', 'multiply', [node, new SymbolNode('in')], true);
       } else {

package/lib/esm/factoriesAny.js

@@ -270,7 +270,7 @@ export { createReplacer } from './json/replacer.js';
 export { createE, createUppercaseE, createFalse, createI, createInfinity, createLN10, createLN2, createLOG10E, createLOG2E, createNaN, createNull, createPhi, createPi, createUppercasePi, createSQRT1_2,
 // eslint-disable-line camelcase
 createSQRT2, createTau, createTrue, createVersion } from './constants.js';
-export { createAtomicMass, createAvogadro, createBohrMagneton, createBohrRadius, createBoltzmann, createClassicalElectronRadius, createConductanceQuantum, createCoulomb, createDeuteronMass, createEfimovFactor, createElectricConstant, createElectronMass, createElementaryCharge, createFaraday, createFermiCoupling, createFineStructure, createFirstRadiation, createGasConstant, createGravitationConstant, createGravity, createHartreeEnergy, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMagneticFluxQuantum, createMolarMass, createMolarMassC12, createMolarPlanckConstant, createMolarVolume, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckConstant, createPlanckLength, createPlanckMass, createPlanckTemperature, createPlanckTime, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSackurTetrode, createSecondRadiation, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createVacuumImpedance, createWeakMixingAngle, createWienDisplacement } from './type/unit/physicalConstants.js';
+export { createAtomicMass, createAvogadro, createBohrMagneton, createBohrRadius, createBoltzmann, createClassicalElectronRadius, createConductanceQuantum, createCoulomb, createCoulombConstant, createDeuteronMass, createEfimovFactor, createElectricConstant, createElectronMass, createElementaryCharge, createFaraday, createFermiCoupling, createFineStructure, createFirstRadiation, createGasConstant, createGravitationConstant, createGravity, createHartreeEnergy, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMagneticFluxQuantum, createMolarMass, createMolarMassC12, createMolarPlanckConstant, createMolarVolume, createNeutronMass, createNuclearMagneton, createPlanckCharge, createPlanckConstant, createPlanckLength, createPlanckMass, createPlanckTemperature, createPlanckTime, createProtonMass, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSackurTetrode, createSecondRadiation, createSpeedOfLight, createStefanBoltzmann, createThomsonCrossSection, createVacuumImpedance, createWeakMixingAngle, createWienDisplacement } from './type/unit/physicalConstants.js';
 export { createMapSlicesTransform } from './expression/transform/mapSlices.transform.js';
 export { createColumnTransform } from './expression/transform/column.transform.js';
 export { createFilterTransform } from './expression/transform/filter.transform.js';

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

@@ -32,39 +32,39 @@ export var createAdd = /* #__PURE__ */factory(name, dependencies, _ref => {
     concat
   });
   /**
-  * Add two or more values, `x + y`.
-  * For matrices, the function is evaluated element wise.
-  *
-  * Syntax:
-  *
-  *    math.add(x, y)
-  *    math.add(x, y, z, ...)
-  *
-  * Examples:
-  *
-  *    math.add(2, 3)               // returns number 5
-  *    math.add(2, 3, 4)            // returns number 9
-  *
-  *    const a = math.complex(2, 3)
-  *    const b = math.complex(-4, 1)
-  *    math.add(a, b)               // returns Complex -2 + 4i
-  *
-  *    math.add([1, 2, 3], 4)       // returns Array [5, 6, 7]
-  *
-  *    const c = math.unit('5 cm')
-  *    const d = math.unit('2.1 mm')
-  *    math.add(c, d)               // returns Unit 52.1 mm
-  *
-  *    math.add("2.3", "4")         // returns number 6.3
-  *
-  * See also:
-  *
-  *    subtract, sum
-  *
-  * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x First value to add
-  * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} y Second value to add
-  * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
-  */
+   * Add two or more values, `x + y`.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.add(x, y)
+   *    math.add(x, y, z, ...)
+   *
+   * Examples:
+   *
+   *    math.add(2, 3)               // returns number 5
+   *    math.add(2, 3, 4)            // returns number 9
+   *
+   *    const a = math.complex(2, 3)
+   *    const b = math.complex(-4, 1)
+   *    math.add(a, b)               // returns Complex -2 + 4i
+   *
+   *    math.add([1, 2, 3], 4)       // returns Array [5, 6, 7]
+   *
+   *    const c = math.unit('5 cm')
+   *    const d = math.unit('2.1 mm')
+   *    math.add(c, d)               // returns Unit 52.1 mm
+   *
+   *    math.add("2.3", "4")         // returns number 6.3
+   *
+   * See also:
+   *
+   *    subtract, sum
+   *
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x First value to add
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} y Second value to add
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
+   */
   return typed(name, {
     'any, any': addScalar,
     'any, any, ...any': typed.referToSelf(self => (x, y, rest) => {

package/lib/esm/function/complex/conj.js

@@ -26,14 +26,15 @@ export var createConj = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    re, im, arg, abs
    *
-   * @param {number | BigNumber | Complex | Array | Matrix} x
+   * @param {number | BigNumber | Complex | Array | Matrix | Unit} x
    *            A complex number or array with complex numbers
-   * @return {number | BigNumber | Complex | Array | Matrix}
+   * @return {number | BigNumber | Complex | Array | Matrix | Unit}
    *            The complex conjugate of x
    */
   return typed(name, {
     'number | BigNumber | Fraction': x => x,
     Complex: x => x.conjugate(),
+    Unit: typed.referToSelf(self => x => new x.constructor(self(x.toNumeric()), x.formatUnits())),
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/function/probability/randomInt.js

@@ -4,7 +4,6 @@ import { createRng } from './util/seededRNG.js';
 import { isMatrix } from '../../utils/is.js';
 var name = 'randomInt';
 var dependencies = ['typed', 'config', 'log2', '?on'];
-var simpleCutoff = 2n ** 30n;
 export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -69,6 +68,7 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
     return Math.floor(min + rng() * (max - min));
   }
   function _randomBigint(min, max) {
+    var simpleCutoff = 2n ** 30n;
     var width = max - min; // number of choices
     if (width <= simpleCutoff) {
       // do it with number type

package/lib/esm/function/utils/numeric.js

@@ -30,6 +30,7 @@ export var createNumeric = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Syntax:
    *
    *    math.numeric(x)
+   *    math.numeric(value, outputType)
    *
    * Examples:
    *

package/lib/esm/type/matrix/DenseMatrix.js

@@ -241,36 +241,46 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       }
 
       // retrieve submatrix
-      // TODO: more efficient when creating an empty matrix and setting _data and _size manually
-      return new DenseMatrix(_getSubmatrix(matrix._data, index, size.length, 0), matrix._datatype);
+      var returnMatrix = new DenseMatrix([]);
+      var submatrix = _getSubmatrix(matrix._data, index);
+      returnMatrix._size = submatrix.size;
+      returnMatrix._datatype = matrix._datatype;
+      returnMatrix._data = submatrix.data;
+      return returnMatrix;
     }
   }
 
   /**
-   * Recursively get a submatrix of a multi dimensional matrix.
+   * Get a submatrix of a multi dimensional matrix.
    * Index is not checked for correct number or length of dimensions.
    * @memberof DenseMatrix
    * @param {Array} data
    * @param {Index} index
-   * @param {number} dims   Total number of dimensions
-   * @param {number} dim    Current dimension
    * @return {Array} submatrix
    * @private
    */
-  function _getSubmatrix(data, index, dims, dim) {
-    var last = dim === dims - 1;
-    var range = index.dimension(dim);
-    if (last) {
-      return range.map(function (i) {
-        validateIndex(i, data.length);
-        return data[i];
-      }).valueOf();
-    } else {
-      return range.map(function (i) {
-        validateIndex(i, data.length);
-        var child = data[i];
-        return _getSubmatrix(child, index, dims, dim + 1);
-      }).valueOf();
+  function _getSubmatrix(data, index) {
+    var maxDepth = index.size().length - 1;
+    var size = Array(maxDepth);
+    return {
+      data: getSubmatrixRecursive(data),
+      size
+    };
+    function getSubmatrixRecursive(data) {
+      var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var ranges = index.dimension(depth);
+      size[depth] = ranges.size()[0];
+      if (depth < maxDepth) {
+        return ranges.map(rangeIndex => {
+          validateIndex(rangeIndex, data.length);
+          return getSubmatrixRecursive(data[rangeIndex], depth + 1);
+        }).valueOf();
+      } else {
+        return ranges.map(rangeIndex => {
+          validateIndex(rangeIndex, data.length);
+          return data[rangeIndex];
+        }).valueOf();
+      }
     }
   }
 
@@ -358,9 +368,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       _fit(matrix, size, defaultValue);
 
       // insert the sub matrix
-      var dims = iSize.length;
-      var dim = 0;
-      _setSubmatrix(matrix._data, index, submatrix, dims, dim);
+      _setSubmatrix(matrix._data, index, submatrix);
     }
     return matrix;
   }
@@ -371,23 +379,25 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @param {Array} data
    * @param {Index} index
    * @param {Array} submatrix
-   * @param {number} dims   Total number of dimensions
-   * @param {number} dim
    * @private
    */
-  function _setSubmatrix(data, index, submatrix, dims, dim) {
-    var last = dim === dims - 1;
-    var range = index.dimension(dim);
-    if (last) {
-      range.forEach(function (dataIndex, subIndex) {
-        validateIndex(dataIndex);
-        data[dataIndex] = submatrix[subIndex[0]];
-      });
-    } else {
-      range.forEach(function (dataIndex, subIndex) {
-        validateIndex(dataIndex);
-        _setSubmatrix(data[dataIndex], index, submatrix[subIndex[0]], dims, dim + 1);
-      });
+  function _setSubmatrix(data, index, submatrix) {
+    var maxDepth = index.size().length - 1;
+    setSubmatrixRecursive(data, submatrix);
+    function setSubmatrixRecursive(data, submatrix) {
+      var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      var range = index.dimension(depth);
+      if (depth < maxDepth) {
+        range.forEach((rangeIndex, i) => {
+          validateIndex(rangeIndex, data.length);
+          setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
+        });
+      } else {
+        range.forEach((rangeIndex, i) => {
+          validateIndex(rangeIndex, data.length);
+          data[rangeIndex] = submatrix[i[0]];
+        });
+      }
     }
   }
 
@@ -518,84 +528,75 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
   };
 
   /**
-   * Applies a callback function to a reference to each element of the matrix
+   * Create a new matrix with the results of the callback function executed on
+   * each entry of the matrix.
    * @memberof DenseMatrix
    * @param {Function} callback   The callback function is invoked with three
-   *                              parameters: the array containing the element,
-   *                              the index of the element within that array (as an integer),
-   *                              and for non unarry callbacks copy of the current index (as an array of integers).
+   *                              parameters: the value of the element, the index
+   *                              of the element, and the Matrix being traversed.
+   * @param {boolean} skipZeros   If true, the callback function is invoked only for non-zero entries
+   * @param {boolean} isUnary     If true, the callback function is invoked with one parameter
+   *
+   * @return {DenseMatrix} matrix
    */
-  DenseMatrix.prototype._forEach = function (callback) {
-    var isUnary = callback.length === 2; // callback has 2 parameters: value, index
-    var maxDepth = this._size.length - 1;
-    if (maxDepth < 0) return;
-    if (isUnary) {
-      iterateUnary(this._data);
-      return;
+  DenseMatrix.prototype.map = function (callback) {
+    var skipZeros = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var isUnary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var me = this;
+    var maxDepth = me._size.length - 1;
+    if (maxDepth < 0) return me.clone();
+    var fastCallback = optimizeCallback(callback, me, 'map', isUnary);
+    var fastCallbackFn = fastCallback.fn;
+    var result = me.create(undefined, me._datatype);
+    result._size = me._size;
+    if (isUnary || fastCallback.isUnary) {
+      result._data = iterateUnary(me._data);
+      return result;
     }
     if (maxDepth === 0) {
-      for (var i = 0; i < this._data.length; i++) {
-        callback(this._data, i, [i]);
+      var inputData = me.valueOf();
+      var data = Array(inputData.length);
+      for (var i = 0; i < inputData.length; i++) {
+        data[i] = fastCallbackFn(inputData[i], [i], me);
       }
-      return;
+      result._data = data;
+      return result;
     }
-    var index = new Array(maxDepth + 1);
-    iterate(this._data);
+    var index = [];
+    result._data = iterate(me._data);
+    return result;
     function iterate(data) {
       var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var result = Array(data.length);
       if (depth < maxDepth) {
         for (var _i = 0; _i < data.length; _i++) {
           index[depth] = _i;
-          iterate(data[_i], depth + 1);
+          result[_i] = iterate(data[_i], depth + 1);
         }
       } else {
         for (var _i2 = 0; _i2 < data.length; _i2++) {
           index[depth] = _i2;
-          callback(data, _i2, index.slice());
+          result[_i2] = fastCallbackFn(data[_i2], index.slice(), me);
         }
       }
+      return result;
     }
     function iterateUnary(data) {
       var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var result = Array(data.length);
       if (depth < maxDepth) {
         for (var _i3 = 0; _i3 < data.length; _i3++) {
-          iterateUnary(data[_i3], depth + 1);
+          result[_i3] = iterateUnary(data[_i3], depth + 1);
         }
       } else {
         for (var _i4 = 0; _i4 < data.length; _i4++) {
-          callback(data, _i4);
+          result[_i4] = fastCallbackFn(data[_i4]);
         }
       }
+      return result;
     }
   };
 
-  /**
-   * Create a new matrix with the results of the callback function executed on
-   * each entry of the matrix.
-   * @memberof DenseMatrix
-   * @param {Function} callback   The callback function is invoked with three
-   *                              parameters: the value of the element, the index
-   *                              of the element, and the Matrix being traversed.
-   * @param {boolean} skipZeros   If true, the callback function is invoked only for non-zero entries
-   * @param {boolean} isUnary     If true, the callback function is invoked with one parameter
-   *
-   * @return {DenseMatrix} matrix
-   */
-  DenseMatrix.prototype.map = function (callback) {
-    var skipZeros = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var isUnary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var me = this;
-    var result = new DenseMatrix(me);
-    var fastCallback = optimizeCallback(callback, me._data, 'map', isUnary);
-    var applyCallback = isUnary || fastCallback.isUnary ? (arr, i) => {
-      arr[i] = fastCallback.fn(arr[i]);
-    } : (arr, i, index) => {
-      arr[i] = fastCallback.fn(arr[i], index, me);
-    };
-    result._forEach(applyCallback);
-    return result;
-  };
-
   /**
    * Execute a callback function on each entry of the matrix.
    * @memberof DenseMatrix
@@ -609,13 +610,48 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     var skipZeros = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     var isUnary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     var me = this;
-    var fastCallback = optimizeCallback(callback, me._data, 'map', isUnary);
-    var applyCallback = isUnary || fastCallback.isUnary ? (arr, i) => {
-      fastCallback.fn(arr[i]);
-    } : (arr, i, index) => {
-      fastCallback.fn(arr[i], index, me);
-    };
-    me._forEach(applyCallback);
+    var maxDepth = me._size.length - 1;
+    if (maxDepth < 0) return;
+    var fastCallback = optimizeCallback(callback, me, 'map', isUnary);
+    var fastCallbackFn = fastCallback.fn;
+    if (isUnary || fastCallback.isUnary) {
+      iterateUnary(me._data);
+      return;
+    }
+    if (maxDepth === 0) {
+      for (var i = 0; i < me._data.length; i++) {
+        fastCallbackFn(me._data[i], [i], me);
+      }
+      return;
+    }
+    var index = [];
+    iterate(me._data);
+    function iterate(data) {
+      var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (depth < maxDepth) {
+        for (var _i5 = 0; _i5 < data.length; _i5++) {
+          index[depth] = _i5;
+          iterate(data[_i5], depth + 1);
+        }
+      } else {
+        for (var _i6 = 0; _i6 < data.length; _i6++) {
+          index[depth] = _i6;
+          fastCallbackFn(data[_i6], index.slice(), me);
+        }
+      }
+    }
+    function iterateUnary(data) {
+      var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (depth < maxDepth) {
+        for (var _i7 = 0; _i7 < data.length; _i7++) {
+          iterateUnary(data[_i7], depth + 1);
+        }
+      } else {
+        for (var _i8 = 0; _i8 < data.length; _i8++) {
+          fastCallbackFn(data[_i8]);
+        }
+      }
+    }
   };
 
   /**
@@ -639,15 +675,15 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     var index = [];
     var _recurse = function* recurse(value, depth) {
       if (depth < maxDepth) {
-        for (var _i5 = 0; _i5 < value.length; _i5++) {
-          index[depth] = _i5;
-          yield* _recurse(value[_i5], depth + 1);
+        for (var _i9 = 0; _i9 < value.length; _i9++) {
+          index[depth] = _i9;
+          yield* _recurse(value[_i9], depth + 1);
         }
       } else {
-        for (var _i6 = 0; _i6 < value.length; _i6++) {
-          index[depth] = _i6;
+        for (var _i0 = 0; _i0 < value.length; _i0++) {
+          index[depth] = _i0;
           yield {
-            value: value[_i6],
+            value: value[_i0],
             index: index.slice()
           };
         }

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

@@ -618,8 +618,8 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
 
     // If at least one operand has a value, then the result should also have a value
     if (this.value !== null || other.value !== null) {
-      var valThis = this.value === null ? this._normalize(1) : this.value;
-      var valOther = other.value === null ? other._normalize(1) : other.value;
+      var valThis = this.value === null ? this._normalize(one(other.value)) : this.value;
+      var valOther = other.value === null ? other._normalize(one(this.value)) : other.value;
       res.value = multiplyScalar(valThis, valOther);
     } else {
       res.value = null;
@@ -666,8 +666,8 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
 
     // If at least one operand has a value, the result should have a value
     if (this.value !== null || other.value !== null) {
-      var valThis = this.value === null ? this._normalize(1) : this.value;
-      var valOther = other.value === null ? other._normalize(1) : other.value;
+      var valThis = this.value === null ? this._normalize(one(other.value)) : this.value;
+      var valOther = other.value === null ? other._normalize(one(this.value)) : other.value;
       res.value = divideScalar(valThis, valOther);
     } else {
       res.value = null;
@@ -723,6 +723,21 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     }
   }
 
+  /**
+   * Create a value one with the numeric type of `typeOfValue`.
+   * For example, `one(new BigNumber(3))` returns `BigNumber(1)`
+   * @param {number | Fraction | BigNumber} typeOfValue
+   * @returns {number | Fraction | BigNumber}
+   */
+  function one(typeOfValue) {
+    // TODO: this is a workaround to prevent the following BigNumber conversion error from throwing:
+    //  "TypeError: Cannot implicitly convert a number with >15 significant digits to BigNumber"
+    //  see https://github.com/josdejong/mathjs/issues/3450
+    //      https://github.com/josdejong/mathjs/pull/3375
+    var convert = Unit._getNumberConverter(typeOf(typeOfValue));
+    return convert(1);
+  }
+
   /**
    * Calculate the absolute value of a unit
    * @memberof Unit

package/lib/esm/type/unit/physicalConstants.js

@@ -12,7 +12,8 @@ export var createReducedPlanckConstant = /* #__PURE__ */unitFactory('reducedPlan
 export var createMagneticConstant = /* #__PURE__ */unitFactory('magneticConstant', '1.25663706212e-6', 'N A^-2');
 export var createElectricConstant = /* #__PURE__ */unitFactory('electricConstant', '8.8541878128e-12', 'F m^-1');
 export var createVacuumImpedance = /* #__PURE__ */unitFactory('vacuumImpedance', '376.730313667', 'ohm');
-export var createCoulomb = /* #__PURE__ */unitFactory('coulomb', '8.987551792261171e9', 'N m^2 C^-2');
+export var createCoulomb = /* #__PURE__ */unitFactory('coulomb', '8.987551792261171e9', 'N m^2 C^-2'); // Deprecated in favor of coulombConstant
+export var createCoulombConstant = /* #__PURE__ */unitFactory('coulombConstant', '8.987551792261171e9', 'N m^2 C^-2');
 export var createElementaryCharge = /* #__PURE__ */unitFactory('elementaryCharge', '1.602176634e-19', 'C');
 export var createBohrMagneton = /* #__PURE__ */unitFactory('bohrMagneton', '9.2740100783e-24', 'J T^-1');
 export var createConductanceQuantum = /* #__PURE__ */unitFactory('conductanceQuantum', '7.748091729863649e-5', 'S');

package/lib/esm/utils/snapshot.js

@@ -138,7 +138,7 @@ export function createSnapshotFromFactories(factories) {
       embeddedDocs[name] = 'Object';
     }
   });
-  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
+  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'coulomb', 'reviver', 'replacer']);
   var allTypeChecks = {};
   Object.keys(allIsFunctions).forEach(name => {
     if (name.indexOf('is') === 0) {

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.4.0';
+export var version = '14.5.1';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.