mathjs-min 11.7.2

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

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOnes = void 0;
+var _is = require("../../utils/is.js");
+var _number = require("../../utils/number.js");
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'ones';
+var dependencies = ['typed', 'config', 'matrix', 'BigNumber'];
+var createOnes = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    matrix = _ref.matrix,
+    BigNumber = _ref.BigNumber;
+  /**
+   * Create a matrix filled with ones. The created matrix can have one or
+   * multiple dimensions.
+   *
+   * Syntax:
+   *
+   *    math.ones(m)
+   *    math.ones(m, format)
+   *    math.ones(m, n)
+   *    math.ones(m, n, format)
+   *    math.ones([m, n])
+   *    math.ones([m, n], format)
+   *    math.ones([m, n, p, ...])
+   *    math.ones([m, n, p, ...], format)
+   *
+   * Examples:
+   *
+   *    math.ones()                    // returns []
+   *    math.ones(3)                   // returns [1, 1, 1]
+   *    math.ones(3, 2)                // returns [[1, 1], [1, 1], [1, 1]]
+   *    math.ones(3, 2, 'dense')       // returns Dense Matrix [[1, 1], [1, 1], [1, 1]]
+   *
+   *    const A = [[1, 2, 3], [4, 5, 6]]
+   *    math.ones(math.size(A))       // returns [[1, 1, 1], [1, 1, 1]]
+   *
+   * See also:
+   *
+   *    zeros, identity, size, range
+   *
+   * @param {...(number|BigNumber) | Array} size    The size of each dimension of the matrix
+   * @param {string} [format]           The Matrix storage format
+   *
+   * @return {Array | Matrix | number}  A matrix filled with ones
+   */
+  return typed('ones', {
+    '': function _() {
+      return config.matrix === 'Array' ? _ones([]) : _ones([], 'default');
+    },
+    // math.ones(m, n, p, ..., format)
+    // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
+    '...number | BigNumber | string': function numberBigNumberString(size) {
+      var last = size[size.length - 1];
+      if (typeof last === 'string') {
+        var format = size.pop();
+        return _ones(size, format);
+      } else if (config.matrix === 'Array') {
+        return _ones(size);
+      } else {
+        return _ones(size, 'default');
+      }
+    },
+    Array: _ones,
+    Matrix: function Matrix(size) {
+      var format = size.storage();
+      return _ones(size.valueOf(), format);
+    },
+    'Array | Matrix, string': function ArrayMatrixString(size, format) {
+      return _ones(size.valueOf(), format);
+    }
+  });
+
+  /**
+   * Create an Array or Matrix with ones
+   * @param {Array} size
+   * @param {string} [format='default']
+   * @return {Array | Matrix}
+   * @private
+   */
+  function _ones(size, format) {
+    var hasBigNumbers = _normalize(size);
+    var defaultValue = hasBigNumbers ? new BigNumber(1) : 1;
+    _validate(size);
+    if (format) {
+      // return a matrix
+      var m = matrix(format);
+      if (size.length > 0) {
+        return m.resize(size, defaultValue);
+      }
+      return m;
+    } else {
+      // return an Array
+      var arr = [];
+      if (size.length > 0) {
+        return (0, _array.resize)(arr, size, defaultValue);
+      }
+      return arr;
+    }
+  }
+
+  // replace BigNumbers with numbers, returns true if size contained BigNumbers
+  function _normalize(size) {
+    var hasBigNumbers = false;
+    size.forEach(function (value, index, arr) {
+      if ((0, _is.isBigNumber)(value)) {
+        hasBigNumbers = true;
+        arr[index] = value.toNumber();
+      }
+    });
+    return hasBigNumbers;
+  }
+
+  // validate arguments
+  function _validate(size) {
+    size.forEach(function (value) {
+      if (typeof value !== 'number' || !(0, _number.isInteger)(value) || value < 0) {
+        throw new Error('Parameters in function ones must be positive integers');
+      }
+    });
+  }
+});
+exports.createOnes = createOnes;

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

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPartitionSelect = void 0;
+var _is = require("../../utils/is.js");
+var _number = require("../../utils/number.js");
+var _factory = require("../../utils/factory.js");
+var name = 'partitionSelect';
+var dependencies = ['typed', 'isNumeric', 'isNaN', 'compare'];
+var createPartitionSelect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    isNumeric = _ref.isNumeric,
+    isNaN = _ref.isNaN,
+    compare = _ref.compare;
+  var asc = compare;
+  var desc = function desc(a, b) {
+    return -compare(a, b);
+  };
+
+  /**
+   * Partition-based selection of an array or 1D matrix.
+   * Will find the kth smallest value, and mutates the input array.
+   * Uses Quickselect.
+   *
+   * Syntax:
+   *
+   *    math.partitionSelect(x, k)
+   *    math.partitionSelect(x, k, compare)
+   *
+   * Examples:
+   *
+   *    math.partitionSelect([5, 10, 1], 2)                               // returns 10
+   *    math.partitionSelect(['C', 'B', 'A', 'D'], 1, math.compareText)   // returns 'B'
+   *
+   *    function sortByLength (a, b) {
+   *      return a.length - b.length
+   *    }
+   *    math.partitionSelect(['Langdon', 'Tom', 'Sara'], 2, sortByLength) // returns 'Langdon'
+   *
+   *    // the input array is mutated
+   *    arr = [5, 2, 1]
+   *    math.partitionSelect(arr, 0) // returns 1, arr is now: [1, 2, 5]
+   *    math.partitionSelect(arr, 1, 'desc') // returns 2, arr is now: [5, 2, 1]
+   *
+   * See also:
+   *
+   *    sort
+   *
+   * @param {Matrix | Array} x    A one dimensional matrix or array to sort
+   * @param {Number} k            The kth smallest value to be retrieved zero-based index
+   * @param {Function | 'asc' | 'desc'} [compare='asc']
+   *        An optional comparator function. The function is called as
+   *        `compare(a, b)`, and must return 1 when a > b, -1 when a < b,
+   *        and 0 when a == b.
+   * @return {*} Returns the kth lowest value.
+   */
+  return typed(name, {
+    'Array | Matrix, number': function ArrayMatrixNumber(x, k) {
+      return _partitionSelect(x, k, asc);
+    },
+    'Array | Matrix, number, string': function ArrayMatrixNumberString(x, k, compare) {
+      if (compare === 'asc') {
+        return _partitionSelect(x, k, asc);
+      } else if (compare === 'desc') {
+        return _partitionSelect(x, k, desc);
+      } else {
+        throw new Error('Compare string must be "asc" or "desc"');
+      }
+    },
+    'Array | Matrix, number, function': _partitionSelect
+  });
+  function _partitionSelect(x, k, compare) {
+    if (!(0, _number.isInteger)(k) || k < 0) {
+      throw new Error('k must be a non-negative integer');
+    }
+    if ((0, _is.isMatrix)(x)) {
+      var size = x.size();
+      if (size.length > 1) {
+        throw new Error('Only one dimensional matrices supported');
+      }
+      return quickSelect(x.valueOf(), k, compare);
+    }
+    if (Array.isArray(x)) {
+      return quickSelect(x, k, compare);
+    }
+  }
+
+  /**
+   * Quickselect algorithm.
+   * Code adapted from:
+   * https://blog.teamleadnet.com/2012/07/quick-select-algorithm-find-kth-element.html
+   *
+   * @param {Array} arr
+   * @param {Number} k
+   * @param {Function} compare
+   * @private
+   */
+  function quickSelect(arr, k, compare) {
+    if (k >= arr.length) {
+      throw new Error('k out of bounds');
+    }
+
+    // check for NaN values since these can cause an infinite while loop
+    for (var i = 0; i < arr.length; i++) {
+      if (isNumeric(arr[i]) && isNaN(arr[i])) {
+        return arr[i]; // return NaN
+      }
+    }
+
+    var from = 0;
+    var to = arr.length - 1;
+
+    // if from == to we reached the kth element
+    while (from < to) {
+      var r = from;
+      var w = to;
+      var pivot = arr[Math.floor(Math.random() * (to - from + 1)) + from];
+
+      // stop if the reader and writer meets
+      while (r < w) {
+        // arr[r] >= pivot
+        if (compare(arr[r], pivot) >= 0) {
+          // put the large values at the end
+          var tmp = arr[w];
+          arr[w] = arr[r];
+          arr[r] = tmp;
+          --w;
+        } else {
+          // the value is smaller than the pivot, skip
+          ++r;
+        }
+      }
+
+      // if we stepped up (r++) we need to step one down (arr[r] > pivot)
+      if (compare(arr[r], pivot) > 0) {
+        --r;
+      }
+
+      // the r pointer is on the end of the first k elements
+      if (k <= r) {
+        to = r;
+      } else {
+        from = r + 1;
+      }
+    }
+    return arr[k];
+  }
+});
+exports.createPartitionSelect = createPartitionSelect;

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

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPinv = void 0;
+var _is = require("../../utils/is.js");
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var _string = require("../../utils/string.js");
+var _object = require("../../utils/object.js");
+var name = 'pinv';
+var dependencies = ['typed', 'matrix', 'inv', 'deepEqual', 'equal', 'dotDivide', 'dot', 'ctranspose', 'divideScalar', 'multiply', 'add', 'Complex'];
+var createPinv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    inv = _ref.inv,
+    deepEqual = _ref.deepEqual,
+    equal = _ref.equal,
+    dotDivide = _ref.dotDivide,
+    dot = _ref.dot,
+    ctranspose = _ref.ctranspose,
+    divideScalar = _ref.divideScalar,
+    multiply = _ref.multiply,
+    add = _ref.add,
+    Complex = _ref.Complex;
+  /**
+   * Calculate the Moore–Penrose inverse of a matrix.
+   *
+   * Syntax:
+   *
+   *     math.pinv(x)
+   *
+   * Examples:
+   *
+   *     math.pinv([[1, 2], [3, 4]])          // returns [[-2, 1], [1.5, -0.5]]
+   *     math.pinv([[1, 0], [0, 1], [0, 1]])  // returns [[1, 0, 0], [0, 0.5, 0.5]]
+   *     math.pinv(4)                         // returns 0.25
+   *
+   * See also:
+   *
+   *     inv
+   *
+   * @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 = (0, _is.isMatrix)(x) ? x.size() : (0, _array.arraySize)(x);
+      switch (size.length) {
+        case 1:
+          // vector
+          if (_isZeros(x)) return ctranspose(x); // null vector
+          if (size[0] === 1) {
+            return inv(x); // invertible matrix
+          } else {
+            return dotDivide(ctranspose(x), dot(x, x));
+          }
+        case 2:
+          // two dimensional array
+          {
+            if (_isZeros(x)) return ctranspose(x); // zero matrixx
+            var rows = size[0];
+            var cols = size[1];
+            if (rows === cols) {
+              try {
+                return inv(x); // invertible matrix
+              } catch (err) {
+                if (err instanceof Error && err.message.match(/Cannot calculate inverse, determinant is zero/)) {
+                  // Expected
+                } else {
+                  throw err;
+                }
+              }
+            }
+            if ((0, _is.isMatrix)(x)) {
+              return matrix(_pinv(x.valueOf(), rows, cols), x.storage());
+            } else {
+              // return an Array
+              return _pinv(x, rows, cols);
+            }
+          }
+        default:
+          // multi dimensional array
+          throw new RangeError('Matrix must be two dimensional ' + '(size: ' + (0, _string.format)(size) + ')');
+      }
+    },
+    any: function any(x) {
+      // scalar
+      if (equal(x, 0)) return (0, _object.clone)(x); // zero
+      return divideScalar(1, x);
+    }
+  });
+
+  /**
+   * Calculate the Moore–Penrose inverse of a matrix
+   * @param {Array[]} mat     A matrix
+   * @param {number} rows     Number of rows
+   * @param {number} cols     Number of columns
+   * @return {Array[]} pinv    Pseudoinverse matrix
+   * @private
+   */
+  function _pinv(mat, rows, cols) {
+    var _rankFact2 = _rankFact(mat, rows, cols),
+      C = _rankFact2.C,
+      F = _rankFact2.F; // TODO: Use SVD instead (may improve precision)
+    var Cpinv = multiply(inv(multiply(ctranspose(C), C)), ctranspose(C));
+    var Fpinv = multiply(ctranspose(F), inv(multiply(F, ctranspose(F))));
+    return multiply(Fpinv, Cpinv);
+  }
+
+  /**
+   * Calculate the reduced row echelon form of a matrix
+   *
+   * Modified from https://rosettacode.org/wiki/Reduced_row_echelon_form
+   *
+   * @param {Array[]} mat     A matrix
+   * @param {number} rows     Number of rows
+   * @param {number} cols     Number of columns
+   * @return {Array[]}        Reduced row echelon form
+   * @private
+   */
+  function _rref(mat, rows, cols) {
+    var M = (0, _object.clone)(mat);
+    var lead = 0;
+    for (var r = 0; r < rows; r++) {
+      if (cols <= lead) {
+        return M;
+      }
+      var i = r;
+      while (_isZero(M[i][lead])) {
+        i++;
+        if (rows === i) {
+          i = r;
+          lead++;
+          if (cols === lead) {
+            return M;
+          }
+        }
+      }
+      var _ref2 = [M[r], M[i]];
+      M[i] = _ref2[0];
+      M[r] = _ref2[1];
+      var val = M[r][lead];
+      for (var j = 0; j < cols; j++) {
+        M[r][j] = dotDivide(M[r][j], val);
+      }
+      for (var _i = 0; _i < rows; _i++) {
+        if (_i === r) continue;
+        val = M[_i][lead];
+        for (var _j = 0; _j < cols; _j++) {
+          M[_i][_j] = add(M[_i][_j], multiply(-1, multiply(val, M[r][_j])));
+        }
+      }
+      lead++;
+    }
+    return M;
+  }
+
+  /**
+   * Calculate the rank factorization of a matrix
+   *
+   * @param {Array[]} mat                  A matrix (M)
+   * @param {number} rows                  Number of rows
+   * @param {number} cols                  Number of columns
+   * @return {{C: Array, F: Array}}        rank factorization where M = C F
+   * @private
+   */
+  function _rankFact(mat, rows, cols) {
+    var rref = _rref(mat, rows, cols);
+    var C = mat.map(function (_, i) {
+      return _.filter(function (_, j) {
+        return j < rows && !_isZero(dot(rref[j], rref[j]));
+      });
+    });
+    var F = rref.filter(function (_, i) {
+      return !_isZero(dot(rref[i], rref[i]));
+    });
+    return {
+      C: C,
+      F: F
+    };
+  }
+  function _isZero(x) {
+    return equal(add(x, Complex(1, 1)), add(0, Complex(1, 1)));
+  }
+  function _isZeros(arr) {
+    return deepEqual(add(arr, Complex(1, 1)), add(multiply(arr, 0), Complex(1, 1)));
+  }
+});
+exports.createPinv = createPinv;