mathjs 10.0.0 → 10.6.4

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

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createFloor = void 0;
+exports.createFloorNumber = exports.createFloor = void 0;
 
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
@@ -21,23 +21,71 @@ var _nearlyEqual = require("../../utils/bignumber/nearlyEqual.js");
 
 var _algorithm = require("../../type/matrix/utils/algorithm11.js");
 
-var _algorithm2 = require("../../type/matrix/utils/algorithm14.js");
+var _algorithm2 = require("../../type/matrix/utils/algorithm12.js");
+
+var _algorithm3 = require("../../type/matrix/utils/algorithm14.js");
 
 var name = 'floor';
-var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
-var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+var createFloorNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', 'round'], function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
-      round = _ref.round,
-      matrix = _ref.matrix,
-      equalScalar = _ref.equalScalar;
+      round = _ref.round;
+  return typed(name, {
+    number: function number(x) {
+      if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.floor(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var _split = "".concat(x, "e").split('e'),
+            _split2 = (0, _slicedToArray2.default)(_split, 2),
+            number = _split2[0],
+            exponent = _split2[1];
+
+        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
+
+        var _split3 = "".concat(result, "e").split('e');
+
+        var _split4 = (0, _slicedToArray2.default)(_split3, 2);
+
+        number = _split4[0];
+        exponent = _split4[1];
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+exports.createFloorNumber = createFloorNumber;
+var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref2) {
+  var typed = _ref2.typed,
+      config = _ref2.config,
+      round = _ref2.round,
+      matrix = _ref2.matrix,
+      equalScalar = _ref2.equalScalar,
+      zeros = _ref2.zeros,
+      DenseMatrix = _ref2.DenseMatrix;
   var algorithm11 = (0, _algorithm.createAlgorithm11)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm14 = (0, _algorithm2.createAlgorithm14)({
+  var algorithm12 = (0, _algorithm2.createAlgorithm12)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var algorithm14 = (0, _algorithm3.createAlgorithm14)({
     typed: typed
   });
+  var floorNumber = createFloorNumber({
+    typed: typed,
+    config: config,
+    round: round
+  });
   /**
    * Round a value towards minus infinity.
    * For matrices, the function is evaluated element wise.
@@ -66,6 +114,10 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
    *    math.floor([3.21, 3.82, -4.71], 1)  // returns Array [3.2, 3.8, -4.8]
    *
+   *    math.floor(math.tau, [2, 3])  // returns Array [6.28, 6.283]
+   *
+   *    // Note that floor(array, array) currently not implemented.
+   *
    * See also:
    *
    *    ceil, fix, round
@@ -76,39 +128,17 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    */
 
   return typed('floor', {
-    number: function number(x) {
-      if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
-        return round(x);
-      } else {
-        return Math.floor(x);
-      }
-    },
-    'number, number': function numberNumber(x, n) {
-      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
-        return round(x, n);
-      } else {
-        var _$split = "".concat(x, "e").split('e'),
-            _$split2 = (0, _slicedToArray2["default"])(_$split, 2),
-            number = _$split2[0],
-            exponent = _$split2[1];
-
-        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
-
-        var _$split3 = "".concat(result, "e").split('e');
-
-        var _$split4 = (0, _slicedToArray2["default"])(_$split3, 2);
-
-        number = _$split4[0];
-        exponent = _$split4[1];
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
-      }
-    },
+    number: floorNumber.signatures.number,
+    'number,number': floorNumber.signatures['number,number'],
     Complex: function Complex(x) {
       return x.floor();
     },
     'Complex, number': function ComplexNumber(x, n) {
       return x.floor(n);
     },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
     BigNumber: function BigNumber(x) {
       if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.epsilon)) {
         return round(x);
@@ -120,7 +150,7 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
       if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
         return round(x, n);
       } else {
-        return x.toDecimalPlaces(n.toNumber(), _decimal["default"].ROUND_FLOOR);
+        return x.toDecimalPlaces(n.toNumber(), _decimal.default.ROUND_FLOOR);
       }
     },
     Fraction: function Fraction(x) {
@@ -129,11 +159,14 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     'Fraction, number': function FractionNumber(x, n) {
       return x.floor(n);
     },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since floor(0) = 0
       return (0, _collection.deepMap)(x, this, true);
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
       var _this = this;
 
       // deep map collection, skip zeros since ceil(0) = 0
@@ -147,9 +180,18 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
       return algorithm14(x, y, this, false);
     },
-    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
+    },
+    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+
+      if (y.storage() === 'dense') {
+        return algorithm14(y, x, this, true);
+      }
+
+      return algorithm12(y, x, this, true);
     }
   });
 });

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

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInvmod = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'invmod';
+var dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
+var createInvmod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      config = _ref.config,
+      BigNumber = _ref.BigNumber,
+      xgcd = _ref.xgcd,
+      equal = _ref.equal,
+      smaller = _ref.smaller,
+      mod = _ref.mod,
+      add = _ref.add,
+      isInteger = _ref.isInteger;
+
+  /**
+   * Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation `ax ≣ 1 (mod b)`
+   * See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse.
+   *
+   * Syntax:
+   *
+   *    math.invmod(a, b)
+   *
+   * Examples:
+   *
+   *    math.invmod(8, 12)             // returns NaN
+   *    math.invmod(7, 13)             // return 2
+   *    math.invmod(15151, 15122)      // returns 10429
+   *
+   * See also:
+   *
+   *    gcd, xgcd
+   *
+   * @param {number | BigNumber} a  An integer number
+   * @param {number | BigNumber} b  An integer number
+   * @return {number | BigNumber }  Returns an integer number
+   *                              where `invmod(a,b)*a ≣ 1 (mod b)`
+   */
+  return typed(name, {
+    'number, number': invmod,
+    'BigNumber, BigNumber': invmod
+  });
+
+  function invmod(a, b) {
+    if (!isInteger(a) || !isInteger(b)) throw new Error('Parameters in function invmod must be integer numbers');
+    a = mod(a, b);
+    if (equal(b, 0)) throw new Error('Divisor must be non zero');
+    var res = xgcd(a, b);
+    res = res.valueOf();
+
+    var _res = res,
+        _res2 = (0, _slicedToArray2.default)(_res, 2),
+        gcd = _res2[0],
+        inv = _res2[1];
+
+    if (!equal(gcd, BigNumber(1))) return NaN;
+    inv = mod(inv, b);
+    if (smaller(inv, BigNumber(0))) inv = add(inv, b);
+    return inv;
+  }
+});
+exports.createInvmod = createInvmod;

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

