mathjs-min 11.7.2

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

@@ -0,0 +1,184 @@
+import { isMatrix } from '../../utils/is.js';
+import { arraySize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { format } from '../../utils/string.js';
+var name = 'inv';
+var dependencies = ['typed', 'matrix', 'divideScalar', 'addScalar', 'multiply', 'unaryMinus', 'det', 'identity', 'abs'];
+export var createInv = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    divideScalar,
+    addScalar,
+    multiply,
+    unaryMinus,
+    det,
+    identity,
+    abs
+  } = _ref;
+  /**
+   * Calculate the inverse of a square matrix.
+   *
+   * Syntax:
+   *
+   *     math.inv(x)
+   *
+   * Examples:
+   *
+   *     math.inv([[1, 2], [3, 4]])  // returns [[-2, 1], [1.5, -0.5]]
+   *     math.inv(4)                 // returns 0.25
+   *     1 / 4                       // returns 0.25
+   *
+   * See also:
+   *
+   *     det, transpose
+   *
+   * @param {number | Complex | Array | Matrix} x     Matrix to be inversed
+   * @return {number | Complex | Array | Matrix} The inverse of `x`.
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(x) {
+      var size = isMatrix(x) ? x.size() : arraySize(x);
+      switch (size.length) {
+        case 1:
+          // vector
+          if (size[0] === 1) {
+            if (isMatrix(x)) {
+              return matrix([divideScalar(1, x.valueOf()[0])]);
+            } else {
+              return [divideScalar(1, x[0])];
+            }
+          } 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());
+              } else {
+                // return an Array
+                return _inv(x, rows, cols);
+              }
+            } else {
+              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) + ')');
+      }
+    },
+    any: function any(x) {
+      // scalar
+      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
+   * @param {number} rows     Number of rows
+   * @param {number} cols     Number of columns, must equal rows
+   * @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
+      // calculate inverse using gauss-jordan elimination
+      //      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
+      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];
+          A[r] = temp;
+          temp = B[c];
+          B[c] = B[r];
+          B[r] = temp;
+        }
+
+        // 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
+              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]));
+              }
+            }
+          } else {
+            // 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

@@ -0,0 +1,85 @@
+import { arraySize as size } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+var name = 'kron';
+var dependencies = ['typed', 'matrix', 'multiplyScalar'];
+export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    multiplyScalar
+  } = _ref;
+  /**
+     * Calculates the kronecker product of 2 matrices or vectors.
+     *
+     * NOTE: If a one dimensional vector / matrix is given, it will be
+     * wrapped so its two dimensions.
+     * See the examples.
+     *
+     * Syntax:
+     *
+     *    math.kron(x, y)
+     *
+     * Examples:
+     *
+     *    math.kron([[1, 0], [0, 1]], [[1, 2], [3, 4]])
+     *    // returns [ [ 1, 2, 0, 0 ], [ 3, 4, 0, 0 ], [ 0, 0, 1, 2 ], [ 0, 0, 3, 4 ] ]
+     *
+     *    math.kron([1,1], [2,3,4])
+     *    // returns [ [ 2, 3, 4, 2, 3, 4 ] ]
+     *
+     * See also:
+     *
+     *    multiply, dot, cross
+     *
+     * @param  {Array | Matrix} x     First vector
+     * @param  {Array | Matrix} y     Second vector
+     * @return {Array | Matrix}       Returns the kronecker product of `x` and `y`
+     */
+  return typed(name, {
+    'Matrix, Matrix': function MatrixMatrix(x, y) {
+      return matrix(_kron(x.toArray(), y.toArray()));
+    },
+    'Matrix, Array': function MatrixArray(x, y) {
+      return matrix(_kron(x.toArray(), y));
+    },
+    'Array, Matrix': function ArrayMatrix(x, y) {
+      return matrix(_kron(x, y.toArray()));
+    },
+    'Array, Array': _kron
+  });
+
+  /**
+     * Calculate the kronecker product of two matrices / vectors
+     * @param {Array} a  First vector
+     * @param {Array} b  Second vector
+     * @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) {
+      return b.map(function (b) {
+        r = [];
+        t.push(r);
+        return a.map(function (y) {
+          return b.map(function (x) {
+            return r.push(multiplyScalar(y, x));
+          });
+        });
+      });
+    }) && t;
+  }
+});

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

@@ -0,0 +1,105 @@
+import { maxArgumentCount } from '../../utils/function.js';
+import { factory } from '../../utils/factory.js';
+var name = 'map';
+var dependencies = ['typed'];
+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.
+   *
+   * 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:
+   *
+   *    math.map(x, callback)
+   *
+   * Examples:
+   *
+   *    math.map([1, 2, 3], function(value) {
+   *      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 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,
+    'Matrix, function': function MatrixFunction(x, callback) {
+      return x.map(callback);
+    }
+  });
+});
+
+/**
+ * Map for a multi dimensional array
+ * @param {Array} array
+ * @param {Function} callback
+ * @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) {
+        // we create a copy of the index array and append the new index value
+        return recurse(child, index.concat(i));
+      });
+    } else {
+      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;
+      }
+    }
+  };
+  return recurse(array, []);
+}

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

@@ -0,0 +1,89 @@
+import { factory } from '../../utils/factory.js';
+var name = 'matrixFromColumns';
+var dependencies = ['typed', 'matrix', 'flatten', 'size'];
+export var createMatrixFromColumns = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    flatten,
+    size
+  } = _ref;
+  /**
+   * Create a dense matrix from vectors as individual columns.
+   * If you pass row vectors, they will be transposed (but not conjugated!)
+   *
+   * Syntax:
+   *
+   *    math.matrixFromColumns(...arr)
+   *    math.matrixFromColumns(col1, col2)
+   *    math.matrixFromColumns(col1, col2, col3)
+   *
+   * Examples:
+   *
+   *    math.matrixFromColumns([1, 2, 3], [[4],[5],[6]])
+   *    math.matrixFromColumns(...vectors)
+   *
+   * See also:
+   *
+   *    matrix, matrixFromRows, matrixFromFunction, zeros
+   *
+   * @param {... Array | Matrix} cols Multiple columns
+   * @return { number[][] | Matrix } if at least one of the arguments is an array, an array will be returned
+   */
+  return typed(name, {
+    '...Array': function Array(arr) {
+      return _createArray(arr);
+    },
+    '...Matrix': function Matrix(arr) {
+      return matrix(_createArray(arr.map(m => m.toArray())));
+    }
+
+    // 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 result = [];
+    for (var i = 0; i < N; i++) {
+      result[i] = [];
+    }
+
+    // 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);
+
+      // 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];
+    } else if (s.length === 2) {
+      // 2D vector
+      if (s[0] === 1) {
+        // row vector
+        return s[1];
+      } else if (s[1] === 1) {
+        // col vector
+        return s[0];
+      } else {
+        throw new TypeError('At least one of the arguments is not a vector.');
+      }
+    } else {
+      throw new TypeError('Only one- or two-dimensional vectors are supported.');
+    }
+  }
+});

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

