mathjs 11.2.1 → 11.3.0

package/lib/esm/function/matrix/fft.js

@@ -13,7 +13,6 @@ export var createFft = /* #__PURE__ */factory(name, dependencies, _ref => {
     tau,
     i: I
   } = _ref;
-
   /**
    * Calculate N-dimensional fourier transform
    *
@@ -39,19 +38,20 @@ export var createFft = /* #__PURE__ */factory(name, dependencies, _ref => {
       return matrix.create(_ndFft(matrix.toArray()));
     }
   });
+
   /**
    * Perform an N-dimensional Fourier transform
    *
    * @param {Array} arr      The array
    * @return {Array}         resulting array
    */
-
   function _ndFft(arr) {
     var size = arraySize(arr);
-    if (size.length === 1) return _fft(arr, size[0]); // ndFft along dimension 1,...,N-1 then 1dFft along dimension 0
-
+    if (size.length === 1) return _fft(arr, size[0]);
+    // ndFft along dimension 1,...,N-1 then 1dFft along dimension 0
     return _1dFft(arr.map(slice => _ndFft(slice, size.slice(1))), 0);
   }
+
   /**
    * Perform an 1-dimensional Fourier transform
    *
@@ -59,46 +59,37 @@ export var createFft = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param {number} dim     dimension of the array to perform on
    * @return {Array}         resulting array
    */
-
-
   function _1dFft(arr, dim) {
     var size = arraySize(arr);
     if (dim !== 0) return new Array(size[0]).fill(0).map((_, i) => _1dFft(arr[i], dim - 1));
     if (size.length === 1) return _fft(arr);
-
     function _transpose(arr) {
       // Swap first 2 dimensions
       var size = arraySize(arr);
       return new Array(size[1]).fill(0).map((_, j) => new Array(size[0]).fill(0).map((_, i) => arr[i][j]));
     }
-
     return _transpose(_1dFft(_transpose(arr), 1));
   }
+
   /**
    * Perform an 1-dimensional Fourier transform
    *
    * @param {Array} arr      The array
    * @return {Array}         resulting array
    */
-
-
   function _fft(arr) {
     var len = arr.length;
     if (len === 1) return [arr[0]];
-
     if (len % 2 === 0) {
       var ret = [..._fft(arr.filter((_, i) => i % 2 === 0), len / 2), ..._fft(arr.filter((_, i) => i % 2 === 1), len / 2)];
-
       for (var k = 0; k < len / 2; k++) {
         var p = ret[k];
         var q = multiplyScalar(ret[k + len / 2], exp(multiplyScalar(multiplyScalar(tau, I), divideScalar(-k, len))));
         ret[k] = addScalar(p, q);
         ret[k + len / 2] = addScalar(p, multiplyScalar(-1, q));
       }
-
       return ret;
     }
-
     throw new Error('Can only calculate FFT of power-of-two size');
   }
 });

package/lib/esm/function/matrix/filter.js

@@ -7,7 +7,6 @@ export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Filter the items in an array or one dimensional matrix.
    *
@@ -48,6 +47,7 @@ export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
   });
 });
+
 /**
  * Filter values in a callback given a callback function
  * @param {Array} x
@@ -55,7 +55,6 @@ export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @return {Array} Returns the filtered array
  * @private
  */
-
 function _filterCallback(x, callback) {
   // figure out what number of arguments the callback function expects
   var args = maxArgumentCount(callback);

package/lib/esm/function/matrix/flatten.js

@@ -1,4 +1,3 @@
-import { clone } from '../../utils/object.js';
 import { flatten as flattenArray } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'flatten';
@@ -8,10 +7,9 @@ export var createFlatten = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     matrix
   } = _ref;
-
   /**
-   * Flatten a multi dimensional matrix into a single dimensional matrix.
-   * It is guaranteed to always return a clone of the argument.
+   * Flatten a multidimensional matrix into a single dimensional matrix.
+   * A new matrix is returned, the original matrix is left untouched.
    *
    * Syntax:
    *
@@ -30,11 +28,11 @@ export var createFlatten = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     Array: function Array(x) {
-      return flattenArray(clone(x));
+      return flattenArray(x);
     },
     Matrix: function Matrix(x) {
-      var flat = flattenArray(clone(x.toArray())); // TODO: return the same matrix type as x
-
+      var flat = flattenArray(x.toArray());
+      // TODO: return the same matrix type as x (Dense or Sparse Matrix)
       return matrix(flat);
     }
   });

package/lib/esm/function/matrix/forEach.js

@@ -7,7 +7,6 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Iterate over all elements of a matrix/array, and executes the given callback function.
    *
@@ -38,17 +37,16 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
   });
 });
+
 /**
  * forEach for a multi dimensional array
  * @param {Array} array
  * @param {Function} callback
  * @private
  */