@@ -71,7 +71,7 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       // norm(x) = abs(x)
       return x.abs();
     },
-    "boolean": function boolean(x) {
+    boolean: function boolean(x) {
       // norm(x) = abs(x)
       return Math.abs(x);
     },

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

@@ -81,9 +81,7 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
 
   var complexErr = '' + 'Complex number not supported in function nthRoot. ' + 'Use nthRoots instead.';
   return typed(name, {
-    number: function number(x) {
-      return (0, _index.nthRootNumber)(x, 2);
-    },
+    number: _index.nthRootNumber,
     'number, number': _index.nthRootNumber,
     BigNumber: function BigNumber(x) {
       return _bigNthRoot(x, new _BigNumber(2));

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

@@ -14,21 +14,25 @@ var _array = require("../../utils/array.js");
 var _index = require("../../plain/number/index.js");
 
 var name = 'pow';
-var dependencies = ['typed', 'config', 'identity', 'multiply', 'matrix', 'fraction', 'number', 'Complex'];
+var dependencies = ['typed', 'config', 'identity', 'multiply', 'matrix', 'inv', 'fraction', 'number', 'Complex'];
 var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
       identity = _ref.identity,
       multiply = _ref.multiply,
       matrix = _ref.matrix,
+      inv = _ref.inv,
       number = _ref.number,
       fraction = _ref.fraction,
       Complex = _ref.Complex;
 
   /**
    * Calculates the power of x to y, `x ^ y`.
-   * Matrix exponentiation is supported for square matrices `x`, and positive
-   * integer exponents `y`.
+   *
+   * Matrix exponentiation is supported for square matrices `x` and integers `y`:
+   * when `y` is nonnegative, `x` may be any square matrix; and when `y` is
+   * negative, `x` must be invertible, and then this function returns
+   * inv(x)^(-y).
    *
    * For cubic roots of negative numbers, the function returns the principal
    * root by default. In order to let the function return the real root,
@@ -49,6 +53,9 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *    const b = [[1, 2], [4, 3]]
    *    math.pow(b, 2)               // returns Array [[9, 8], [16, 17]]
    *
+   *    const c = [[1, 2], [4, 3]]
+   *    math.pow(c, -1)               // returns Array [[-0.6, 0.4], [0.8, -0.2]]
+   *
    * See also:
    *
    *    multiply, sqrt, cbrt, nthRoot
@@ -144,15 +151,15 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
   /**
    * Calculate the power of a 2d array
    * @param {Array} x     must be a 2 dimensional, square matrix
-   * @param {number} y    a positive, integer value
+   * @param {number} y    a integer value (positive if `x` is not invertible)
    * @returns {Array}
    * @private
    */
 
 
   function _powArray(x, y) {
-    if (!(0, _number.isInteger)(y) || y < 0) {
-      throw new TypeError('For A^b, b must be a positive integer (value is ' + y + ')');
+    if (!(0, _number.isInteger)(y)) {
+      throw new TypeError('For A^b, b must be an integer (value is ' + y + ')');
     } // verify that A is a 2 dimensional square matrix
 
 
@@ -166,6 +173,18 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
       throw new Error('For A^b, A must be square (size is ' + s[0] + 'x' + s[1] + ')');
     }
 
+    if (y < 0) {
+      try {
+        return _powArray(inv(x), -y);
+      } catch (error) {
+        if (error.message === 'Cannot calculate inverse, determinant is zero') {
+          throw new TypeError('For A^b, when A is not invertible, b must be a positive integer (value is ' + y + ')');
+        }
+
+        throw error;
+      }
+    }
+
     var res = identity(s[0]).valueOf();
     var px = x;
 

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

@@ -1,20 +1,14 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createRoundNumber = exports.createRound = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+exports.createRound = void 0;
 
 var _factory = require("../../utils/factory.js");
 
 var _collection = require("../../utils/collection.js");
 
-var _number = require("../../utils/number.js");
-
 var _algorithm = require("../../type/matrix/utils/algorithm11.js");
 
 var _algorithm2 = require("../../type/matrix/utils/algorithm12.js");
@@ -23,10 +17,6 @@ var _algorithm3 = require("../../type/matrix/utils/algorithm14.js");
 
 var _index = require("../../plain/number/index.js");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
 var NO_INT = 'Number of decimals in function round must be an integer';
 var name = 'round';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix'];
@@ -84,7 +74,16 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
 
-  return typed(name, _objectSpread(_objectSpread({}, roundNumberSignatures), {}, {
+  return typed(name, {
+    number: _index.roundNumber,
+    'number, number': _index.roundNumber,
+    'number, BigNumber': function numberBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+
+      return new BigNumber(x).toDecimalPlaces(n.toNumber());
+    },
     Complex: function Complex(x) {
       return x.round();
     },
@@ -104,13 +103,6 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       return x.round(_n);
     },
-    'number, BigNumber': function numberBigNumber(x, n) {
-      if (!n.isInteger()) {
-        throw new TypeError(NO_INT);
-      }
-
-      return new BigNumber(x).toDecimalPlaces(n.toNumber());
-    },
     BigNumber: function BigNumber(x) {
       return x.toDecimalPlaces(0);
     },
@@ -131,6 +123,13 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       return x.round(n);
     },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+
+      return x.round(n.toNumber());
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since round(0) = 0
       return (0, _collection.deepMap)(x, this, true);
@@ -141,7 +140,11 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
       return algorithm14(x, y, this, false);
     },
-    'number | Complex | BigNumber, SparseMatrix': function numberComplexBigNumberSparseMatrix(x, y) {
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(x), y, this, false).valueOf();
+    },
+    'number | Complex | BigNumber | Fraction, SparseMatrix': function numberComplexBigNumberFractionSparseMatrix(x, y) {
       // check scalar is zero
       if (equalScalar(x, 0)) {
         // do not execute algorithm, result will be a zero matrix
@@ -150,7 +153,7 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       return algorithm12(y, x, this, true);
     },
-    'number | Complex | BigNumber, DenseMatrix': function numberComplexBigNumberDenseMatrix(x, y) {
+    'number | Complex | BigNumber | Fraction, DenseMatrix': function numberComplexBigNumberFractionDenseMatrix(x, y) {
       // check scalar is zero
       if (equalScalar(x, 0)) {
         // do not execute algorithm, result will be a zero matrix
@@ -159,33 +162,10 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       return algorithm14(y, x, this, true);
     },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | BigNumber | Fraction, Array': function numberComplexBigNumberFractionArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
     }
-  }));
-});
-exports.createRound = createRound;
-var roundNumberSignatures = {
-  number: _index.roundNumber,
-  'number, number': function numberNumber(x, n) {
-    if (!(0, _number.isInteger)(n)) {
-      throw new TypeError(NO_INT);
-    }
-
-    if (n < 0 || n > 15) {
-      throw new Error('Number of decimals in function round must be in the range of 0-15');
-    }
-
-    return (0, _index.roundNumber)(x, n);
-  }
-};
-var createRoundNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed'], function (_ref2) {
-  var typed = _ref2.typed;
-  return typed(name, roundNumberSignatures);
+  });
 });
