mathjs 10.6.3 → 11.0.1

package/lib/esm/function/utils/typeOf.js

@@ -8,46 +8,7 @@ export var createTypeOf = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
 
   /**
-   * Determine the type of a variable.
-   *
-   * Function `typeOf` recognizes the following types of objects:
-   *
-   * Object                 | Returns       | Example
-   * ---------------------- | ------------- | ------------------------------------------
-   * null                   | `'null'`      | `math.typeOf(null)`
-   * number                 | `'number'`    | `math.typeOf(3.5)`
-   * boolean                | `'boolean'`   | `math.typeOf(true)`
-   * string                 | `'string'`    | `math.typeOf('hello world')`
-   * Array                  | `'Array'`     | `math.typeOf([1, 2, 3])`
-   * Date                   | `'Date'`      | `math.typeOf(new Date())`
-   * Function               | `'Function'`  | `math.typeOf(function () {})`
-   * Object                 | `'Object'`    | `math.typeOf({a: 2, b: 3})`
-   * RegExp                 | `'RegExp'`    | `math.typeOf(/a regexp/)`
-   * undefined              | `'undefined'` | `math.typeOf(undefined)`
-   * math.BigNumber         | `'BigNumber'` | `math.typeOf(math.bignumber('2.3e500'))`
-   * math.Chain             | `'Chain'`     | `math.typeOf(math.chain(2))`
-   * math.Complex           | `'Complex'`   | `math.typeOf(math.complex(2, 3))`
-   * math.Fraction          | `'Fraction'`  | `math.typeOf(math.fraction(1, 3))`
-   * math.Help              | `'Help'`      | `math.typeOf(math.help('sqrt'))`
-   * math.Help              | `'Help'`      | `math.typeOf(math.help('sqrt'))`
-   * math.Index             | `'Index'`     | `math.typeOf(math.index(1, 3))`
-   * math.Matrix            | `'Matrix'`    | `math.typeOf(math.matrix([[1,2], [3, 4]]))`
-   * math.Range             | `'Range'`     | `math.typeOf(math.range(0, 10))`
-   * math.ResultSet         | `'ResultSet'` | `math.typeOf(math.evaluate('a=2\nb=3'))`
-   * math.Unit              | `'Unit'`      | `math.typeOf(math.unit('45 deg'))`
-   * math.AccessorNode            | `'AccessorNode'`            | `math.typeOf(math.parse('A[2]'))`
-   * math.ArrayNode               | `'ArrayNode'`               | `math.typeOf(math.parse('[1,2,3]'))`
-   * math.AssignmentNode          | `'AssignmentNode'`          | `math.typeOf(math.parse('x=2'))`
-   * math.BlockNode               | `'BlockNode'`               | `math.typeOf(math.parse('a=2; b=3'))`
-   * math.ConditionalNode         | `'ConditionalNode'`         | `math.typeOf(math.parse('x<0 ? -x : x'))`
-   * math.ConstantNode            | `'ConstantNode'`            | `math.typeOf(math.parse('2.3'))`
-   * math.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeOf(math.parse('f(x)=x^2'))`
-   * math.FunctionNode            | `'FunctionNode'`            | `math.typeOf(math.parse('sqrt(4)'))`
-   * math.IndexNode               | `'IndexNode'`               | `math.typeOf(math.parse('A[2]').index)`
-   * math.ObjectNode              | `'ObjectNode'`              | `math.typeOf(math.parse('{a:2}'))`
-   * math.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeOf(math.parse('(2+3)'))`
-   * math.RangeNode               | `'RangeNode'`               | `math.typeOf(math.parse('1:10'))`
-   * math.SymbolNode              | `'SymbolNode'`              | `math.typeOf(math.parse('x'))`
+   * Determine the type of an entity.
    *
    * Syntax:
    *
@@ -55,10 +16,43 @@ export var createTypeOf = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *    math.typeOf(3.5)                     // returns 'number'
-   *    math.typeOf(math.complex('2-4i'))    // returns 'Complex'
-   *    math.typeOf(math.unit('45 deg'))     // returns 'Unit'
-   *    math.typeOf('hello world')           // returns 'string'
+   *    // This list is intended to include all relevant types, for testing
+   *    // purposes:
+   *    math.typeOf(3.5)                      // returns 'number'
+   *    math.typeOf(math.complex('2-4i'))     // returns 'Complex'
+   *    math.typeOf(math.unit('45 deg'))      // returns 'Unit'
+   *    math.typeOf('hello world')            // returns 'string'
+   *    math.typeOf(null)                     // returns 'null'
+   *    math.typeOf(true)                     // returns 'boolean'
+   *    math.typeOf([1, 2, 3])                // returns 'Array'
+   *    math.typeOf(new Date())               // returns 'Date'
+   *    math.typeOf(function () {})           // returns 'function'
+   *    math.typeOf({a: 2, b: 3})             // returns 'Object'
+   *    math.typeOf(/a regexp/)               // returns 'RegExp'
+   *    math.typeOf(undefined)                // returns 'undefined'
+   *    math.typeOf(math.bignumber('23e99'))  // returns 'BigNumber'
+   *    math.typeOf(math.chain(2))            // returns 'Chain'
+   *    math.typeOf(math.fraction(1, 3))      // returns 'Fraction'
+   *    math.typeOf(math.help('sqrt'))        // returns 'Help'
+   *    math.typeOf(math.index(1, 3))         // returns 'Index'
+   *    math.typeOf(math.matrix([[1],[3]]))   // returns 'DenseMatrix'
+   *    math.typeOf(math.matrix([],'sparse')) // returns 'SparseMatrix'
+   *    math.typeOf(new math.Range(0, 10))    // returns 'Range'
+   *    math.typeOf(math.evaluate('a=2\na'))  // returns 'ResultSet'
+   *    math.typeOf(math.parse('A[2]'))       // returns 'AccessorNode'
+   *    math.typeOf(math.parse('[1,2,3]'))    // returns 'ArrayNode'
+   *    math.typeOf(math.parse('x=2'))        // returns 'AssignmentNode'
+   *    math.typeOf(math.parse('a=2; b=3'))   // returns 'BlockNode'
+   *    math.typeOf(math.parse('x<0?-1:1'))   // returns 'ConditionalNode'
+   *    math.typeOf(math.parse('2.3'))        // returns 'ConstantNode'
+   *    math.typeOf(math.parse('f(x)=x^2'))   // returns 'FunctionAssignmentNode'
+   *    math.typeOf(math.parse('sqrt(4)'))    // returns 'FunctionNode'
+   *    math.typeOf(math.parse('A[2]').index) // returns 'IndexNode'
+   *    math.typeOf(math.parse('{a:2}'))      // returns 'ObjectNode'
+   *    math.typeOf(math.parse('(2+3)'))      // returns 'ParenthesisNode'
+   *    math.typeOf(math.parse('1:10'))       // returns 'RangeNode'
+   *    math.typeOf(math.parse('a<b<c'))      // returns 'RelationalNode'
+   *    math.typeOf(math.parse('x'))          // returns 'SymbolNode'
    *
    * @param {*} x     The variable for which to test the type.
    * @return {string} Returns the name of the type. Primitive types are lower case,

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

@@ -75,8 +75,6 @@ export var createBignumber = /* #__PURE__ */factory(name, dependencies, _ref =>
     null: function _null(x) {
       return new BigNumber(0);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/type/boolean.js

@@ -69,8 +69,6 @@ export var createBoolean = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       throw new Error('Cannot convert "' + x + '" to a boolean');
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/type/chain/Chain.js

@@ -3,11 +3,12 @@ import { format } from '../../utils/string.js';
 import { hasOwnProperty, lazy } from '../../utils/object.js';
 import { factory } from '../../utils/factory.js';
 var name = 'Chain';
-var dependencies = ['?on', 'math'];
+var dependencies = ['?on', 'math', 'typed'];
 export var createChainClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     on,
-    math
+    math,
+    typed
   } = _ref;
 
   /**
@@ -142,12 +143,31 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, _ref =>
 
   function chainify(fn) {
     return function () {
-      var args = [this.value]; // `this` will be the context of a Chain instance
+      // Here, `this` will be the context of a Chain instance
+      if (arguments.length === 0) {
+        return new Chain(fn(this.value));
+      }
+
+      var args = [this.value];
 
       for (var i = 0; i < arguments.length; i++) {
         args[i + 1] = arguments[i];
       }
 
+      if (typed.isTypedFunction(fn)) {
+        var sigObject = typed.resolve(fn, args); // We want to detect if a rest parameter has matched across the
+        // value in the chain and the current arguments of this call.
+        // That is the case if and only if the matching signature has
+        // exactly one parameter (which then must be a rest parameter
+        // as it is matching at least two actual arguments).
+
+        if (sigObject.params.length === 1) {
+          throw new Error('chain function ' + fn.name + ' cannot match rest parameter between chain value and additional arguments.');
+        }
+
+        return new Chain(sigObject.implementation.apply(fn, args));
+      }
+
       return new Chain(fn.apply(fn, args));
     };
   }

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

@@ -8,6 +8,10 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
   /**
    * Attach type information
    */
+  Object.defineProperty(Complex, 'name', {
+    value: 'Complex'
+  });
+  Complex.prototype.constructor = Complex;
   Complex.prototype.type = 'Complex';
   Complex.prototype.isComplex = true;
   /**

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

@@ -83,8 +83,6 @@ export var createComplex = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       throw new Error('Expected object with properties (re and im) or (r and phi) or (abs and arg)');
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -6,6 +6,10 @@ export var createFractionClass = /* #__PURE__ */factory(name, dependencies, () =
   /**
    * Attach type information
    */
+  Object.defineProperty(Fraction, 'name', {
+    value: 'Fraction'
+  });
+  Fraction.prototype.constructor = Fraction;
   Fraction.prototype.type = 'Fraction';
   Fraction.prototype.isFraction = true;
   /**

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

@@ -71,8 +71,6 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
     Object: function Object(x) {
       return new Fraction(x);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/type/matrix/DenseMatrix.js

@@ -5,6 +5,7 @@ import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
+import { maxArgumentCount } from '../../utils/function.js';
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -79,6 +80,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    */
 
 
+  Object.defineProperty(DenseMatrix, 'name', {
+    value: 'DenseMatrix'
+  });
+  DenseMatrix.prototype.constructor = DenseMatrix;
   DenseMatrix.prototype.type = 'DenseMatrix';
   DenseMatrix.prototype.isDenseMatrix = true;
   /**
@@ -576,6 +581,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
     var me = this;
+    var args = maxArgumentCount(callback);
 
     var recurse = function recurse(value, index) {
       if (isArray(value)) {
@@ -583,7 +589,15 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
           return recurse(child, index.concat(i));
         });
       } else {
-        return callback(value, index, me);
+        // 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, me);
+        }
       }
     }; // determine the new datatype when the original matrix has datatype defined
     // TODO: should be done in matrix constructor instead

package/lib/esm/type/matrix/SparseMatrix.js

@@ -5,6 +5,7 @@ import { clone, deepStrictEqual } from '../../utils/object.js';
 import { arraySize, getArrayDataType, processSizesWildcard, unsqueeze, validateIndex } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { DimensionError } from '../../error/DimensionError.js';
+import { maxArgumentCount } from '../../utils/function.js';
 var name = 'SparseMatrix';
 var dependencies = ['typed', 'equalScalar', 'Matrix'];
 export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -166,6 +167,10 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
    */
 
 
+  Object.defineProperty(SparseMatrix, 'name', {
+    value: 'SparseMatrix'
+  });
+  SparseMatrix.prototype.constructor = SparseMatrix;
   SparseMatrix.prototype.type = 'SparseMatrix';
   SparseMatrix.prototype.isSparseMatrix = true;
   /**
@@ -919,8 +924,12 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     var rows = this._size[0];
     var columns = this._size[1]; // invoke callback
 
+    var args = maxArgumentCount(callback);
+
     var invoke = function invoke(v, i, j) {
       // invoke callback
+      if (args === 1) return callback(v);
+      if (args === 2) return callback(v, [i, j]);
       return callback(v, [i, j], me);
     }; // invoke _map
 

package/lib/esm/type/matrix/utils/{algorithm01.js → matAlgo01xDSid.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm01';
+var name = 'matAlgo01xDSid';
 var dependencies = ['typed'];
-export var createAlgorithm01 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo01xDSid = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;

package/lib/esm/type/matrix/utils/{algorithm02.js → matAlgo02xDS0.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm02';
+var name = 'matAlgo02xDS0';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm02 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo02xDS0 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -27,7 +27,7 @@ export var createAlgorithm02 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97477571
    */
-  return function algorithm02(denseMatrix, sparseMatrix, callback, inverse) {
+  return function matAlgo02xDS0(denseMatrix, sparseMatrix, callback, inverse) {
     // dense matrix arrays
     var adata = denseMatrix._data;
     var asize = denseMatrix._size;

package/lib/esm/type/matrix/utils/{algorithm03.js → matAlgo03xDSf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm03';
+var name = 'matAlgo03xDSf';
 var dependencies = ['typed'];
-export var createAlgorithm03 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo03xDSf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
@@ -26,7 +26,7 @@ export var createAlgorithm03 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97477571
    */
-  return function algorithm03(denseMatrix, sparseMatrix, callback, inverse) {
+  return function matAlgo03xDSf(denseMatrix, sparseMatrix, callback, inverse) {
     // dense matrix arrays
     var adata = denseMatrix._data;
     var asize = denseMatrix._size;

package/lib/esm/type/matrix/utils/{algorithm04.js → matAlgo04xSidSid.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm04';
+var name = 'matAlgo04xSidSid';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm04 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo04xSidSid = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -14,8 +14,8 @@ export var createAlgorithm04 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    *
    *          ┌  f(Aij, Bij)  ; A(i,j) !== 0 && B(i,j) !== 0
-   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0
-   *          └  B(i,j)       ; B(i,j) !== 0
+   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0 && B(i,j) === 0
+   *          └  B(i,j)       ; A(i,j) === 0
    *
    *
    * @param {Matrix}   a                 The SparseMatrix instance (A)
@@ -26,7 +26,7 @@ export var createAlgorithm04 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm04(a, b, callback) {
+  return function matAlgo04xSidSid(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm05.js → matAlgo05xSfSf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm05';
+var name = 'matAlgo05xSfSf';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm05 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo05xSfSf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -26,7 +26,7 @@ export var createAlgorithm05 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm05(a, b, callback) {
+  return function matAlgo05xSfSf(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm06.js → matAlgo06xS0S0.js}

@@ -1,9 +1,9 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
 import { scatter } from '../../../utils/collection.js';
-var name = 'algorithm06';
+var name = 'matAlgo06xS0S0';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm06 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo06xS0S0 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -27,7 +27,7 @@ export var createAlgorithm06 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm06(a, b, callback) {
+  return function matAlgo06xS0S0(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var asize = a._size;

package/lib/esm/type/matrix/utils/{algorithm07.js → matAlgo07xSSf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm07';
+var name = 'matAlgo07xSSf';
 var dependencies = ['typed', 'DenseMatrix'];
-export var createAlgorithm07 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo07xSSf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     DenseMatrix
@@ -22,7 +22,7 @@ export var createAlgorithm07 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm07(a, b, callback) {
+  return function matAlgo07xSSf(a, b, callback) {
     // sparse matrix arrays
     var asize = a._size;
     var adt = a._datatype; // sparse matrix arrays

package/lib/esm/type/matrix/utils/{algorithm08.js → matAlgo08xS0Sid.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm08';
+var name = 'matAlgo08xS0Sid';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm08 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo08xS0Sid = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -14,7 +14,7 @@ export var createAlgorithm08 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    *
    *          ┌  f(Aij, Bij)  ; A(i,j) !== 0 && B(i,j) !== 0
-   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0
+   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0 && B(i,j) === 0
    *          └  0            ; otherwise
    *
    *
@@ -26,7 +26,7 @@ export var createAlgorithm08 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm08(a, b, callback) {
+  return function matAlgo08xS0Sid(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm09.js → matAlgo09xS0Sf.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm09';
+var name = 'matAlgo09xS0Sf';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm09 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo09xS0Sf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -26,7 +26,7 @@ export var createAlgorithm09 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
    */
-  return function algorithm09(a, b, callback) {
+  return function matAlgo09xS0Sf(a, b, callback) {
     // sparse matrix arrays
     var avalues = a._values;
     var aindex = a._index;

package/lib/esm/type/matrix/utils/{algorithm10.js → matAlgo10xSids.js}

@@ -1,7 +1,7 @@
 import { factory } from '../../../utils/factory.js';
-var name = 'algorithm10';
+var name = 'matAlgo10xSids';
 var dependencies = ['typed', 'DenseMatrix'];
-export var createAlgorithm10 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo10xSids = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     DenseMatrix
@@ -26,7 +26,7 @@ export var createAlgorithm10 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97626813
    */
-  return function algorithm10(s, b, callback, inverse) {
+  return function matAlgo10xSids(s, b, callback, inverse) {
     // sparse matrix arrays
     var avalues = s._values;
     var aindex = s._index;

package/lib/esm/type/matrix/utils/{algorithm11.js → matAlgo11xS0s.js}

@@ -1,7 +1,7 @@
 import { factory } from '../../../utils/factory.js';
-var name = 'algorithm11';
+var name = 'matAlgo11xS0s';
 var dependencies = ['typed', 'equalScalar'];
-export var createAlgorithm11 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo11xS0s = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     equalScalar
@@ -26,7 +26,7 @@ export var createAlgorithm11 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97626813
    */
-  return function algorithm11(s, b, callback, inverse) {
+  return function matAlgo11xS0s(s, b, callback, inverse) {
     // sparse matrix arrays
     var avalues = s._values;
     var aindex = s._index;

package/lib/esm/type/matrix/utils/{algorithm12.js → matAlgo12xSfs.js}

@@ -1,7 +1,7 @@
 import { factory } from '../../../utils/factory.js';
-var name = 'algorithm12';
+var name = 'matAlgo12xSfs';
 var dependencies = ['typed', 'DenseMatrix'];
-export var createAlgorithm12 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo12xSfs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     DenseMatrix
@@ -26,7 +26,7 @@ export var createAlgorithm12 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97626813
    */
-  return function algorithm12(s, b, callback, inverse) {
+  return function matAlgo12xSfs(s, b, callback, inverse) {
     // sparse matrix arrays
     var avalues = s._values;
     var aindex = s._index;

package/lib/esm/type/matrix/utils/{algorithm13.js → matAlgo13xDD.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
-var name = 'algorithm13';
+var name = 'matAlgo13xDD';
 var dependencies = ['typed'];
-export var createAlgorithm13 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo13xDD = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
@@ -21,7 +21,7 @@ export var createAlgorithm13 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97658658
    */
-  return function algorithm13(a, b, callback) {
+  return function matAlgo13xDD(a, b, callback) {
     // a arrays
     var adata = a._data;
     var asize = a._size;

package/lib/esm/type/matrix/utils/{algorithm14.js → matAlgo14xDs.js}

@@ -1,8 +1,8 @@
 import { factory } from '../../../utils/factory.js';
 import { clone } from '../../../utils/object.js';
-var name = 'algorithm14';
+var name = 'matAlgo14xDs';
 var dependencies = ['typed'];
-export var createAlgorithm14 = /* #__PURE__ */factory(name, dependencies, _ref => {
+export var createMatAlgo14xDs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
@@ -22,7 +22,7 @@ export var createAlgorithm14 = /* #__PURE__ */factory(name, dependencies, _ref =
    *
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97659042
    */
-  return function algorithm14(a, b, callback, inverse) {
+  return function matAlgo14xDs(a, b, callback, inverse) {
     // a arrays
     var adata = a._data;
     var asize = a._size;