mathjs 10.2.0 → 10.4.1

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

@@ -54,32 +54,36 @@ function createComplexEigs(_ref) {
     } // TODO check if any row/col are zero except the diagonal
     // make sure corresponding rows and columns have similar magnitude
     // important because of numerical stability
+    // MODIFIES arr by side effect!
 
 
     var R = balance(arr, N, prec, type, findVectors); // R is the row transformation matrix
-    // A' = R A R⁻¹, A is the original matrix
+    // arr = A' = R A R⁻¹, A is the original matrix
     // (if findVectors is false, R is undefined)
+    // (And so to return to original matrix: A = R⁻¹ arr R)
     // TODO if magnitudes of elements vary over many orders,
     // move greatest elements to the top left corner
     // using similarity transformations, reduce the matrix
     // to Hessenberg form (upper triangular plus one subdiagonal row)
     // updates the transformation matrix R with new row operationsq
+    // MODIFIES arr by side effect!
 
-    reduceToHessenberg(arr, N, prec, type, findVectors, R); // find eigenvalues
+    reduceToHessenberg(arr, N, prec, type, findVectors, R); // still true that original A = R⁻¹ arr R)
+    // find eigenvalues
 
     var _iterateUntilTriangul = iterateUntilTriangular(arr, N, prec, type, findVectors),
         values = _iterateUntilTriangul.values,
         C = _iterateUntilTriangul.C; // values is the list of eigenvalues, C is the column
-    // transformation matrix that transforms the hessenberg
-    // matrix to upper triangular
-    // compose transformations A → hess. and hess. → triang.
+    // transformation matrix that transforms arr, the hessenberg
+    // matrix, to upper triangular
+    // (So U = C⁻¹ arr C and the relationship between current arr
+    // and original A is unchanged.)
 
 
-    C = multiply(inv(R), C);
     var vectors;
 
     if (findVectors) {
-      vectors = findEigenvectors(arr, N, C, values, prec, type);
+      vectors = findEigenvectors(arr, N, C, R, values, prec, type);
       vectors = matrixFromColumns.apply(void 0, (0, _toConsumableArray2.default)(vectors));
     }
 