-exports.createRoundNumber = createRoundNumber;
+exports.createRound = createRound;

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

@@ -65,6 +65,10 @@ var createSign = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       return (0, _collection.deepMap)(x, this, true);
     },
     Unit: function Unit(x) {
+      if (!x._isDerived() && x.units[0].unit.offset !== 0) {
+        throw new TypeError('sign is ambiguous for units with offset');
+      }
+
       return this(x.value);
     }
   });

package/lib/cjs/function/combinatorics/stirlingS2.js

@@ -7,8 +7,10 @@ exports.createStirlingS2 = void 0;
 
 var _factory = require("../../utils/factory.js");
 
+var _is = require("../../utils/is.js");
+
 var name = 'stirlingS2';
-var dependencies = ['typed', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'factorial', 'combinations', 'isNegative', 'isInteger', 'larger'];
+var dependencies = ['typed', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'factorial', 'combinations', 'isNegative', 'isInteger', 'number', '?bignumber', 'larger'];
 var createStirlingS2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       addScalar = _ref.addScalar,
@@ -20,15 +22,22 @@ var createStirlingS2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       combinations = _ref.combinations,
       isNegative = _ref.isNegative,
       isInteger = _ref.isInteger,
+      number = _ref.number,
+      bignumber = _ref.bignumber,
       larger = _ref.larger;
