mathjs 9.4.0 → 9.4.4

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

@@ -10,7 +10,7 @@ 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'];
+var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten'];
 var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
@@ -23,7 +23,8 @@ var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       divideScalar = _ref.divideScalar,
       subtract = _ref.subtract,
       smaller = _ref.smaller,
-      equalScalar = _ref.equalScalar;
+      equalScalar = _ref.equalScalar,
+      flatten = _ref.flatten;
 
   /**
    * Calculates the point of intersection of two lines in two or three dimensions
@@ -49,74 +50,106 @@ var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
    * @param  {Array | Matrix} y   Co-ordinates of first end-point of second line
    *                              OR Co-efficients of the plane's equation
    * @param  {Array | Matrix} z   Co-ordinates of second end-point of second line
-   *                              OR null if the calculation is for line and plane
+   *                              OR undefined if the calculation is for line and plane
    * @return {Array}              Returns the point of intersection of lines/lines-planes
    */
   return typed('intersect', {
-    'Array, Array, Array': function ArrayArrayArray(x, y, plane) {
-      if (!_3d(x)) {
+    'Array, Array, Array': _AAA,
+    'Array, Array, Array, Array': _AAAA,
+    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(x, y, plane) {
+      var arr = _AAA(x.valueOf(), y.valueOf(), plane.valueOf());
+
+      return arr === null ? null : matrix(arr);
+    },
+    'Matrix, Matrix, Matrix, Matrix': function MatrixMatrixMatrixMatrix(w, x, y, z) {
+      // TODO: output matrix type should match input matrix type
+      var arr = _AAAA(w.valueOf(), x.valueOf(), y.valueOf(), z.valueOf());
+
+      return arr === null ? null : matrix(arr);
+    }
+  });
+
+  function _AAA(x, y, plane) {
+    x = _coerceArr(x);
+    y = _coerceArr(y);
+    plane = _coerceArr(plane);
+
+    if (!_3d(x)) {
+      throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
+    }
+
+    if (!_3d(y)) {
+      throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
+    }
+
+    if (!_4d(plane)) {
+      throw new TypeError('Array with 4 numbers expected as third argument');
+    }
+
+    return _intersectLinePlane(x[0], x[1], x[2], y[0], y[1], y[2], plane[0], plane[1], plane[2], plane[3]);
+  }
+
+  function _AAAA(w, x, y, z) {
+    w = _coerceArr(w);
+    x = _coerceArr(x);
+    y = _coerceArr(y);
+    z = _coerceArr(z);
+
+    if (w.length === 2) {
+      if (!_2d(w)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for first argument');
+      }
+
+      if (!_2d(x)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for second argument');
+      }
+
+      if (!_2d(y)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for third argument');
+      }
+
+      if (!_2d(z)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for fourth argument');
+      }
+
+      return _intersect2d(w, x, y, z);
+    } else if (w.length === 3) {
+      if (!_3d(w)) {
         throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
       }
 
-      if (!_3d(y)) {
+      if (!_3d(x)) {
         throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
       }
 
-      if (!_4d(plane)) {
-        throw new TypeError('Array with 4 numbers expected as third argument');
+      if (!_3d(y)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for third argument');
       }
 
-      return _intersectLinePlane(x[0], x[1], x[2], y[0], y[1], y[2], plane[0], plane[1], plane[2], plane[3]);
-    },
-    'Array, Array, Array, Array': function ArrayArrayArrayArray(w, x, y, z) {
-      if (w.length === 2) {
-        if (!_2d(w)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for first argument');
-        }
-
-        if (!_2d(x)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for second argument');
-        }
-
-        if (!_2d(y)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for third argument');
-        }
-
-        if (!_2d(z)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for fourth argument');
-        }
-
-        return _intersect2d(w, x, y, z);
-      } else if (w.length === 3) {
-        if (!_3d(w)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
-        }
-
-        if (!_3d(x)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
-        }
-
-        if (!_3d(y)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for third argument');
-        }
-
-        if (!_3d(z)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for fourth argument');
-        }
-
-        return _intersect3d(w[0], w[1], w[2], x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
-      } else {
-        throw new TypeError('Arrays with two or thee dimensional points expected');
+      if (!_3d(z)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for fourth argument');
       }
-    },
-    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(x, y, plane) {
-      return matrix(this(x.valueOf(), y.valueOf(), plane.valueOf()));
-    },
-    'Matrix, Matrix, Matrix, Matrix': function MatrixMatrixMatrixMatrix(w, x, y, z) {
-      // TODO: output matrix type should match input matrix type
-      return matrix(this(w.valueOf(), x.valueOf(), y.valueOf(), z.valueOf()));
+
+      return _intersect3d(w[0], w[1], w[2], x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
+    } else {
+      throw new TypeError('Arrays with two or thee dimensional points expected');
     }
-  });
+  }
+  /** Coerce row and column 2-dim arrays to 1-dim array */
+
+
+  function _coerceArr(arr) {
+    // row matrix
+    if (arr.length === 1) return arr[0]; // column matrix
+
+    if (arr.length > 1 && Array.isArray(arr[0])) {
+      if (arr.every(function (el) {
+        return Array.isArray(el) && el.length === 1;
+      })) return flatten(arr);
+    }
+
+    return arr;
+  }
 
   function _isNumeric(a) {
     // intersect supports numbers and bignumbers
@@ -196,7 +229,9 @@ var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     var y2y = multiplyScalar(y2, y);
     var z1z = multiplyScalar(z1, z);
     var z2z = multiplyScalar(z2, z);
-    var t = divideScalar(subtract(subtract(subtract(c, x1x), y1y), z1z), subtract(subtract(subtract(addScalar(addScalar(x2x, y2y), z2z), x1x), y1y), z1z));
+    var numerator = subtract(subtract(subtract(c, x1x), y1y), z1z);
+    var denominator = subtract(subtract(subtract(addScalar(addScalar(x2x, y2y), z2z), x1x), y1y), z1z);
+    var t = divideScalar(numerator, denominator);
     var px = addScalar(x1, multiplyScalar(t, subtract(x2, x1)));
     var py = addScalar(y1, multiplyScalar(t, subtract(y2, y1)));
     var pz = addScalar(z1, multiplyScalar(t, subtract(z2, z1)));

package/lib/cjs/function/matrix/eigs/complexEigs.js

@@ -30,15 +30,14 @@ function createComplexEigs(_ref) {
       diag = _ref.diag,
       inv = _ref.inv,
       qr = _ref.qr,
+      usolve = _ref.usolve,
       usolveAll = _ref.usolveAll,
       equal = _ref.equal,
       complex = _ref.complex,
       larger = _ref.larger,
       smaller = _ref.smaller,
-      round = _ref.round,
-      log10 = _ref.log10,
-      transpose = _ref.transpose,
-      matrixFromColumns = _ref.matrixFromColumns;
+      matrixFromColumns = _ref.matrixFromColumns,
+      dot = _ref.dot;
 
   /**
    * @param {number[][]} arr the matrix to find eigenvalues of
@@ -80,7 +79,7 @@ function createComplexEigs(_ref) {
     var vectors;
 
     if (findVectors) {
-      vectors = findEigenvectors(arr, N, C, values, prec);
+      vectors = findEigenvectors(arr, N, C, values, prec, type);
       vectors = matrixFromColumns.apply(void 0, (0, _toConsumableArray2["default"])(vectors));
     }
 
@@ -415,13 +414,18 @@ function createComplexEigs(_ref) {
    * @param {number} N size of A
    * @param {Matrix} C column transformation matrix that turns A into upper triangular
    * @param {number[]} values array of eigenvalues of A
+   * @param {'number'|'BigNumber'|'Complex'} type
    * @returns {number[][]} eigenvalues
    */
 
 
-  function findEigenvectors(A, N, C, values, prec) {
+  function findEigenvectors(A, N, C, values, prec, type) {
     var Cinv = inv(C);
-    var U = multiply(Cinv, A, C); // turn values into a kind of "multiset"
+    var U = multiply(Cinv, A, C);
+    var big = type === 'BigNumber';
+    var cplx = type === 'Complex';
+    var zero = big ? bignumber(0) : cplx ? complex(0) : 0;
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1; // turn values into a kind of "multiset"
     // this way it is easier to find eigenvectors
 
     var uniqueValues = [];
@@ -437,11 +441,7 @@ function createComplexEigs(_ref) {
         var _i4 = indexOf(uniqueValues, _λ, equal);
 
         if (_i4 === -1) {
-          // a dirty trick that helps us find more vectors
-          // TODO with iterative algorithm this can be removed
-          // Note: the round around log10 is needed to prevent rounding off errors in IE
-          var rounded = round(_λ, subtract(-1, round(log10(prec))));
-          uniqueValues.push(rounded);
+          uniqueValues.push(_λ);
           multiplicities.push(1);
         } else {
           multiplicities[_i4] += 1;
@@ -458,22 +458,34 @@ function createComplexEigs(_ref) {
 
     var vectors = [];
     var len = uniqueValues.length;
-    var b = Array(N).fill(0);
-    var E = diag(Array(N).fill(1)); // eigenvalues for which usolve failed (due to numerical error)
+    var b = Array(N).fill(zero);
+    var E = diag(Array(N).fill(one)); // eigenvalues for which usolve failed (due to numerical error)
 
     var failedLambdas = [];
 
     for (var i = 0; i < len; i++) {
       var λ = uniqueValues[i];
-      var solutions = usolveAll(subtract(U, multiply(λ, E)), b);
+
+      var _A = subtract(U, multiply(λ, E)); // the characteristic matrix
+
+
+      var solutions = usolveAll(_A, b);
       solutions = solutions.map(function (v) {
         return multiply(C, v);
       });
       solutions.shift(); // ignore the null vector
-      // looks like we missed something
+      // looks like we missed something, try inverse iteration
+
+      while (solutions.length < multiplicities[i]) {
+        var approxVec = inverseIterate(_A, N, solutions, prec, type);
 
-      if (solutions.length < multiplicities[i]) {
-        failedLambdas.push(λ);
+        if (approxVec == null) {
+          // no more vectors were found
+          failedLambdas.push(λ);
+          break;
+        }
+
+        solutions.push(approxVec);
       }
 
       vectors.push.apply(vectors, (0, _toConsumableArray2["default"])(solutions.map(function (v) {
@@ -626,6 +638,144 @@ function createComplexEigs(_ref) {
 
     return -1;
   }
+  /**
+   * Provided a near-singular upper-triangular matrix A and a list of vectors,
+   * finds an eigenvector of A with the smallest eigenvalue, which is orthogonal
+   * to each vector in the list
+   * @template T
+   * @param {T[][]} A near-singular square matrix
+   * @param {number} N dimension
+   * @param {T[][]} orthog list of vectors
+   * @param {number} prec epsilon
+   * @param {'number'|'BigNumber'|'Complex'} type
+   * @return {T[] | null} eigenvector
+   *
+   * @see Numerical Recipes for Fortran 77 – 11.7 Eigenvalues or Eigenvectors by Inverse Iteration
+   */
+
+
+  function inverseIterate(A, N, orthog, prec, type) {
+    var largeNum = type === 'BigNumber' ? bignumber(1000) : 1000;
+    var b; // the vector
+    // you better choose a random vector before I count to five
+
+    var i = 0;
+
+    while (true) {
+      b = randomOrthogonalVector(N, orthog, type);
+      b = usolve(A, b);
+
+      if (larger(norm(b), largeNum)) {
+        break;
+      }
+
+      if (++i >= 5) {
+        return null;
+      }
+    } // you better converge before I count to ten
+
+
+    i = 0;
+
+    while (true) {
+      var c = usolve(A, b);
+
+      if (smaller(norm(orthogonalComplement(b, [c])), prec)) {
+        break;
+      }
+
+      if (++i >= 10) {
+        return null;
+      }
+
+      b = normalize(c);
+    }
+
+    return b;
+  }
+  /**
+   * Generates a random unit vector of dimension N, orthogonal to each vector in the list
+   * @template T
+   * @param {number} N dimension
+   * @param {T[][]} orthog list of vectors
+   * @param {'number'|'BigNumber'|'Complex'} type
+   * @returns {T[]} random vector
+   */
+
+
+  function randomOrthogonalVector(N, orthog, type) {
+    var big = type === 'BigNumber';
+    var cplx = type === 'Complex'; // generate random vector with the correct type
+
+    var v = Array(N).fill(0).map(function (_) {
+      return 2 * Math.random() - 1;
+    });
+
+    if (big) {
+      v = v.map(function (n) {
+        return bignumber(n);
+      });
+    }
+
+    if (cplx) {
+      v = v.map(function (n) {
+        return complex(n);
+      });
+    } // project to orthogonal complement
+
+
+    v = orthogonalComplement(v, orthog); // normalize
+
+    return normalize(v, type);
+  }
+  /**
+   * Project vector v to the orthogonal complement of an array of vectors
+   */
+
+
+  function orthogonalComplement(v, orthog) {
+    var _iterator3 = _createForOfIteratorHelper(orthog),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var w = _step3.value;
+        // v := v − (w, v)/∥w∥² w
+        v = subtract(v, multiply(divideScalar(dot(w, v), dot(w, w)), w));
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+
+    return v;
+  }
+  /**
+   * Calculate the norm of a vector.
+   * We can't use math.norm because factory can't handle circular dependency.
+   * Seriously, I'm really fed up with factory.
+   */
+
+
+  function norm(v) {
+    return abs(sqrt(dot(v, v)));
+  }
+  /**
+   * Normalize a vector
+   * @template T
+   * @param {T[]} v
+   * @param {'number'|'BigNumber'|'Complex'} type
+   * @returns {T[]} normalized vec
+   */
+
+
+  function normalize(v, type) {
+    var big = type === 'BigNumber';
+    var cplx = type === 'Complex';
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1;
+    return multiply(divideScalar(one, norm(v)), v);
+  }
 
   return complexEigs;
 }

package/lib/cjs/function/matrix/eigs.js

@@ -17,7 +17,7 @@ var _is = require("../../utils/is.js");
 
 var name = 'eigs'; // The absolute state of math.js's dependency system:
 
-var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'qr', 'usolveAll', 'im', 're', 'smaller', 'round', 'log10', 'transpose', 'matrixFromColumns'];
+var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'qr', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
 var createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var config = _ref.config,
       typed = _ref.typed,
@@ -43,14 +43,13 @@ var createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       sqrt = _ref.sqrt,
       diag = _ref.diag,
       qr = _ref.qr,
+      usolve = _ref.usolve,
       usolveAll = _ref.usolveAll,
       im = _ref.im,
       re = _ref.re,
       smaller = _ref.smaller,
-      round = _ref.round,
-      log10 = _ref.log10,
-      transpose = _ref.transpose,
-      matrixFromColumns = _ref.matrixFromColumns;
+      matrixFromColumns = _ref.matrixFromColumns,
+      dot = _ref.dot;
   var doRealSymetric = (0, _realSymetric.createRealSymmetric)({
     config: config,
     addScalar: addScalar,
@@ -83,15 +82,14 @@ var createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     diag: diag,
     qr: qr,
     inv: inv,
+    usolve: usolve,
     usolveAll: usolveAll,
     equal: equal,
     complex: complex,
     larger: larger,
     smaller: smaller,
-    round: round,
-    log10: log10,
-    transpose: transpose,
-    matrixFromColumns: matrixFromColumns
+    matrixFromColumns: matrixFromColumns,
+    dot: dot
   });
   /**
    * Compute eigenvalues and eigenvectors of a matrix. The eigenvalues are sorted by their absolute value, ascending.

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 9.4.0
- * @date    2021-05-16
+ * @version 9.4.4
+ * @date    2021-07-07
  *
  * @license
  * Copyright (C) 2013-2021 Jos de Jong <wjosdejong@gmail.com>

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

@@ -16,17 +16,17 @@ var dependencies = ['?on', 'config'];
 var createBigNumberClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var on = _ref.on,
       config = _ref.config;
-  var EUCLID = 9; // Use euclidian division for mod calculation
 
   var BigNumber = _decimal["default"].clone({
     precision: config.precision,
-    modulo: EUCLID
+    modulo: _decimal["default"].EUCLID
   });
+
+  BigNumber.prototype = Object.create(BigNumber.prototype);
   /**
    * Attach type information
    */
 
-
   BigNumber.prototype.type = 'BigNumber';
   BigNumber.prototype.isBigNumber = true;
   /**

package/lib/cjs/utils/is.js

@@ -65,7 +65,19 @@ function isNumber(x) {
 }
 
 function isBigNumber(x) {
-  return x && x.constructor.prototype.isBigNumber === true || false;
+  if (!x || (0, _typeof2["default"])(x) !== 'object' || typeof x.constructor !== 'function') {
+    return false;
+  }
+
+  if (x.isBigNumber === true && (0, _typeof2["default"])(x.constructor.prototype) === 'object' && x.constructor.prototype.isBigNumber === true) {
+    return true;
+  }
+
+  if (typeof x.constructor.isDecimal === 'function' && x.constructor.isDecimal(x) === true) {
+    return true;
+  }
+
+  return false;
 }
 
 function isComplex(x) {

package/lib/cjs/version.js

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

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

@@ -12,12 +12,12 @@ import { complexDependencies } from './dependenciesComplex.generated.js';
 import { cosDependencies } from './dependenciesCos.generated.js';
 import { diagDependencies } from './dependenciesDiag.generated.js';
 import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
+import { dotDependencies } from './dependenciesDot.generated.js';
 import { equalDependencies } from './dependenciesEqual.generated.js';
 import { flattenDependencies } from './dependenciesFlatten.generated.js';
 import { imDependencies } from './dependenciesIm.generated.js';
 import { invDependencies } from './dependenciesInv.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
-import { log10Dependencies } from './dependenciesLog10.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { matrixFromColumnsDependencies } from './dependenciesMatrixFromColumns.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
@@ -25,13 +25,12 @@ import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generat
 import { numberDependencies } from './dependenciesNumber.generated.js';
 import { qrDependencies } from './dependenciesQr.generated.js';
 import { reDependencies } from './dependenciesRe.generated.js';
-import { roundDependencies } from './dependenciesRound.generated.js';
 import { sinDependencies } from './dependenciesSin.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
 import { sqrtDependencies } from './dependenciesSqrt.generated.js';
 import { subtractDependencies } from './dependenciesSubtract.generated.js';
-import { transposeDependencies } from './dependenciesTranspose.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
+import { usolveDependencies } from './dependenciesUsolve.generated.js';
 import { usolveAllDependencies } from './dependenciesUsolveAll.generated.js';
 import { createEigs } from '../../factoriesAny.js';
 export var eigsDependencies = {
@@ -45,12 +44,12 @@ export var eigsDependencies = {
   cosDependencies,
   diagDependencies,
   divideScalarDependencies,
+  dotDependencies,
   equalDependencies,
   flattenDependencies,
   imDependencies,
   invDependencies,
   largerDependencies,
-  log10Dependencies,
   matrixDependencies,
   matrixFromColumnsDependencies,
   multiplyDependencies,
@@ -58,13 +57,12 @@ export var eigsDependencies = {
   numberDependencies,
   qrDependencies,
   reDependencies,
-  roundDependencies,
   sinDependencies,
   smallerDependencies,
   sqrtDependencies,
   subtractDependencies,
-  transposeDependencies,
   typedDependencies,
+  usolveDependencies,
   usolveAllDependencies,
   createEigs
 };

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

@@ -7,6 +7,7 @@ import { addDependencies } from './dependenciesAdd.generated.js';
 import { addScalarDependencies } from './dependenciesAddScalar.generated.js';
 import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
 import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
+import { flattenDependencies } from './dependenciesFlatten.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
 import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generated.js';
@@ -20,6 +21,7 @@ export var intersectDependencies = {
   addScalarDependencies,
   divideScalarDependencies,
   equalScalarDependencies,
+  flattenDependencies,
   matrixDependencies,
   multiplyDependencies,
   multiplyScalarDependencies,