mathjs 10.0.0 → 10.6.4

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

@@ -4,24 +4,62 @@ import { deepMap } from '../../utils/collection.js';
 import { nearlyEqual } from '../../utils/number.js';
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
 import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
+import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
 import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
 var name = 'floor';
-var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
-export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
+  var {
+    typed,
+    config,
+    round
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      if (nearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.floor(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var [number, exponent] = "".concat(x, "e").split('e');
+        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        [number, exponent] = "".concat(result, "e").split('e');
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
   var {
     typed,
     config,
     round,
     matrix,
-    equalScalar
-  } = _ref;
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
   var algorithm11 = createAlgorithm11({
     typed,
     equalScalar
   });
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
   var algorithm14 = createAlgorithm14({
     typed
   });
+  var floorNumber = createFloorNumber({
+    typed,
+    config,
+    round
+  });
   /**
    * Round a value towards minus infinity.
    * For matrices, the function is evaluated element wise.
@@ -50,6 +88,10 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    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
@@ -60,29 +102,17 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed('floor', {
-    number: function number(x) {
-      if (nearlyEqual(x, round(x), config.epsilon)) {
-        return round(x);
-      } else {
-        return Math.floor(x);
-      }
-    },
-    'number, number': function numberNumber(x, n) {
-      if (nearlyEqual(x, round(x, n), config.epsilon)) {
-        return round(x, n);
-      } else {
-        var [number, exponent] = "".concat(x, "e").split('e');
-        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        [number, exponent] = "".concat(result, "e").split('e');
-        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 (bigNearlyEqual(x, round(x), config.epsilon)) {
         return round(x);
@@ -103,11 +133,14 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
     '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 deepMap(x, this, true);
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
       // deep map collection, skip zeros since ceil(0) = 0
       return deepMap(x, i => this(i, n), true);
     },
@@ -117,9 +150,18 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
     '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/esm/function/arithmetic/invmod.js

@@ -0,0 +1,57 @@
+import { factory } from '../../utils/factory.js';
+var name = 'invmod';
+var dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
+export var createInvmod = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    BigNumber,
+    xgcd,
+    equal,
+    smaller,
+    mod,
+    add,
+    isInteger
+  } = _ref;
+
+  /**
+   * 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 [gcd, inv] = res;
+    if (!equal(gcd, BigNumber(1))) return NaN;
+    inv = mod(inv, b);
+    if (smaller(inv, BigNumber(0))) inv = add(inv, b);
+    return inv;
+  }
+});

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

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

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

@@ -67,7 +67,7 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
 
       roots.push(new Complex({
-        r: r,
+        r,
         phi: (arg + 2 * Math.PI * k) / root
       }));
     }

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

@@ -3,7 +3,7 @@ import { isInteger } from '../../utils/number.js';
 import { arraySize as size } from '../../utils/array.js';
 import { powNumber } from '../../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'];
 export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -11,6 +11,7 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
     identity,
     multiply,
     matrix,
+    inv,
     number,
     fraction,
     Complex
@@ -18,8 +19,11 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   /**
    * 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,
@@ -40,6 +44,9 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    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
@@ -135,15 +142,15 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * 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 (!isInteger(y) || y < 0) {
-      throw new TypeError('For A^b, b must be a positive integer (value is ' + y + ')');
+    if (!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
 
 
@@ -157,6 +164,18 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
       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/esm/function/arithmetic/round.js

@@ -1,12 +1,5 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
-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) { _defineProperty(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; }
-
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
-import { isInteger } from '../../utils/number.js';
 import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
 import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
 import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
@@ -70,7 +63,16 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
 
-  return typed(name, _objectSpread(_objectSpread({}, roundNumberSignatures), {}, {
+  return typed(name, {
+    number: roundNumber,
+    'number, number': 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();
     },
@@ -90,13 +92,6 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       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);
     },
@@ -117,6 +112,13 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       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 deepMap(x, this, true);
@@ -127,7 +129,11 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
     '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
@@ -136,7 +142,7 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       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
@@ -145,33 +151,9 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       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();
     }
-  }));
-});
-var roundNumberSignatures = {
-  number: roundNumber,
-  'number, number': function numberNumber(x, n) {
-    if (!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 roundNumber(x, n);
-  }
-};
-export var createRoundNumber = /* #__PURE__ */factory(name, ['typed'], _ref2 => {
-  var {
-    typed
-  } = _ref2;
-  return typed(name, roundNumberSignatures);
+  });
 });

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

@@ -57,6 +57,10 @@ export var createSign = /* #__PURE__ */factory(name, dependencies, _ref => {
       return 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/esm/function/combinatorics/stirlingS2.js

@@ -1,6 +1,7 @@
 import { factory } from '../../utils/factory.js';
+import { isNumber } from '../../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'];
 export var createStirlingS2 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -13,16 +14,23 @@ export var createStirlingS2 = /* #__PURE__ */factory(name, dependencies, _ref =>
     combinations,
     isNegative,
     isInteger,
+    number,
+    bignumber,
     larger
   } = _ref;
-
+  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:
    *
@@ -40,26 +48,47 @@ export var createStirlingS2 = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @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 = !(isNumber(n) && 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/esm/function/geometry/intersect.js

@@ -1,7 +1,6 @@
-import { isBigNumber } from '../../utils/is.js';
 import { factory } from '../../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'];
 export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -16,7 +15,9 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     subtract,
     smaller,
     equalScalar,
-    flatten
+    flatten,
+    isZero,
+    isNumeric
   } = _ref;
 
   /**
@@ -142,21 +143,16 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     return arr;
   }
 
-  function _isNumeric(a) {
-    // intersect supports numbers and bignumbers
-    return typeof a === 'number' || 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) {
@@ -165,6 +161,7 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     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;
@@ -197,7 +194,10 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
 
     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)));