-
+  var smallCache = [];
+  var bigCache = [];
   /**
    * The Stirling numbers of the second kind, counts the number of ways to partition
    * a set of n labelled objects into k nonempty unlabelled subsets.
    * stirlingS2 only takes integer arguments.
    * The following condition must be enforced: k <= n.
    *
-   *  If n = k or k = 1, then s(n,k) = 1
+   *  If n = k or k = 1 <= n, then s(n,k) = 1
+   *  If k = 0 < n, then s(n,k) = 0
+   *
+   * Note that if either n or k is supplied as a BigNumber, the result will be
+   * as well.
    *
    * Syntax:
    *
@@ -46,26 +55,47 @@ var createStirlingS2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    * @param {Number | BigNumber} k    Number of objects in the subset
    * @return {Number | BigNumber}     S(n,k)
    */
+
   return typed(name, {
     'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, k) {
       if (!isInteger(n) || isNegative(n) || !isInteger(k) || isNegative(k)) {
         throw new TypeError('Non-negative integer value expected in function stirlingS2');
       } else if (larger(k, n)) {
         throw new TypeError('k must be less than or equal to n in function stirlingS2');
-      } // 1/k! Sum(i=0 -> k) [(-1)^(k-i)*C(k,j)* i^n]
+      }
+
+      var big = !((0, _is.isNumber)(n) && (0, _is.isNumber)(k));
+      var cache = big ? bigCache : smallCache;
+      var make = big ? bignumber : number;
+      var nn = number(n);
+      var nk = number(k);
+      /* See if we already have the value: */
+
+      if (cache[nn] && cache[nn].length > nk) {
+        return cache[nn][nk];
+      }
+      /* Fill the cache */
+
 
+      for (var m = 0; m <= nn; ++m) {
+        if (!cache[m]) {
+          cache[m] = [m === 0 ? make(1) : make(0)];
+        }
 
-      var kFactorial = factorial(k);
-      var result = 0;
+        if (m === 0) continue;
+        var row = cache[m];
+        var prev = cache[m - 1];
 
-      for (var i = 0; i <= k; i++) {
-        var negativeOne = pow(-1, subtract(k, i));
-        var kChooseI = combinations(k, i);
-        var iPower = pow(i, n);
-        result = addScalar(result, multiplyScalar(multiplyScalar(kChooseI, iPower), negativeOne));
+        for (var i = row.length; i <= m && i <= nk; ++i) {
+          if (i === m) {
+            row[i] = 1;
+          } else {
+            row[i] = addScalar(multiplyScalar(make(i), prev[i]), prev[i - 1]);
+          }
+        }
       }
 
-      return divideScalar(result, kFactorial);
+      return cache[nn][nk];
     }
   });
 });

