mathjs 10.0.0 → 10.6.4

package/lib/cjs/function/statistics/cumsum.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCumSum = void 0;
+
+var _collection = require("../../utils/collection.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _switch2 = require("../../utils/switch.js");
+
+var _improveErrorMessage = require("./utils/improveErrorMessage.js");
+
+var _array = require("../../utils/array.js");
+
+var _IndexError = require("../../error/IndexError.js");
+
+var name = 'cumsum';
+var dependencies = ['typed', 'add', 'unaryPlus'];
+var createCumSum = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      add = _ref.add,
+      unaryPlus = _ref.unaryPlus;
+
+  /**
+   * Compute the cumulative sum of a matrix or a list with values.
+   * In case of a (multi dimensional) array or matrix, the cumulative sums
+   * along a specified dimension (defaulting to the first) will be calculated.
+   *
+   * Syntax:
+   *
+   *     math.cumsum(a, b, c, ...)
+   *     math.cumsum(A)
+   *
+   * Examples:
+   *
+   *     math.cumsum(2, 1, 4, 3)               // returns [2, 3, 7, 10]
+   *     math.cumsum([2, 1, 4, 3])             // returns [2, 3, 7, 10]
+   *     math.cumsum([[1, 2], [3, 4]])         // returns [[1, 2], [4, 6]]
+   *     math.cumsum([[1, 2], [3, 4]], 0)      // returns [[1, 2], [4, 6]]
+   *     math.cumsum([[1, 2], [3, 4]], 1)      // returns [[1, 3], [3, 7]]
+   *     math.cumsum([[2, 5], [4, 3], [1, 7]]) // returns [[2, 5], [6, 8], [7, 15]]
+   *
+   * See also:
+   *
+   *    mean, median, min, max, prod, std, variance, sum
+   *
+   * @param {... *} args  A single matrix or or multiple scalar values
+   * @return {*} The cumulative sum of all values
+   */
+  return typed(name, {
+    // sum([a, b, c, d, ...])
+    Array: _cumsum,
+    Matrix: function Matrix(matrix) {
+      return matrix.create(_cumsum(matrix.valueOf()));
+    },
+    // sum([a, b, c, d, ...], dim)
+    'Array, number | BigNumber': _ncumSumDim,
+    'Matrix, number | BigNumber': function MatrixNumberBigNumber(matrix, dim) {
+      return matrix.create(_ncumSumDim(matrix.valueOf(), dim));
+    },
+    // cumsum(a, b, c, d, ...)
+    '...': function _(args) {
+      if ((0, _collection.containsCollections)(args)) {
+        throw new TypeError('All values expected to be scalar in function cumsum');
+      }
+
+      return _cumsum(args);
+    }
+  });
+  /**
+     * Recursively calculate the cumulative sum of an n-dimensional array
+     * @param {Array} array
+     * @return {number} cumsum
+     * @private
+     */
+
+  function _cumsum(array) {
+    try {
+      return _cumsummap(array);
+    } catch (err) {
+      throw (0, _improveErrorMessage.improveErrorMessage)(err, name);
+    }
+  }
+
+  function _cumsummap(array) {
+    if (array.length === 0) {
+      return [];
+    }
+
+    var sums = [unaryPlus(array[0])]; // unaryPlus converts to number if need be
+
+    for (var i = 1; i < array.length; ++i) {
+      // Must use add below and not addScalar for the case of summing a
+      // 2+-dimensional array along the 0th dimension (the row vectors,
+      // or higher-d analogues, are literally added to each other).
+      sums.push(add(sums[i - 1], array[i]));
+    }
+
+    return sums;
+  }
+
+  function _ncumSumDim(array, dim) {
+    var size = (0, _array.arraySize)(array);
+
+    if (dim < 0 || dim >= size.length) {
+      // TODO: would be more clear when throwing a DimensionError here
+      throw new _IndexError.IndexError(dim, size.length);
+    }
+
+    try {
+      return _cumsumDimensional(array, dim);
+    } catch (err) {
+      throw (0, _improveErrorMessage.improveErrorMessage)(err, name);
+    }
+  }
+  /* Possible TODO: Refactor _reduce in collection.js to be able to work here as well */
+
+
+  function _cumsumDimensional(mat, dim) {
+    var i, ret, tran;
+
+    if (dim <= 0) {
+      var initialValue = mat[0][0];
+
+      if (!Array.isArray(initialValue)) {
+        return _cumsummap(mat);
+      } else {
+        tran = (0, _switch2._switch)(mat);
+        ret = [];
+
+        for (i = 0; i < tran.length; i++) {
+          ret[i] = _cumsumDimensional(tran[i], dim - 1);
+        }
+
+        return ret;
+      }
+    } else {
+      ret = [];
+
+      for (i = 0; i < mat.length; i++) {
+        ret[i] = _cumsumDimensional(mat[i], dim - 1);
+      }
+
+      return ret;
+    }
+  }
+});
+exports.createCumSum = createCumSum;

