mathjs-min 11.7.2

package/lib/cjs/type/matrix/Matrix.js

@@ -0,0 +1,249 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatrixClass = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'Matrix';
+var dependencies = [];
+var createMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function () {
+  /**
+   * @constructor Matrix
+   *
+   * A Matrix is a wrapper around an Array. A matrix can hold a multi dimensional
+   * array. A matrix can be constructed as:
+   *
+   *     let matrix = math.matrix(data)
+   *
+   * Matrix contains the functions to resize, get and set values, get the size,
+   * clone the matrix and to convert the matrix to a vector, array, or scalar.
+   * Furthermore, one can iterate over the matrix using map and forEach.
+   * The internal Array of the Matrix can be accessed using the function valueOf.
+   *
+   * Example usage:
+   *
+   *     let matrix = math.matrix([[1, 2], [3, 4]])
+   *     matix.size()              // [2, 2]
+   *     matrix.resize([3, 2], 5)
+   *     matrix.valueOf()          // [[1, 2], [3, 4], [5, 5]]
+   *     matrix.subset([1,2])       // 3 (indexes are zero-based)
+   *
+   */
+  function Matrix() {
+    if (!(this instanceof Matrix)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+  }
+
+  /**
+   * Attach type information
+   */
+  Matrix.prototype.type = 'Matrix';
+  Matrix.prototype.isMatrix = true;
+
+  /**
+   * Get the storage format used by the matrix.
+   *
+   * Usage:
+   *     const format = matrix.storage()   // retrieve storage format
+   *
+   * @return {string}           The storage format.
+   */
+  Matrix.prototype.storage = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke storage on a Matrix interface');
+  };
+
+  /**
+   * Get the datatype of the data stored in the matrix.
+   *
+   * Usage:
+   *     const format = matrix.datatype()    // retrieve matrix datatype
+   *
+   * @return {string}           The datatype.
+   */
+  Matrix.prototype.datatype = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke datatype on a Matrix interface');
+  };
+
+  /**
+   * Create a new Matrix With the type of the current matrix instance
+   * @param {Array | Object} data
+   * @param {string} [datatype]
+   */
+  Matrix.prototype.create = function (data, datatype) {
+    throw new Error('Cannot invoke create on a Matrix interface');
+  };
+
+  /**
+   * Get a subset of the matrix, or replace a subset of the matrix.
+   *
+   * Usage:
+   *     const subset = matrix.subset(index)               // retrieve subset
+   *     const value = matrix.subset(index, replacement)   // replace subset
+   *
+   * @param {Index} index
+   * @param {Array | Matrix | *} [replacement]
+   * @param {*} [defaultValue=0]      Default value, filled in on new entries when
+   *                                  the matrix is resized. If not provided,
+   *                                  new matrix elements will be filled with zeros.
+   */
+  Matrix.prototype.subset = function (index, replacement, defaultValue) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke subset on a Matrix interface');
+  };
+
+  /**
+   * Get a single element from the matrix.
+   * @param {number[]} index   Zero-based index
+   * @return {*} value
+   */
+  Matrix.prototype.get = function (index) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke get on a Matrix interface');
+  };
+
+  /**
+   * Replace a single element in the matrix.
+   * @param {number[]} index   Zero-based index
+   * @param {*} value
+   * @param {*} [defaultValue]        Default value, filled in on new entries when
+   *                                  the matrix is resized. If not provided,
+   *                                  new matrix elements will be left undefined.
+   * @return {Matrix} self
+   */
+  Matrix.prototype.set = function (index, value, defaultValue) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke set on a Matrix interface');
+  };
+
+  /**
+   * Resize the matrix to the given size. Returns a copy of the matrix when
+   * `copy=true`, otherwise return the matrix itself (resize in place).
+   *
+   * @param {number[]} size           The new size the matrix should have.
+   * @param {*} [defaultValue=0]      Default value, filled in on new entries.
+   *                                  If not provided, the matrix elements will
+   *                                  be filled with zeros.
+   * @param {boolean} [copy]          Return a resized copy of the matrix
+   *
+   * @return {Matrix}                 The resized matrix
+   */
+  Matrix.prototype.resize = function (size, defaultValue) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke resize on a Matrix interface');
+  };
+
+  /**
+   * Reshape the matrix to the given size. Returns a copy of the matrix when
+   * `copy=true`, otherwise return the matrix itself (reshape in place).
+   *
+   * @param {number[]} size           The new size the matrix should have.
+   * @param {boolean} [copy]          Return a reshaped copy of the matrix
+   *
+   * @return {Matrix}                 The reshaped matrix
+   */
+  Matrix.prototype.reshape = function (size, defaultValue) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke reshape on a Matrix interface');
+  };
+
+  /**
+   * Create a clone of the matrix
+   * @return {Matrix} clone
+   */
+  Matrix.prototype.clone = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke clone on a Matrix interface');
+  };
+
+  /**
+   * Retrieve the size of the matrix.
+   * @returns {number[]} size
+   */
+  Matrix.prototype.size = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke size on a Matrix interface');
+  };
+
+  /**
+   * Create a new matrix with the results of the callback function executed on
+   * each entry of the matrix.
+   * @param {Function} callback   The callback function is invoked with three
+   *                              parameters: the value of the element, the index
+   *                              of the element, and the Matrix being traversed.
+   * @param {boolean} [skipZeros] Invoke callback function for non-zero values only.
+   *
+   * @return {Matrix} matrix
+   */
+  Matrix.prototype.map = function (callback, skipZeros) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke map on a Matrix interface');
+  };
+
+  /**
+   * Execute a callback function on each entry of the matrix.
+   * @param {Function} callback   The callback function is invoked with three
+   *                              parameters: the value of the element, the index
+   *                              of the element, and the Matrix being traversed.
+   */
+  Matrix.prototype.forEach = function (callback) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke forEach on a Matrix interface');
+  };
+
+  /**
+   * Iterate over the matrix elements
+   * @return {Iterable<{ value, index: number[] }>}
+   */
+  Matrix.prototype[Symbol.iterator] = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot iterate a Matrix interface');
+  };
+
+  /**
+   * Create an Array with a copy of the data of the Matrix
+   * @returns {Array} array
+   */
+  Matrix.prototype.toArray = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke toArray on a Matrix interface');
+  };
+
+  /**
+   * Get the primitive value of the Matrix: a multidimensional array
+   * @returns {Array} array
+   */
+  Matrix.prototype.valueOf = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke valueOf on a Matrix interface');
+  };
+
+  /**
+   * Get a string representation of the matrix, with optional formatting options.
+   * @param {Object | number | Function} [options]  Formatting options. See
+   *                                                lib/utils/number:format for a
+   *                                                description of the available
+   *                                                options.
+   * @returns {string} str
+   */
+  Matrix.prototype.format = function (options) {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke format on a Matrix interface');
+  };
+
+  /**
+   * Get a string representation of the matrix
+   * @returns {string} str
+   */
+  Matrix.prototype.toString = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot invoke toString on a Matrix interface');
+  };
+  return Matrix;
+}, {
+  isClass: true
+});
+exports.createMatrixClass = createMatrixClass;