package/lib/cjs/function/geometry/intersect.js

@@ -5,12 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createIntersect = void 0;
 
-var _is = require("../../utils/is.js");
-
 var _factory = require("../../utils/factory.js");
 
 var name = 'intersect';
-var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten'];
+var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten', 'isZero', 'isNumeric'];
 var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
@@ -24,7 +22,9 @@ var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       subtract = _ref.subtract,
       smaller = _ref.smaller,
       equalScalar = _ref.equalScalar,
-      flatten = _ref.flatten;
+      flatten = _ref.flatten,
+      isZero = _ref.isZero,
+      isNumeric = _ref.isNumeric;
 
   /**
    * Calculates the point of intersection of two lines in two or three dimensions
@@ -151,21 +151,16 @@ var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     return arr;
   }
 
-  function _isNumeric(a) {
-    // intersect supports numbers and bignumbers
-    return typeof a === 'number' || (0, _is.isBigNumber)(a);
-  }
-
   function _2d(x) {
-    return x.length === 2 && _isNumeric(x[0]) && _isNumeric(x[1]);
+    return x.length === 2 && isNumeric(x[0]) && isNumeric(x[1]);
   }
 
   function _3d(x) {
-    return x.length === 3 && _isNumeric(x[0]) && _isNumeric(x[1]) && _isNumeric(x[2]);
+    return x.length === 3 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]);
   }
 
   function _4d(x) {
-    return x.length === 4 && _isNumeric(x[0]) && _isNumeric(x[1]) && _isNumeric(x[2]) && _isNumeric(x[3]);
+    return x.length === 4 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]) && isNumeric(x[3]);
   }
 
   function _intersect2d(p1a, p1b, p2a, p2b) {
@@ -174,6 +169,7 @@ var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     var d1 = subtract(o1, p1b);
     var d2 = subtract(o2, p2b);
     var det = subtract(multiplyScalar(d1[0], d2[1]), multiplyScalar(d2[0], d1[1]));
+    if (isZero(det)) return null;
 
     if (smaller(abs(det), config.epsilon)) {
       return null;
@@ -206,7 +202,10 @@ var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
 
     var d2121 = _intersect3dHelper(x2, x1, x2, x1, y2, y1, y2, y1, z2, z1, z2, z1);
 
-    var ta = divideScalar(subtract(multiplyScalar(d1343, d4321), multiplyScalar(d1321, d4343)), subtract(multiplyScalar(d2121, d4343), multiplyScalar(d4321, d4321)));
+    var numerator = subtract(multiplyScalar(d1343, d4321), multiplyScalar(d1321, d4343));
+    var denominator = subtract(multiplyScalar(d2121, d4343), multiplyScalar(d4321, d4321));
+    if (isZero(denominator)) return null;
+    var ta = divideScalar(numerator, denominator);
     var tb = divideScalar(addScalar(d1343, multiplyScalar(ta, d4321)), d4343);
     var pax = addScalar(x1, multiplyScalar(ta, subtract(x2, x1)));
     var pay = addScalar(y1, multiplyScalar(ta, subtract(y2, y1)));