package/lib/cjs/function/statistics/sum.js

@@ -37,7 +37,7 @@ var createSum = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *
    * See also:
    *
-   *    mean, median, min, max, prod, std, variance
+   *    mean, median, min, max, prod, std, variance, cumsum
    *
    * @param {... *} args  A single matrix or or multiple scalar values
    * @return {*} The sum of all values

package/lib/cjs/function/string/format.js

@@ -77,6 +77,9 @@ var createFormat = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *    - `fraction: string`. Available values: 'ratio' (default) or 'decimal'.
    *      For example `format(fraction(1, 3))` will output '1/3' when 'ratio' is
    *      configured, and will output `0.(3)` when 'decimal' is configured.
+   *    - `truncate: number`. Specifies the maximum allowed length of the
+   *      returned string. If it would have been longer, the excess characters
+   *      are deleted and replaced with `'...'`.
    * - `callback: function`
    *   A custom formatting function, invoked for all numeric elements in `value`,
    *   for example all elements of a matrix, or the real and imaginary
@@ -119,7 +122,7 @@ var createFormat = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *      // you could also use math.format inside the callback:
    *      // return '$' + math.format(value, {notation: 'fixed', precision: 2})
    *    }
-   *    math.format([2.1, 3, 0.016], formatCurrency}            // returns '[$2.10, $3.00, $0.02]'
+   *    math.format([2.1, 3, 0.016], formatCurrency)            // returns '[$2.10, $3.00, $0.02]'
    *
    * See also:
    *

package/lib/cjs/header.js

@@ -6,11 +6,11 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 10.0.0
- * @date    2021-11-03
+ * @version 10.6.4
+ * @date    2022-06-28
  *
  * @license
- * Copyright (C) 2013-2021 Jos de Jong <wjosdejong@gmail.com>
+ * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy

package/lib/cjs/plain/bignumber/index.js

@@ -27,7 +27,7 @@ Object.keys(_arithmetic).forEach(function (key) {
 });
 
 // TODO: this is ugly. Instead, be able to pass your own isBigNumber function to typed?
-var BigNumber = _decimal["default"].clone();
+var BigNumber = _decimal.default.clone();
 
 BigNumber.prototype.isBigNumber = true;
 

package/lib/cjs/plain/number/arithmetic.js

@@ -6,13 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.absNumber = absNumber;
 exports.addNumber = addNumber;
 exports.cbrtNumber = cbrtNumber;
-exports.ceilNumber = ceilNumber;
 exports.cubeNumber = cubeNumber;
 exports.divideNumber = divideNumber;
 exports.expNumber = expNumber;
 exports.expm1Number = expm1Number;
-exports.fixNumber = fixNumber;
-exports.floorNumber = floorNumber;
 exports.gcdNumber = gcdNumber;
 exports.lcmNumber = lcmNumber;
 exports.log10Number = log10Number;