package/lib/cjs/type/matrix/MatrixIndex.js

@@ -0,0 +1,271 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIndexClass = void 0;
+var _is = require("../../utils/is.js");
+var _object = require("../../utils/object.js");
+var _number = require("../../utils/number.js");
+var _factory = require("../../utils/factory.js");
+var name = 'Index';
+var dependencies = ['ImmutableDenseMatrix'];
+var createIndexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var ImmutableDenseMatrix = _ref.ImmutableDenseMatrix;
+  /**
+   * Create an index. An Index can store ranges and sets for multiple dimensions.
+   * Matrix.get, Matrix.set, and math.subset accept an Index as input.
+   *
+   * Usage:
+   *     const index = new Index(range1, range2, matrix1, array1, ...)
+   *
+   * Where each parameter can be any of:
+   *     A number
+   *     A string (containing a name of an object property)
+   *     An instance of Range
+   *     An Array with the Set values
+   *     A Matrix with the Set values
+   *
+   * The parameters start, end, and step must be integer numbers.
+   *
+   * @class Index
+   * @Constructor Index
+   * @param {...*} ranges
+   */
+  function Index(ranges) {
+    if (!(this instanceof Index)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+    this._dimensions = [];
+    this._isScalar = true;
+    for (var i = 0, ii = arguments.length; i < ii; i++) {
+      var arg = arguments[i];
+      if ((0, _is.isRange)(arg)) {
+        this._dimensions.push(arg);
+        this._isScalar = false;
+      } else if (Array.isArray(arg) || (0, _is.isMatrix)(arg)) {
+        // create matrix
+        var m = _createImmutableMatrix(arg.valueOf());
+        this._dimensions.push(m);
+        // size
+        var size = m.size();
+        // scalar
+        if (size.length !== 1 || size[0] !== 1) {
+          this._isScalar = false;
+        }
+      } else if (typeof arg === 'number') {
+        this._dimensions.push(_createImmutableMatrix([arg]));
+      } else if (typeof arg === 'string') {
+        // object property (arguments.count should be 1)
+        this._dimensions.push(arg);
+      } else {
+        throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
+      }
+      // TODO: implement support for wildcard '*'
+    }
+  }
+
+  /**
+   * Attach type information
+   */
+  Index.prototype.type = 'Index';
+  Index.prototype.isIndex = true;
+  function _createImmutableMatrix(arg) {
+    // loop array elements
+    for (var i = 0, l = arg.length; i < l; i++) {
+      if (typeof arg[i] !== 'number' || !(0, _number.isInteger)(arg[i])) {
+        throw new TypeError('Index parameters must be positive integer numbers');
+      }
+    }
+    // create matrix
+    return new ImmutableDenseMatrix(arg);
+  }
+
+  /**
+   * Create a clone of the index
+   * @memberof Index
+   * @return {Index} clone
+   */
+  Index.prototype.clone = function () {
+    var index = new Index();
+    index._dimensions = (0, _object.clone)(this._dimensions);
+    index._isScalar = this._isScalar;
+    return index;
+  };
+
+  /**
+   * Create an index from an array with ranges/numbers
+   * @memberof Index
+   * @param {Array.<Array | number>} ranges
+   * @return {Index} index
+   * @private
+   */
+  Index.create = function (ranges) {
+    var index = new Index();
+    Index.apply(index, ranges);
+    return index;
+  };
+
+  /**
+   * Retrieve the size of the index, the number of elements for each dimension.
+   * @memberof Index
+   * @returns {number[]} size
+   */
+  Index.prototype.size = function () {
+    var size = [];
+    for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
+      var d = this._dimensions[i];
+      size[i] = typeof d === 'string' ? 1 : d.size()[0];
+    }
+    return size;
+  };
+
+  /**
+   * Get the maximum value for each of the indexes ranges.
+   * @memberof Index
+   * @returns {number[]} max
+   */
+  Index.prototype.max = function () {
+    var values = [];
+    for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
+      var range = this._dimensions[i];
+      values[i] = typeof range === 'string' ? range : range.max();
+    }
+    return values;
+  };
+
+  /**
+   * Get the minimum value for each of the indexes ranges.
+   * @memberof Index
+   * @returns {number[]} min
+   */
+  Index.prototype.min = function () {
+    var values = [];
+    for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
+      var range = this._dimensions[i];
+      values[i] = typeof range === 'string' ? range : range.min();
+    }
+    return values;
+  };
+
+  /**
+   * Loop over each of the ranges of the index
+   * @memberof Index
+   * @param {Function} callback   Called for each range with a Range as first
+   *                              argument, the dimension as second, and the
+   *                              index object as third.
+   */
+  Index.prototype.forEach = function (callback) {
+    for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
+      callback(this._dimensions[i], i, this);
+    }
+  };
+
+  /**
+   * Retrieve the dimension for the given index
+   * @memberof Index
+   * @param {Number} dim                  Number of the dimension
+   * @returns {Range | null} range
+   */
+  Index.prototype.dimension = function (dim) {
+    return this._dimensions[dim] || null;
+  };
+
+  /**
+   * Test whether this index contains an object property
+   * @returns {boolean} Returns true if the index is an object property
+   */
+  Index.prototype.isObjectProperty = function () {
+    return this._dimensions.length === 1 && typeof this._dimensions[0] === 'string';
+  };
+
+  /**
+   * Returns the object property name when the Index holds a single object property,
+   * else returns null
+   * @returns {string | null}
+   */
+  Index.prototype.getObjectProperty = function () {
+    return this.isObjectProperty() ? this._dimensions[0] : null;
+  };
+
+  /**
+   * Test whether this index contains only a single value.
+   *
+   * This is the case when the index is created with only scalar values as ranges,
+   * not for ranges resolving into a single value.
+   * @memberof Index
+   * @return {boolean} isScalar
+   */
+  Index.prototype.isScalar = function () {
+    return this._isScalar;
+  };
+
+  /**
+   * Expand the Index into an array.
+   * For example new Index([0,3], [2,7]) returns [[0,1,2], [2,3,4,5,6]]
+   * @memberof Index
+   * @returns {Array} array
+   */
+  Index.prototype.toArray = function () {
+    var array = [];
+    for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
+      var dimension = this._dimensions[i];
+      array.push(typeof dimension === 'string' ? dimension : dimension.toArray());
+    }
+    return array;
+  };
+
+  /**
+   * Get the primitive value of the Index, a two dimensional array.
+   * Equivalent to Index.toArray().
+   * @memberof Index
+   * @returns {Array} array
+   */
+  Index.prototype.valueOf = Index.prototype.toArray;
+
+  /**
+   * Get the string representation of the index, for example '[2:6]' or '[0:2:10, 4:7, [1,2,3]]'
+   * @memberof Index
+   * @returns {String} str
+   */
+  Index.prototype.toString = function () {
+    var strings = [];
+    for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
+      var dimension = this._dimensions[i];
+      if (typeof dimension === 'string') {
+        strings.push(JSON.stringify(dimension));
+      } else {
+        strings.push(dimension.toString());
+      }
+    }
+    return '[' + strings.join(', ') + ']';
+  };
+
+  /**
+   * Get a JSON representation of the Index
+   * @memberof Index
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "Index", "ranges": [{"mathjs": "Range", start: 0, end: 10, step:1}, ...]}`
+   */
+  Index.prototype.toJSON = function () {
+    return {
+      mathjs: 'Index',
+      dimensions: this._dimensions
+    };
+  };
+
+  /**
+   * Instantiate an Index from a JSON object
+   * @memberof Index
+   * @param {Object} json A JSON object structured as:
+   *                     `{"mathjs": "Index", "dimensions": [{"mathjs": "Range", start: 0, end: 10, step:1}, ...]}`
+   * @return {Index}
+   */
+  Index.fromJSON = function (json) {
+    return Index.create(json.dimensions);
+  };
+  return Index;
+}, {
+  isClass: true
+});
+exports.createIndexClass = createIndexClass;