@@ -100,8 +104,9 @@ function createComplexEigs(_ref) {
   function balance(arr, N, prec, type, findVectors) {
     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; // base of the floating-point arithmetic
+    var realzero = big ? bignumber(0) : 0;
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1;
+    var realone = big ? bignumber(1) : 1; // base of the floating-point arithmetic
 
     var radix = big ? bignumber(10) : 2;
     var radixSq = multiplyScalar(radix, radix); // the diagonal transformation matrix R
@@ -122,12 +127,13 @@ function createComplexEigs(_ref) {
       for (var i = 0; i < N; i++) {
         // compute the taxicab norm of i-th column and row
         // TODO optimize for complex numbers
-        var colNorm = zero;
-        var rowNorm = zero;
+        var colNorm = realzero;
+        var rowNorm = realzero;
 
         for (var j = 0; j < N; j++) {
           if (i === j) continue;
-          var c = abs(arr[i][j]);
+          var c = abs(arr[i][j]); // should be real
+
           colNorm = addScalar(colNorm, c);
           rowNorm = addScalar(rowNorm, c);
         }
@@ -136,7 +142,7 @@ function createComplexEigs(_ref) {
           // find integer power closest to balancing the matrix
           // (we want to scale only by integer powers of radix,
           // so that we don't lose any precision due to round-off)
-          var f = one;
+          var f = realone;
           var _c = colNorm;
           var rowDivRadix = divideScalar(rowNorm, radix);
           var rowMulRadix = multiplyScalar(rowNorm, radix);
@@ -410,16 +416,17 @@ function createComplexEigs(_ref) {
     };
   }
   /**
-   * @param {Matrix} A original matrix
+   * @param {Matrix} A hessenberg-form matrix
    * @param {number} N size of A
    * @param {Matrix} C column transformation matrix that turns A into upper triangular
+   * @param {Matrix} R similarity that turns original matrix into A
    * @param {number[]} values array of eigenvalues of A
    * @param {'number'|'BigNumber'|'Complex'} type
    * @returns {number[][]} eigenvalues
    */
 
 
-  function findEigenvectors(A, N, C, values, prec, type) {
+  function findEigenvectors(A, N, C, R, values, prec, type) {
     var Cinv = inv(C);
     var U = multiply(Cinv, A, C);
     var big = type === 'BigNumber';
@@ -436,12 +443,12 @@ function createComplexEigs(_ref) {
 
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _λ = _step.value;
+        var λ = _step.value;
 
-        var _i4 = indexOf(uniqueValues, _λ, equal);
+        var _i4 = indexOf(uniqueValues, λ, equal);
 
         if (_i4 === -1) {
-          uniqueValues.push(_λ);
+          uniqueValues.push(λ);
           multiplicities.push(1);
         } else {
           multiplicities[_i4] += 1;
@@ -463,21 +470,16 @@ function createComplexEigs(_ref) {
 
     var failedLambdas = [];
 
-    for (var i = 0; i < len; i++) {
+    var _loop = function _loop(i) {
       var λ = uniqueValues[i];
+      var S = subtract(U, multiply(λ, E)); // the characteristic matrix
 
-      var _A = subtract(U, multiply(λ, E)); // the characteristic matrix
-
-
-      var solutions = usolveAll(_A, b);
-      solutions = solutions.map(function (v) {
-        return multiply(C, v);
-      });
+      var solutions = usolveAll(S, b);
       solutions.shift(); // ignore the null vector
       // looks like we missed something, try inverse iteration
 
       while (solutions.length < multiplicities[i]) {
-        var approxVec = inverseIterate(_A, N, solutions, prec, type);
+        var approxVec = inverseIterate(S, N, solutions, prec, type);
 
         if (approxVec == null) {
           // no more vectors were found
@@ -486,11 +488,20 @@ function createComplexEigs(_ref) {
         }
 
         solutions.push(approxVec);
-      }
+      } // Transform back into original array coordinates
+
 
+      var correction = multiply(inv(R), C);
+      solutions = solutions.map(function (v) {
+        return multiply(correction, v);
+      });
       vectors.push.apply(vectors, (0, _toConsumableArray2.default)(solutions.map(function (v) {
         return flatten(v);
       })));
+    };
+
+    for (var i = 0; i < len; i++) {
+      _loop(i);
     }
 
     if (failedLambdas.length !== 0) {

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

@@ -15,8 +15,15 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
   var typed = _ref.typed;
 
   /**
-   * Create a new matrix or array with the results of the callback function executed on
-   * each entry of the matrix/array.
+   * Create a new matrix or array with the results of a callback function executed on
+   * each entry of a given matrix/array.
+   *
+   * For each entry of the input, the callback is invoked with three arguments:
+   * the value of the entry, the index at which that entry occurs, and the full
+   * matrix/array being traversed. Note that because the matrix/array might be
+   * multidimensional, the "index" argument is always an array of numbers giving
+   * the index in each dimension. This is true even for vectors: the "index"
+   * argument is an array of length 1, rather than simply a number.
    *
    * Syntax:
    *
@@ -28,15 +35,25 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *      return value * value
    *    })  // returns [1, 4, 9]
    *
+   *    // The calling convention for the callback can cause subtleties:
+   *    math.map([1, 2, 3], math.format)
+   *    // throws TypeError: map attempted to call 'format(1,[0])' but argument 2 of type Array does not match expected type number or function or Object or string or boolean
+   *    // [This happens because `format` _can_ take a second argument,
+   *    // but its semantics don't match that of the 2nd argument `map` provides]
+   *
+   *    // To avoid this error, use a function that takes exactly the
+   *    // desired arguments:
+   *    math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
+   *
    * See also:
    *
    *    filter, forEach, sort
    *
-   * @param {Matrix | Array} x    The matrix to iterate on.
-   * @param {Function} callback   The callback method is invoked with three
-   *                              parameters: the value of the element, the index
-   *                              of the element, and the matrix being traversed.
-   * @return {Matrix | array}     Transformed map of x
+   * @param {Matrix | Array} x    The input to iterate on.
+   * @param {Function} callback
+   *     The function to call (as described above) on each entry of the input
+   * @return {Matrix | array}
+   *     Transformed map of x; always has the same type and shape as x
    */
   return typed(name, {
     'Array, function': _map,
@@ -66,14 +83,35 @@ function _map(array, callback) {
         return recurse(child, index.concat(i));
       });
     } else {
-      // invoke the callback function with the right number of arguments
-      if (args === 1) {
-        return callback(value);
-      } else if (args === 2) {
-        return callback(value, index);
-      } else {
-        // 3 or -1
-        return callback(value, index, array);
+      try {
+        // invoke the callback function with the right number of arguments
+        if (args === 1) {
+          return callback(value);
+        } else if (args === 2) {
+          return callback(value, index);
+        } else {
+          // 3 or -1
+          return callback(value, index, array);
+        }
+      } catch (err) {
+        // But maybe the arguments still weren't right
+        if (err instanceof TypeError && 'data' in err && err.data.category === 'wrongType') {
+          var newmsg = "map attempted to call '".concat(err.data.fn, "(").concat(value);
+          var indexString = JSON.stringify(index);
+
+          if (args === 2) {
+            newmsg += ',' + indexString;
+          } else if (args !== 1) {
+            newmsg += ",".concat(indexString, ",").concat(array);
+          }
+
+          newmsg += ")' but argument ".concat(err.data.index + 1, " of type ");
+          newmsg += "".concat(err.data.actual, " does not match expected type ");
+          newmsg += err.data.expected.join(' or ');
+          throw new TypeError(newmsg);
+        }
+
+        throw err;
       }
     }
   };

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

@@ -39,16 +39,26 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    *     // replace a subset
    *     const e = []
-   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]]
+   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]] and e = [[5, 0, 6]]
    *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 6], [0, 7]]
    *
+   *     // get submatrix using ranges
+   *     const M = [
+   *       [1,2,3],
+   *       [4,5,6],
+   *       [7,8,9]
+   *     ]
+   *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1,2,3],[4,5,6]]
+   *
    * See also:
    *
    *     size, resize, squeeze, index
    *
    * @param {Array | Matrix | string} matrix  An array, matrix, or string
-   * @param {Index} index                     An index containing ranges for each
-   *                                          dimension
+   * @param {Index} index
+   *    For each dimension of the target, specifies an index or a list of
+   *    indices to fetch or set. `subset` uses the cartesian product of
+   *    the indices specified in each dimension.
    * @param {*} [replacement]                 An array, matrix, or scalar.
    *                                          If provided, the subset is replaced with replacement.
    *                                          If not provided, the subset is returned
@@ -91,7 +101,7 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
 /**
  * Retrieve a subset of a string
  * @param {string} str            string from which to get a substring
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @returns {string} substring
  * @private
  */
@@ -122,7 +132,7 @@ function _getSubstring(str, index) {
 /**
  * Replace a substring in a string
  * @param {string} str            string to be replaced
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @param {string} replacement    Replacement string
  * @param {string} [defaultValue] Default value to be uses when resizing
  *                                the string. is ' ' by default

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

@@ -119,7 +119,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,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 10.2.0
- * @date    2022-03-01
+ * @version 10.4.1
+ * @date    2022-03-23
  *
  * @license
  * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>

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
    */

package/lib/cjs/utils/collection.js

@@ -15,6 +15,8 @@ var _IndexError = require("../error/IndexError.js");
 
 var _array = require("./array.js");
 
+var _switch2 = require("./switch.js");
+
 /**
  * Test whether an array contains collections
  * @param {Array} array
@@ -126,7 +128,7 @@ function _reduce(mat, dim, callback) {
 
       return val;
     } else {
-      tran = _switch(mat);
+      tran = (0, _switch2._switch)(mat);
       ret = [];
 
       for (i = 0; i < tran.length; i++) {
@@ -144,32 +146,6 @@ function _reduce(mat, dim, callback) {
 
     return ret;
   }
-}
-/**
- * Transpose a matrix
- * @param {Array} mat
- * @returns {Array} ret
- * @private
- */
-
-
-function _switch(mat) {
-  var I = mat.length;
-  var J = mat[0].length;
-  var i, j;
-  var ret = [];
-
-  for (j = 0; j < J; j++) {
-    var tmp = [];
-
-    for (i = 0; i < I; i++) {
-      tmp.push(mat[i][j]);
-    }
-
-    ret.push(tmp);
-  }
-
-  return ret;
 } // TODO: document function scatter
 
 

package/lib/cjs/utils/switch.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._switch = _switch;
+
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+function _switch(mat) {
+  var I = mat.length;
+  var J = mat[0].length;
+  var i, j;
+  var ret = [];
+
+  for (j = 0; j < J; j++) {
+    var tmp = [];
+
+    for (i = 0; i < I; i++) {
+      tmp.push(mat[i][j]);
+    }
+
+    ret.push(tmp);
+  }
+
+  return ret;
+}

package/lib/cjs/version.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = '10.2.0'; // Note: This file is automatically generated when building math.js.
+var version = '10.4.1'; // 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/dependenciesCumSum.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { unaryPlusDependencies } from './dependenciesUnaryPlus.generated.js';
+import { createCumSum } from '../../factoriesAny.js';
+export var cumsumDependencies = {
+  addDependencies,
+  typedDependencies,
+  unaryPlusDependencies,
+  createCumSum
+};

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

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { unaryPlusDependencies } from './dependenciesUnaryPlus.generated.js';
+import { createCumSumTransform } from '../../factoriesAny.js';
+export var cumsumTransformDependencies = {
+  addDependencies,
+  typedDependencies,
+  unaryPlusDependencies,
+  createCumSumTransform
+};

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

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { OperatorNodeDependencies } from './dependenciesOperatorNode.generated.js';
+import { parseDependencies } from './dependenciesParse.generated.js';
+import { simplifyDependencies } from './dependenciesSimplify.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createSymbolicEqual } from '../../factoriesAny.js';
+export var symbolicEqualDependencies = {
+  OperatorNodeDependencies,
+  parseDependencies,
+  simplifyDependencies,
+  typedDependencies,
+  createSymbolicEqual
+};