-
 function _forEach(array, callback) {
   // figure out what number of arguments the callback function expects
   var args = maxArgumentCount(callback);
-
   var recurse = function recurse(value, index) {
     if (Array.isArray(value)) {
       forEachArray(value, function (child, i) {
@@ -67,6 +65,5 @@ function _forEach(array, callback) {
       }
     }
   };
-
   recurse(array, []);
 }

package/lib/esm/function/matrix/getMatrixDataType.js

@@ -7,7 +7,6 @@ export var createGetMatrixDataType = /* #__PURE__ */factory(name, dependencies,
   var {
     typed
   } = _ref;
-
   /**
    * Find the data type of all elements in a matrix or array,
    * for example 'number' if all items are a number and 'Complex' if all values

package/lib/esm/function/matrix/identity.js

@@ -13,7 +13,6 @@ export var createIdentity = /* #__PURE__ */factory(name, dependencies, _ref => {
     DenseMatrix,
     SparseMatrix
   } = _ref;
-
   /**
    * Create a 2-dimensional identity matrix with size m x n or n x n.
    * The matrix has ones on the diagonal and zeros elsewhere.
@@ -76,22 +75,19 @@ export var createIdentity = /* #__PURE__ */factory(name, dependencies, _ref => {
       return _identityVector(size.valueOf(), format);
     }
   });
-
   function _identityVector(size, format) {
     switch (size.length) {
       case 0:
         return format ? matrix(format) : [];
-
       case 1:
         return _identity(size[0], size[0], format);
-
       case 2:
         return _identity(size[0], size[1], format);
-
       default:
         throw new Error('Vector containing two values expected');
     }
   }
+
   /**
    * Create an identity matrix
    * @param {number | BigNumber} rows
@@ -100,48 +96,41 @@ export var createIdentity = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {Matrix}
    * @private
    */
-
-
   function _identity(rows, cols, format) {
     // BigNumber constructor with the right precision
     var Big = isBigNumber(rows) || isBigNumber(cols) ? BigNumber : null;
     if (isBigNumber(rows)) rows = rows.toNumber();
     if (isBigNumber(cols)) cols = cols.toNumber();
-
     if (!isInteger(rows) || rows < 1) {
       throw new Error('Parameters in function identity must be positive integers');
     }
-
     if (!isInteger(cols) || cols < 1) {
       throw new Error('Parameters in function identity must be positive integers');
     }
-
     var one = Big ? new BigNumber(1) : 1;
     var defaultValue = Big ? new Big(0) : 0;
-    var size = [rows, cols]; // check we need to return a matrix
+    var size = [rows, cols];
 
+    // check we need to return a matrix
     if (format) {
       // create diagonal matrix (use optimized implementation for storage format)
       if (format === 'sparse') {
         return SparseMatrix.diagonal(size, one, 0, defaultValue);
       }
-
       if (format === 'dense') {
         return DenseMatrix.diagonal(size, one, 0, defaultValue);
       }
-
       throw new TypeError("Unknown matrix type \"".concat(format, "\""));
-    } // create and resize array
-
-
-    var res = resize([], size, defaultValue); // fill in ones on the diagonal
-
-    var minimum = rows < cols ? rows : cols; // fill diagonal
+    }
 
+    // create and resize array
+    var res = resize([], size, defaultValue);
+    // fill in ones on the diagonal
+    var minimum = rows < cols ? rows : cols;
+    // fill diagonal
     for (var d = 0; d < minimum; d++) {
       res[d][d] = one;
     }
-
     return res;
   }
 });

package/lib/esm/function/matrix/ifft.js