@@ -0,0 +1,74 @@
+import { factory } from '../../utils/factory.js';
+var name = 'matrixFromFunction';
+var dependencies = ['typed', 'matrix', 'isZero'];
+export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    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.
+   * Passing `size` as a Matrix or specifying a `format` will result in returning a Matrix.
+   *
+   * Syntax:
+   *
+   *    math.matrixFromFunction(size, fn)
+   *    math.matrixFromFunction(size, fn, format)
+   *    math.matrixFromFunction(size, fn, format, datatype)
+   *    math.matrixFromFunction(size, format, fn)
+   *    math.matrixFromFunction(size, format, datatype, fn)
+   *
+   * Examples:
+   *
+   *    math.matrixFromFunction([3,3], i => i[0] - i[1]) // an antisymmetric matrix
+   *    math.matrixFromFunction([100, 100], 'sparse', i => i[0] - i[1] === 1 ? 4 : 0) // a sparse subdiagonal matrix
+   *    math.matrixFromFunction([5], i => math.random()) // a random vector
+   *
+   * See also:
+   *
+   *    matrix, zeros
+   *
+   * @param {Array | Matrix} size   The size of the matrix to be created
+   * @param {function} fn           Callback function invoked for every entry in the matrix
+   * @param {string} [format]       The Matrix storage format, either `'dense'` or `'sparse'`
+   * @param {string} [datatype]     Type of the values
+   * @return {Array | Matrix} Returns the created matrix
+   */
+  return typed(name, {
+    'Array | Matrix, function, string, string': function ArrayMatrixFunctionStringString(size, fn, format, datatype) {
+      return _create(size, fn, format, datatype);
+    },
+    'Array | Matrix, function, string': function ArrayMatrixFunctionString(size, fn, format) {
+      return _create(size, fn, format);
+    },
+    'Matrix, function': function MatrixFunction(size, fn) {
+      return _create(size, fn, 'dense');
+    },
+    'Array, function': function ArrayFunction(size, fn) {
+      return _create(size, fn, 'dense').toArray();
+    },
+    'Array | Matrix, string, function': function ArrayMatrixStringFunction(size, format, fn) {
+      return _create(size, fn, format);
+    },
+    'Array | Matrix, string, string, function': function ArrayMatrixStringStringFunction(size, format, datatype, fn) {
+      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);
+      if (isZero(val)) return;
+      m.set(index, val);
+    });
+    return m;
+  }
+});

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

@@ -0,0 +1,77 @@
+import { factory } from '../../utils/factory.js';
+var name = 'matrixFromRows';
+var dependencies = ['typed', 'matrix', 'flatten', 'size'];
+export var createMatrixFromRows = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    flatten,
+    size
+  } = _ref;
+  /**
+   * Create a dense matrix from vectors as individual rows.
+   * If you pass column vectors, they will be transposed (but not conjugated!)
+   *
+   * Syntax:
+   *
+   *    math.matrixFromRows(...arr)
+   *    math.matrixFromRows(row1, row2)
+   *    math.matrixFromRows(row1, row2, row3)
+   *
+   * Examples:
+   *
+   *    math.matrixFromRows([1, 2, 3], [[4],[5],[6]])
+   *    math.matrixFromRows(...vectors)
+   *
+   * See also:
+   *
+   *    matrix, matrixFromColumns, matrixFromFunction, zeros
+   *
+   * @param {... Array | Matrix} rows  Multiple rows
+   * @return { number[][] | Matrix } if at least one of the arguments is an array, an array will be returned
+   */
+  return typed(name, {
+    '...Array': function Array(arr) {
+      return _createArray(arr);
+    },
+    '...Matrix': function Matrix(arr) {
+      return matrix(_createArray(arr.map(m => m.toArray())));
+    }
+
+    // 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];
+    } else if (s.length === 2) {
+      // 2D vector
+      if (s[0] === 1) {
+        // row vector
+        return s[1];
+      } else if (s[1] === 1) {
+        // col vector
+        return s[0];
+      } else {
+        throw new TypeError('At least one of the arguments is not a vector.');
+      }
+    } else {
+      throw new TypeError('Only one- or two-dimensional vectors are supported.');
+    }
+  }
+});