mathjs-min 11.7.2

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

@@ -0,0 +1,123 @@
+import { isBigNumber } from '../../utils/is.js';
+import { isInteger } from '../../utils/number.js';
+import { resize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+var name = 'ones';
+var dependencies = ['typed', 'config', 'matrix', 'BigNumber'];
+export var createOnes = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    matrix,
+    BigNumber
+  } = _ref;
+  /**
+   * 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 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 (isBigNumber(value)) {
+        hasBigNumbers = true;
+        arr[index] = value.toNumber();
+      }
+    });
+    return hasBigNumbers;
+  }
+
+  // validate arguments
+  function _validate(size) {
+    size.forEach(function (value) {
+      if (typeof value !== 'number' || !isInteger(value) || value < 0) {
+        throw new Error('Parameters in function ones must be positive integers');
+      }
+    });
+  }
+});

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

@@ -0,0 +1,144 @@
+import { isMatrix } from '../../utils/is.js';
+import { isInteger } from '../../utils/number.js';
+import { factory } from '../../utils/factory.js';
+var name = 'partitionSelect';
+var dependencies = ['typed', 'isNumeric', 'isNaN', 'compare'];
+export var createPartitionSelect = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isNumeric,
+    isNaN,
+    compare
+  } = _ref;
+  var asc = compare;
+  var desc = (a, b) => -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 (!isInteger(k) || k < 0) {
+      throw new Error('k must be a non-negative integer');
+    }
+    if (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];
+  }
+});

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

@@ -0,0 +1,179 @@
+import { isMatrix } from '../../utils/is.js';
+import { arraySize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { format } from '../../utils/string.js';
+import { clone } from '../../utils/object.js';
+var name = 'pinv';
+var dependencies = ['typed', 'matrix', 'inv', 'deepEqual', 'equal', 'dotDivide', 'dot', 'ctranspose', 'divideScalar', 'multiply', 'add', 'Complex'];
+export var createPinv = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    inv,
+    deepEqual,
+    equal,
+    dotDivide,
+    dot,
+    ctranspose,
+    divideScalar,
+    multiply,
+    add,
+    Complex
+  } = _ref;
+  /**
+   * 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 = isMatrix(x) ? x.size() : 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 (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: ' + format(size) + ')');
+      }
+    },
+    any: function any(x) {
+      // scalar
+      if (equal(x, 0)) return 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 {
+      C,
+      F
+    } = _rankFact(mat, rows, cols); // 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 = 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;
+          }
+        }
+      }
+      [M[i], M[r]] = [M[r], M[i]];
+      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((_, i) => _.filter((_, j) => j < rows && !_isZero(dot(rref[j], rref[j]))));
+    var F = rref.filter((_, i) => !_isZero(dot(rref[i], rref[i])));
+    return {
+      C,
+      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)));
+  }
+});

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

@@ -0,0 +1,258 @@
+import { factory } from '../../utils/factory.js';
+import { noBignumber, noMatrix } from '../../utils/noop.js';
+var name = 'range';
+var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq'];
+export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    matrix,
+    bignumber,
+    smaller,
+    smallerEq,
+    larger,
+    largerEq
+  } = _ref;
+  /**
+   * Create an array from a range.
+   * By default, the range end is excluded. This can be customized by providing
+   * an extra parameter `includeEnd`.
+   *
+   * Syntax:
+   *
+   *     math.range(str [, includeEnd])               // Create a range from a string,
+   *                                                  // where the string contains the
+   *                                                  // start, optional step, and end,
+   *                                                  // separated by a colon.
+   *     math.range(start, end [, includeEnd])        // Create a range with start and
+   *                                                  // end and a step size of 1.
+   *     math.range(start, end, step [, includeEnd])  // Create a range with start, step,
+   *                                                  // and end.
+   *
+   * Where:
+   *
+   * - `str: string`
+   *   A string 'start:end' or 'start:step:end'
+   * - `start: {number | BigNumber}`
+   *   Start of the range
+   * - `end: number | BigNumber`
+   *   End of the range, excluded by default, included when parameter includeEnd=true
+   * - `step: number | BigNumber`
+   *   Step size. Default value is 1.
+   * - `includeEnd: boolean`
+   *   Option to specify whether to include the end or not. False by default.
+   *
+   * Examples:
+   *
+   *     math.range(2, 6)        // [2, 3, 4, 5]
+   *     math.range(2, -3, -1)   // [2, 1, 0, -1, -2]
+   *     math.range('2:1:6')     // [2, 3, 4, 5]
+   *     math.range(2, 6, true)  // [2, 3, 4, 5, 6]
+   *
+   * See also:
+   *
+   *     ones, zeros, size, subset
+   *
+   * @param {*} args   Parameters describing the ranges `start`, `end`, and optional `step`.
+   * @return {Array | Matrix} range
+   */
+  return typed(name, {
+    // TODO: simplify signatures when typed-function supports default values and optional arguments
+
+    // TODO: a number or boolean should not be converted to string here
+    string: _strRange,
+    'string, boolean': _strRange,
+    'number, number': function numberNumber(start, end) {
+      return _out(_rangeEx(start, end, 1));
+    },
+    'number, number, number': function numberNumberNumber(start, end, step) {
+      return _out(_rangeEx(start, end, step));
+    },
+    'number, number, boolean': function numberNumberBoolean(start, end, includeEnd) {
+      return includeEnd ? _out(_rangeInc(start, end, 1)) : _out(_rangeEx(start, end, 1));
+    },
+    'number, number, number, boolean': function numberNumberNumberBoolean(start, end, step, includeEnd) {
+      return includeEnd ? _out(_rangeInc(start, end, step)) : _out(_rangeEx(start, end, step));
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(start, end) {
+      var BigNumber = start.constructor;
+      return _out(_bigRangeEx(start, end, new BigNumber(1)));
+    },
+    'BigNumber, BigNumber, BigNumber': function BigNumberBigNumberBigNumber(start, end, step) {
+      return _out(_bigRangeEx(start, end, step));
+    },
+    'BigNumber, BigNumber, boolean': function BigNumberBigNumberBoolean(start, end, includeEnd) {
+      var BigNumber = start.constructor;
+      return includeEnd ? _out(_bigRangeInc(start, end, new BigNumber(1))) : _out(_bigRangeEx(start, end, new BigNumber(1)));
+    },
+    'BigNumber, BigNumber, BigNumber, boolean': function BigNumberBigNumberBigNumberBoolean(start, end, step, includeEnd) {
+      return includeEnd ? _out(_bigRangeInc(start, end, step)) : _out(_bigRangeEx(start, end, step));
+    }
+  });
+  function _out(arr) {
+    if (config.matrix === 'Matrix') {
+      return matrix ? matrix(arr) : noMatrix();
+    }
+    return arr;
+  }
+  function _strRange(str, includeEnd) {
+    var r = _parse(str);
+    if (!r) {
+      throw new SyntaxError('String "' + str + '" is no valid range');
+    }
+    var fn;
+    if (config.number === 'BigNumber') {
+      if (bignumber === undefined) {
+        noBignumber();
+      }
+      fn = includeEnd ? _bigRangeInc : _bigRangeEx;
+      return _out(fn(bignumber(r.start), bignumber(r.end), bignumber(r.step)));
+    } else {
+      fn = includeEnd ? _rangeInc : _rangeEx;
+      return _out(fn(r.start, r.end, r.step));
+    }
+  }
+
+  /**
+   * Create a range with numbers. End is excluded
+   * @param {number} start
+   * @param {number} end
+   * @param {number} step
+   * @returns {Array} range
+   * @private
+   */
+  function _rangeEx(start, end, step) {
+    var array = [];
+    var x = start;
+    if (step > 0) {
+      while (smaller(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    } else if (step < 0) {
+      while (larger(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Create a range with numbers. End is included
+   * @param {number} start
+   * @param {number} end
+   * @param {number} step
+   * @returns {Array} range
+   * @private
+   */
+  function _rangeInc(start, end, step) {
+    var array = [];
+    var x = start;
+    if (step > 0) {
+      while (smallerEq(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    } else if (step < 0) {
+      while (largerEq(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Create a range with big numbers. End is excluded
+   * @param {BigNumber} start
+   * @param {BigNumber} end
+   * @param {BigNumber} step
+   * @returns {Array} range
+   * @private
+   */
+  function _bigRangeEx(start, end, step) {
+    var zero = bignumber(0);
+    var array = [];
+    var x = start;
+    if (step.gt(zero)) {
+      while (smaller(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    } else if (step.lt(zero)) {
+      while (larger(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Create a range with big numbers. End is included
+   * @param {BigNumber} start
+   * @param {BigNumber} end
+   * @param {BigNumber} step
+   * @returns {Array} range
+   * @private
+   */
+  function _bigRangeInc(start, end, step) {
+    var zero = bignumber(0);
+    var array = [];
+    var x = start;
+    if (step.gt(zero)) {
+      while (smallerEq(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    } else if (step.lt(zero)) {
+      while (largerEq(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Parse a string into a range,
+   * The string contains the start, optional step, and end, separated by a colon.
+   * If the string does not contain a valid range, null is returned.
+   * For example str='0:2:11'.
+   * @param {string} str
+   * @return {{start: number, end: number, step: number} | null} range Object containing properties start, end, step
+   * @private
+   */
+  function _parse(str) {
+    var args = str.split(':');
+
+    // number
+    var nums = args.map(function (arg) {
+      // use Number and not parseFloat as Number returns NaN on invalid garbage in the string
+      return Number(arg);
+    });
+    var invalid = nums.some(function (num) {
+      return isNaN(num);
+    });
+    if (invalid) {
+      return null;
+    }
+    switch (nums.length) {
+      case 2:
+        return {
+          start: nums[0],
+          end: nums[1],
+          step: 1
+        };
+      case 3:
+        return {
+          start: nums[0],
+          end: nums[2],
+          step: nums[1]
+        };
+      default:
+        return null;
+    }
+  }
+});