@@ -10,7 +10,6 @@ export var createIfft = /* #__PURE__ */factory(name, dependencies, _ref => {
     dotDivide,
     conj
   } = _ref;
-
   /**
    * Calculate N-dimensional inverse fourier transform
    *

package/lib/esm/function/matrix/inv.js

@@ -16,7 +16,6 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
     identity,
     abs
   } = _ref;
-
   /**
    * Calculate the inverse of a square matrix.
    *
@@ -40,7 +39,6 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     'Array | Matrix': function ArrayMatrix(x) {
       var size = isMatrix(x) ? x.size() : arraySize(x);
-
       switch (size.length) {
         case 1:
           // vector
@@ -53,13 +51,11 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
           } else {
             throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
           }
-
         case 2:
           // two dimensional array
           {
             var rows = size[0];
             var cols = size[1];
-
             if (rows === cols) {
               if (isMatrix(x)) {
                 return matrix(_inv(x.valueOf(), rows, cols), x.storage());
@@ -71,7 +67,6 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
               throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
             }
           }
-
         default:
           // multi dimensional array
           throw new RangeError('Matrix must be two dimensional ' + '(size: ' + format(size) + ')');
@@ -82,6 +77,7 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
       return divideScalar(1, x); // FIXME: create a BigNumber one when configured for bignumbers
     }
   });
+
   /**
    * Calculate the inverse of a square matrix
    * @param {Array[]} mat     A square matrix
@@ -90,27 +86,21 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Array[]} inv    Inverse matrix
    * @private
    */
-
   function _inv(mat, rows, cols) {
     var r, s, f, value, temp;
-
     if (rows === 1) {
       // this is a 1 x 1 matrix
       value = mat[0][0];
-
       if (value === 0) {
         throw Error('Cannot calculate inverse, determinant is zero');
       }
-
       return [[divideScalar(1, value)]];
     } else if (rows === 2) {
       // this is a 2 x 2 matrix
       var d = det(mat);
-
       if (d === 0) {
         throw Error('Cannot calculate inverse, determinant is zero');
       }
-
       return [[divideScalar(mat[1][1], d), divideScalar(unaryMinus(mat[0][1]), d)], [divideScalar(unaryMinus(mat[1][0]), d), divideScalar(mat[0][0], d)]];
     } else {
       // this is a matrix of 3 x 3 or larger
@@ -118,38 +108,34 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
       //      https://en.wikipedia.org/wiki/Gaussian_elimination
       //      http://mathworld.wolfram.com/MatrixInverse.html
       //      http://math.uww.edu/~mcfarlat/inverse.htm
+
       // make a copy of the matrix (only the arrays, not of the elements)
       var A = mat.concat();
-
       for (r = 0; r < rows; r++) {
         A[r] = A[r].concat();
-      } // create an identity matrix which in the end will contain the
-      // matrix inverse
-
+      }
 
-      var B = identity(rows).valueOf(); // loop over all columns, and perform row reductions
+      // create an identity matrix which in the end will contain the
+      // matrix inverse
+      var B = identity(rows).valueOf();
 
+      // loop over all columns, and perform row reductions
       for (var c = 0; c < cols; c++) {
         // Pivoting: Swap row c with row r, where row r contains the largest element A[r][c]
         var ABig = abs(A[c][c]);
         var rBig = c;
         r = c + 1;
-
         while (r < rows) {
           if (abs(A[r][c]) > ABig) {
             ABig = abs(A[r][c]);
             rBig = r;
           }
-
           r++;
         }
-
         if (ABig === 0) {
           throw Error('Cannot calculate inverse, determinant is zero');
         }
-
         r = rBig;
-
         if (r !== c) {
           temp = A[c];
           A[c] = A[r];
@@ -157,26 +143,24 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
           temp = B[c];
           B[c] = B[r];
           B[r] = temp;
-        } // eliminate non-zero values on the other rows at column c
-
+        }
 
+        // eliminate non-zero values on the other rows at column c
         var Ac = A[c];
         var Bc = B[c];
-
         for (r = 0; r < rows; r++) {
           var Ar = A[r];
           var Br = B[r];
-
           if (r !== c) {
             // eliminate value at column c and row r
             if (Ar[c] !== 0) {
-              f = divideScalar(unaryMinus(Ar[c]), Ac[c]); // add (f * row c) to row r to eliminate the value
-              // at column c
+              f = divideScalar(unaryMinus(Ar[c]), Ac[c]);
 
+              // add (f * row c) to row r to eliminate the value
+              // at column c
               for (s = c; s < cols; s++) {
                 Ar[s] = addScalar(Ar[s], multiply(f, Ac[s]));
               }
-
               for (s = 0; s < cols; s++) {
                 Br[s] = addScalar(Br[s], multiply(f, Bc[s]));
               }
@@ -185,18 +169,15 @@ export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
             // normalize value at Acc to 1,
             // divide each value on row r with the value at Acc
             f = Ac[c];
-
             for (s = c; s < cols; s++) {
               Ar[s] = divideScalar(Ar[s], f);
             }
-
             for (s = 0; s < cols; s++) {
               Br[s] = divideScalar(Br[s], f);
             }
           }
         }
       }
-
       return B;
     }
   }

package/lib/esm/function/matrix/kron.js

@@ -8,7 +8,6 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrix,
     multiplyScalar
   } = _ref;
-
   /**
      * Calculates the kronecker product of 2 matrices or vectors.
      *
@@ -48,6 +47,7 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     'Array, Array': _kron
   });
+
   /**
      * Calculate the kronecker product of two matrices / vectors
      * @param {Array} a  First vector
@@ -55,23 +55,19 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @returns {Array} Returns the kronecker product of x and y
      * @private
      */