@@ -86,12 +83,6 @@ function cbrtNumber(x) {
 
 cbrtNumber.signature = n1;
 
-function ceilNumber(x) {
-  return Math.ceil(x);
-}
-
-ceilNumber.signature = n1;
-
 function cubeNumber(x) {
   return x * x * x;
 }
@@ -109,18 +100,6 @@ function expm1Number(x) {
 }
 
 expm1Number.signature = n1;
-
-function fixNumber(x) {
-  return x > 0 ? Math.floor(x) : Math.ceil(x);
-}
-
-fixNumber.signature = n1;
-
-function floorNumber(x) {
-  return Math.floor(x);
-}
-
-floorNumber.signature = n1;
 /**
  * Calculate gcd for numbers
  * @param {number} a
@@ -178,22 +157,26 @@ function lcmNumber(a, b) {
 
 lcmNumber.signature = n2;
 /**
- * Calculate the logarithm of a value.
+ * Calculate the logarithm of a value, optionally to a given base.
  * @param {number} x
+ * @param {number | null | undefined} base
  * @return {number}
  */
 
-function logNumber(x) {
+function logNumber(x, y) {
+  if (y) {
+    return Math.log(x) / Math.log(y);
+  }
+
   return Math.log(x);
 }
-
-logNumber.signature = n1;
 /**
  * Calculate the 10-base logarithm of a number
  * @param {number} x
  * @return {number}
  */
 
+
 function log10Number(x) {
   return (0, _number.log10)(x);
 }
@@ -249,11 +232,12 @@ modNumber.signature = n2;
  * Calculate the nth root of a, solve x^root == a
  * http://rosettacode.org/wiki/Nth_root#JavaScript
  * @param {number} a
- * @param {number} root
+ * @param {number} [2] root
  * @private
  */
 
-function nthRootNumber(a, root) {
+function nthRootNumber(a) {
+  var root = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
   var inv = root < 0;
 
   if (inv) {
@@ -304,8 +288,6 @@ function nthRootNumber(a, root) {
   */
 }
 
-nthRootNumber.signature = n2;
-
 function signNumber(x) {
   return (0, _number.sign)(x);
 }
@@ -401,16 +383,20 @@ powNumber.signature = n2;
 
 function roundNumber(value) {
   var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+  if (!(0, _number.isInteger)(decimals) || decimals < 0 || decimals > 15) {
+    throw new Error('Number of decimals in function round must be an integer from 0 to 15 inclusive');
+  }
+
   return parseFloat((0, _number.toFixed)(value, decimals));
 }
-
-roundNumber.signature = n2;
 /**
  * Calculate the norm of a number, the absolute value.
  * @param {number} x
  * @return {number}
  */
 
+
 function normNumber(x) {
   return Math.abs(x);
 }

package/lib/cjs/plain/number/combinations.js

@@ -23,15 +23,27 @@ function combinationsNumber(n, k) {
   }
 
   var nMinusk = n - k;
-  var prodrange;
+  var answer = 1;
+  var firstnumerator = k < nMinusk ? nMinusk + 1 : k + 1;
+  var nextdivisor = 2;
+  var lastdivisor = k < nMinusk ? k : nMinusk; // balance multiplications and divisions to try to keep intermediate values
+  // in exact-integer range as long as possible
 
-  if (k < nMinusk) {
-    prodrange = (0, _product.product)(nMinusk + 1, n);
-    return prodrange / (0, _product.product)(1, k);
+  for (var nextnumerator = firstnumerator; nextnumerator <= n; ++nextnumerator) {
+    answer *= nextnumerator;
+
+    while (nextdivisor <= lastdivisor && answer % nextdivisor === 0) {
+      answer /= nextdivisor;
+      ++nextdivisor;
+    }
+  } // for big n, k, floating point may have caused weirdness in remainder
+
+
+  if (nextdivisor <= lastdivisor) {
+    answer /= (0, _product.product)(nextdivisor, lastdivisor);
   }
 
-  prodrange = (0, _product.product)(k + 1, n);
-  return prodrange / (0, _product.product)(1, nMinusk);
+  return answer;
 }
 
 combinationsNumber.signature = 'number, number';

package/lib/cjs/plain/number/probability.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.gammaG = void 0;
 exports.gammaNumber = gammaNumber;
-exports.gammaP = void 0;
+exports.lgammaN = exports.lgammaG = exports.gammaP = void 0;
+exports.lgammaNumber = lgammaNumber;
+exports.lnSqrt2PI = exports.lgammaSeries = void 0;
 
 var _number = require("../../utils/number.js");
 
@@ -59,5 +61,43 @@ gammaNumber.signature = 'number'; // TODO: comment on the variables g and p
 
 var gammaG = 4.7421875;
 exports.gammaG = gammaG;
-var gammaP = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5];
-exports.gammaP = gammaP;
+var gammaP = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5]; // lgamma implementation ref: https://mrob.com/pub/ries/lanczos-gamma.html#code
+// log(2 * pi) / 2
+
+exports.gammaP = gammaP;
+var lnSqrt2PI = 0.91893853320467274178;
+exports.lnSqrt2PI = lnSqrt2PI;
+var lgammaG = 5; // Lanczos parameter "g"
+
+exports.lgammaG = lgammaG;
+var lgammaN = 7; // Range of coefficients "n"
+
+exports.lgammaN = lgammaN;
+var lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5];
+exports.lgammaSeries = lgammaSeries;
+
+function lgammaNumber(n) {
+  if (n < 0) return NaN;
+  if (n === 0) return Infinity;
+  if (!isFinite(n)) return n;
+
+  if (n < 0.5) {
+    // Use Euler's reflection formula:
+    // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))
+    return Math.log(Math.PI / Math.sin(Math.PI * n)) - lgammaNumber(1 - n);
+  } // Compute the logarithm of the Gamma function using the Lanczos method
+
+
+  n = n - 1;
+  var base = n + lgammaG + 0.5; // Base of the Lanczos exponential
+
+  var sum = lgammaSeries[0]; // We start with the terms that have the smallest coefficients and largest denominator
+
+  for (var i = lgammaN - 1; i >= 1; i--) {
+    sum += lgammaSeries[i] / (n + i);
+  }
+
+  return lnSqrt2PI + (n + 0.5) * Math.log(base) - base + Math.log(sum);
+}
+
+lgammaNumber.signature = 'number';

package/lib/cjs/type/bignumber/BigNumber.js

@@ -17,9 +17,9 @@ var createBigNumberClass = /* #__PURE__ */(0, _factory.factory)(name, dependenci
   var on = _ref.on,
       config = _ref.config;
 
-  var BigNumber = _decimal["default"].clone({
+  var BigNumber = _decimal.default.clone({
     precision: config.precision,
-    modulo: _decimal["default"].EUCLID
+    modulo: _decimal.default.EUCLID
   });
 
   BigNumber.prototype = Object.create(BigNumber.prototype);

package/lib/cjs/type/bignumber/function/bignumber.js

@@ -79,7 +79,7 @@ var createBignumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     Fraction: function Fraction(x) {
       return new BigNumber(x.n).div(x.d).times(x.s);
     },
-    "null": function _null(x) {
+    null: function _null(x) {
       return new BigNumber(0);
     },
     'Array | Matrix': function ArrayMatrix(x) {

package/lib/cjs/type/boolean.js

@@ -45,13 +45,13 @@ var createBoolean = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
     '': function _() {
       return false;
     },
-    "boolean": function boolean(x) {
+    boolean: function boolean(x) {
       return x;
     },
     number: function number(x) {
       return !!x;
     },
-    "null": function _null(x) {
+    null: function _null(x) {
       return false;
     },
     BigNumber: function BigNumber(x) {

package/lib/cjs/type/complex/Complex.js

@@ -23,15 +23,15 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
   /**
    * Attach type information
    */
-  _complex["default"].prototype.type = 'Complex';
-  _complex["default"].prototype.isComplex = true;
+  _complex.default.prototype.type = 'Complex';
+  _complex.default.prototype.isComplex = true;
   /**
    * Get a JSON representation of the complex number
    * @returns {Object} Returns a JSON object structured as:
    *                   `{"mathjs": "Complex", "re": 2, "im": 3}`
    */
 
-  _complex["default"].prototype.toJSON = function () {
+  _complex.default.prototype.toJSON = function () {
     return {
       mathjs: 'Complex',
       re: this.re,
@@ -45,7 +45,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex["default"].prototype.toPolar = function () {
+  _complex.default.prototype.toPolar = function () {
     return {
       r: this.abs(),
       phi: this.arg()
@@ -62,7 +62,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex["default"].prototype.format = function (options) {
+  _complex.default.prototype.format = function (options) {
     var str = '';
     var im = this.im;
     var re = this.re;
@@ -127,14 +127,14 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex["default"].fromPolar = function (args) {
+  _complex.default.fromPolar = function (args) {
     switch (arguments.length) {
       case 1:
         {
           var arg = arguments[0];
 
-          if ((0, _typeof2["default"])(arg) === 'object') {
-            return (0, _complex["default"])(arg);
+          if ((0, _typeof2.default)(arg) === 'object') {
+            return (0, _complex.default)(arg);
           } else {
             throw new TypeError('Input has to be an object with r and phi keys.');
           }
@@ -152,7 +152,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             }
 
             if ((0, _is.isNumber)(phi)) {
-              return new _complex["default"]({
+              return new _complex.default({
                 r: r,
                 phi: phi
               });
@@ -169,7 +169,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     }
   };
 
-  _complex["default"].prototype.valueOf = _complex["default"].prototype.toString;
+  _complex.default.prototype.valueOf = _complex.default.prototype.toString;
   /**
    * Create a Complex number from a JSON object
    * @param {Object} json  A JSON Object structured as
@@ -179,8 +179,8 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    * @return {Complex} Returns a new Complex number
    */
 
-  _complex["default"].fromJSON = function (json) {
-    return new _complex["default"](json);
+  _complex.default.fromJSON = function (json) {
+    return new _complex.default(json);
   };
   /**
    * Compare two complex numbers, `a` and `b`:
@@ -199,7 +199,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex["default"].compare = function (a, b) {
+  _complex.default.compare = function (a, b) {
     if (a.re > b.re) {
       return 1;
     }
@@ -219,7 +219,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     return 0;
   };
 
-  return _complex["default"];
+  return _complex.default;
 }, {
   isClass: true
 });

package/lib/cjs/type/complex/function/complex.js

@@ -76,7 +76,7 @@ var createComplex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
     string: function string(x) {
       return Complex(x); // for example '2 + 3i'
     },
-    "null": function _null(x) {
+    null: function _null(x) {
       return Complex(0);
     },
     Object: function Object(x) {

package/lib/cjs/type/fraction/Fraction.js

@@ -17,15 +17,15 @@ var createFractionClass = /* #__PURE__ */(0, _factory.factory)(name, dependencie
   /**
    * Attach type information
    */
-  _fraction["default"].prototype.type = 'Fraction';
-  _fraction["default"].prototype.isFraction = true;
+  _fraction.default.prototype.type = 'Fraction';
+  _fraction.default.prototype.isFraction = true;
   /**
    * Get a JSON representation of a Fraction containing type information
    * @returns {Object} Returns a JSON object structured as:
    *                   `{"mathjs": "Fraction", "n": 3, "d": 8}`
    */
 
-  _fraction["default"].prototype.toJSON = function () {
+  _fraction.default.prototype.toJSON = function () {
     return {
       mathjs: 'Fraction',
       n: this.s * this.n,
@@ -40,11 +40,11 @@ var createFractionClass = /* #__PURE__ */(0, _factory.factory)(name, dependencie
    */
 
 
-  _fraction["default"].fromJSON = function (json) {
-    return new _fraction["default"](json);
+  _fraction.default.fromJSON = function (json) {
+    return new _fraction.default(json);
   };
 
-  return _fraction["default"];
+  return _fraction.default;
 }, {
   isClass: true
 });

package/lib/cjs/type/fraction/function/fraction.js

@@ -16,27 +16,39 @@ var createFraction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       Fraction = _ref.Fraction;
 
   /**
-   * Create a fraction convert a value to a fraction.
+   * Create a fraction or convert a value to a fraction.
+   *
+   * With one numeric argument, produces the closest rational approximation to the
+   * input.
+   * With two arguments, the first is the numerator and the second is the denominator,
+   * and creates the corresponding fraction. Both numerator and denominator must be
+   * integers.
+   * With one object argument, looks for the integer numerator as the value of property
+   * 'n' and the integer denominator as the value of property 'd'.
+   * With a matrix argument, creates a matrix of the same shape with entries
+   * converted into fractions.
    *
    * Syntax:
+   *     math.fraction(value)
    *     math.fraction(numerator, denominator)
    *     math.fraction({n: numerator, d: denominator})
-   *     math.fraction(matrix: Array | Matrix)         Turn all matrix entries
-   *                                                   into fractions
+   *     math.fraction(matrix: Array | Matrix)
    *
    * Examples:
    *
-   *     math.fraction(1, 3)
-   *     math.fraction('2/3')
-   *     math.fraction({n: 2, d: 3})
-   *     math.fraction([0.2, 0.25, 1.25])
+   *     math.fraction(6.283)             // returns Fraction 6283/1000
+   *     math.fraction(1, 3)              // returns Fraction 1/3
+   *     math.fraction('2/3')             // returns Fraction 2/3
+   *     math.fraction({n: 2, d: 3})      // returns Fraction 2/3
+   *     math.fraction([0.2, 0.25, 1.25]) // returns Array [1/5, 1/4, 5/4]
+   *     math.fraction(4, 5.1)            // throws Error: Parameters must be integer
    *
    * See also:
    *
    *    bignumber, number, string, unit
    *
    * @param {number | string | Fraction | BigNumber | Array | Matrix} [args]
-   *            Arguments specifying the numerator and denominator of
+   *            Arguments specifying the value, or numerator and denominator of
    *            the fraction
    * @return {Fraction | Array | Matrix} Returns a fraction
    */
@@ -54,7 +66,7 @@ var createFraction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     'number, number': function numberNumber(numerator, denominator) {
       return new Fraction(numerator, denominator);
     },
-    "null": function _null(x) {
+    null: function _null(x) {
       return new Fraction(0);
     },
     BigNumber: function BigNumber(x) {