-
   function _kron(a, b) {
     // Deal with the dimensions of the matricies.
     if (size(a).length === 1) {
       // Wrap it in a 2D Matrix
       a = [a];
     }
-
     if (size(b).length === 1) {
       // Wrap it in a 2D Matrix
       b = [b];
     }
-
     if (size(a).length > 2 || size(b).length > 2) {
       throw new RangeError('Vectors with dimensions greater then 2 are not supported expected ' + '(Size x = ' + JSON.stringify(a.length) + ', y = ' + JSON.stringify(b.length) + ')');
     }
-
     var t = [];
     var r = [];
     return a.map(function (a) {

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

@@ -6,7 +6,6 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Create a new matrix or array with the results of a callback function executed on
    * each entry of a given matrix/array.
@@ -55,6 +54,7 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
   });
 });
+
 /**
  * Map for a multi dimensional array
  * @param {Array} array
@@ -62,11 +62,9 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @return {Array}
  * @private
  */
-
 function _map(array, callback) {
   // figure out what number of arguments the callback function expects
   var args = maxArgumentCount(callback);
-
   var recurse = function recurse(value, index) {
     if (Array.isArray(value)) {
       return value.map(function (child, i) {
@@ -89,23 +87,19 @@ function _map(array, callback) {
         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;
       }
     }
   };
-
   return recurse(array, []);
 }

package/lib/esm/function/matrix/matrixFromColumns.js

@@ -8,7 +8,6 @@ export var createMatrixFromColumns = /* #__PURE__ */factory(name, dependencies,
     flatten,
     size
   } = _ref;
-
   /**
    * Create a dense matrix from vectors as individual columns.
    * If you pass row vectors, they will be transposed (but not conjugated!)
@@ -37,41 +36,38 @@ export var createMatrixFromColumns = /* #__PURE__ */factory(name, dependencies,
     },
     '...Matrix': function Matrix(arr) {
       return matrix(_createArray(arr.map(m => m.toArray())));
-    } // TODO implement this properly for SparseMatrix
+    }
 
+    // TODO implement this properly for SparseMatrix
   });
 
   function _createArray(arr) {
     if (arr.length === 0) throw new TypeError('At least one column is needed to construct a matrix.');
-    var N = checkVectorTypeAndReturnLength(arr[0]); // create an array with empty rows
+    var N = checkVectorTypeAndReturnLength(arr[0]);
 
+    // create an array with empty rows
     var result = [];
-
     for (var i = 0; i < N; i++) {
       result[i] = [];
-    } // loop columns
-
+    }
 
+    // loop columns
     for (var col of arr) {
       var colLength = checkVectorTypeAndReturnLength(col);
-
       if (colLength !== N) {
         throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (colLength | 0));
       }
+      var f = flatten(col);
 
-      var f = flatten(col); // push a value to each row
-
+      // push a value to each row
       for (var _i = 0; _i < N; _i++) {
         result[_i].push(f[_i]);
       }
     }
-
     return result;
   }
-
   function checkVectorTypeAndReturnLength(vec) {
     var s = size(vec);
-
     if (s.length === 1) {
       // 1D vector
       return s[0];

package/lib/esm/function/matrix/matrixFromFunction.js

@@ -7,7 +7,6 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
     matrix,
     isZero
   } = _ref;
-
   /**
    * Create a matrix by evaluating a generating function at each index.
    * The simplest overload returns a multi-dimensional array as long as `size` is an array.
@@ -57,16 +56,13 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
       return _create(size, fn, format, datatype);
     }
   });
-
   function _create(size, fn, format, datatype) {
     var m;
-
     if (datatype !== undefined) {
       m = matrix(format, datatype);
     } else {
       m = matrix(format);
     }
-
     m.resize(size);
     m.forEach(function (_, index) {
       var val = fn(index);

package/lib/esm/function/matrix/matrixFromRows.js

@@ -8,7 +8,6 @@ export var createMatrixFromRows = /* #__PURE__ */factory(name, dependencies, _re
     flatten,
     size
   } = _ref;
-
   /**
    * Create a dense matrix from vectors as individual rows.
    * If you pass column vectors, they will be transposed (but not conjugated!)
@@ -37,31 +36,26 @@ export var createMatrixFromRows = /* #__PURE__ */factory(name, dependencies, _re
     },
     '...Matrix': function Matrix(arr) {
       return matrix(_createArray(arr.map(m => m.toArray())));
-    } // TODO implement this properly for SparseMatrix
+    }
 
+    // TODO implement this properly for SparseMatrix
   });
 
   function _createArray(arr) {
     if (arr.length === 0) throw new TypeError('At least one row is needed to construct a matrix.');
     var N = checkVectorTypeAndReturnLength(arr[0]);
     var result = [];
-
     for (var row of arr) {
       var rowLength = checkVectorTypeAndReturnLength(row);
-
       if (rowLength !== N) {
         throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (rowLength | 0));
       }
-
       result.push(flatten(row));
     }
-
     return result;
   }
-
   function checkVectorTypeAndReturnLength(vec) {
     var s = size(vec);
-
     if (s.length === 1) {
       // 1D vector
       return s[0];