mathjs 8.1.0 → 12.2.1

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

@@ -1,17 +1,18 @@
 import { isIndex } from '../../utils/is.js';
 import { clone } from '../../utils/object.js';
-import { validateIndex } from '../../utils/array.js';
+import { isEmptyIndex, validateIndex, validateIndexSourceSize } from '../../utils/array.js';
 import { getSafeProperty, setSafeProperty } from '../../utils/customs.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
 var name = 'subset';
-var dependencies = ['typed', 'matrix'];
-export var createSubset = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', 'matrix', 'zeros', 'add'];
+export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
-    matrix
+    matrix,
+    zeros,
+    add
   } = _ref;
-
   /**
    * Get or set a subset of a matrix or string.
    *
@@ -23,21 +24,33 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    *
    *     // get a subset
    *     const d = [[1, 2], [3, 4]]
-   *     math.subset(d, math.index(1, 0))        // returns 3
-   *     math.subset(d, math.index([0, 1], 1))   // returns [[2], [4]]
+   *     math.subset(d, math.index(1, 0))             // returns 3
+   *     math.subset(d, math.index([0, 1], 1))        // returns [[2], [4]]
+   *     math.subset(d, math.index([false, true], 0)) // returns [[3]]
    *
    *     // replace a subset
    *     const e = []
-   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]]
-   *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 6], [0, 7]]
+   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 0, 6]]
+   *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 0, 6], [0, 7, 0]]
+   *     math.subset(g, math.index([false, true], 1), 8)          // returns [[5, 0, 6], [0, 8, 0]]
+   *
+   *     // get submatrix using ranges
+   *     const M = [
+   *       [1,2,3],
+   *       [4,5,6],
+   *       [7,8,9]
+   *     ]
+   *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1, 2, 3], [4, 5, 6]]
    *
    * See also:
    *
    *     size, resize, squeeze, index
    *
    * @param {Array | Matrix | string} matrix  An array, matrix, or string
-   * @param {Index} index                     An index containing ranges for each
-   *                                          dimension
+   * @param {Index} index
+   *    For each dimension of the target, specifies an index or a list of
+   *    indices to fetch or set. `subset` uses the cartesian product of
+   *    the indices specified in each dimension.
    * @param {*} [replacement]                 An array, matrix, or scalar.
    *                                          If provided, the subset is replaced with replacement.
    *                                          If not provided, the subset is returned
@@ -46,56 +59,101 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    *                                          math.matrix elements will be left undefined.
    * @return {Array | Matrix | string} Either the retrieved subset or the updated matrix.
    */
+
   return typed(name, {
     // get subset
-    'Array, Index': function ArrayIndex(value, index) {
-      var m = matrix(value);
-      var subset = m.subset(index); // returns a Matrix
-
-      return index.isScalar() ? subset : subset.valueOf(); // return an Array (like the input)
-    },
     'Matrix, Index': function MatrixIndex(value, index) {
+      if (isEmptyIndex(index)) {
+        return matrix();
+      }
+      validateIndexSourceSize(value, index);
       return value.subset(index);
     },
+    'Array, Index': typed.referTo('Matrix, Index', function (subsetRef) {
+      return function (value, index) {
+        var subsetResult = subsetRef(matrix(value), index);
+        return index.isScalar() ? subsetResult : subsetResult.valueOf();
+      };
+    }),
     'Object, Index': _getObjectProperty,
     'string, Index': _getSubstring,
     // set subset
-    'Array, Index, any': function ArrayIndexAny(value, index, replacement) {
-      return matrix(clone(value)).subset(index, replacement, undefined).valueOf();
-    },
-    'Array, Index, any, any': function ArrayIndexAnyAny(value, index, replacement, defaultValue) {
-      return matrix(clone(value)).subset(index, replacement, defaultValue).valueOf();
-    },
-    'Matrix, Index, any': function MatrixIndexAny(value, index, replacement) {
-      return value.clone().subset(index, replacement);
-    },
     'Matrix, Index, any, any': function MatrixIndexAnyAny(value, index, replacement, defaultValue) {
-      return value.clone().subset(index, replacement, defaultValue);
+      if (isEmptyIndex(index)) {
+        return value;
+      }
+      validateIndexSourceSize(value, index);
+      return value.clone().subset(index, _broadcastReplacement(replacement, index), defaultValue);
     },
+    'Array, Index, any, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement, defaultValue) {
+        var subsetResult = subsetRef(matrix(value), index, replacement, defaultValue);
+        return subsetResult.isMatrix ? subsetResult.valueOf() : subsetResult;
+      };
+    }),
+    'Array, Index, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement) {
+        return subsetRef(matrix(value), index, replacement, undefined).valueOf();
+      };
+    }),
+    'Matrix, Index, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement) {
+        return subsetRef(value, index, replacement, undefined);
+      };
+    }),
     'string, Index, string': _setSubstring,
     'string, Index, string, string': _setSubstring,
     'Object, Index, any': _setObjectProperty
   });
+
+  /**
+   * Broadcasts a replacment value to be the same size as index
+   * @param {number | BigNumber | Array | Matrix} replacement Replacement value to try to broadcast
+   * @param {*} index Index value
+   * @returns broadcasted replacement that matches the size of index
+   */
+
+  function _broadcastReplacement(replacement, index) {
+    if (typeof replacement === 'string') {
+      throw new Error('can\'t boradcast a string');
+    }
+    if (index._isScalar) {
+      return replacement;
+    }
+    var indexSize = index.size();
+    if (indexSize.every(d => d > 0)) {
+      try {
+        return add(replacement, zeros(indexSize));
+      } catch (error) {
+        return replacement;
+      }
+    } else {
+      return replacement;
+    }
+  }
 });
+
 /**
  * Retrieve a subset of a string
  * @param {string} str            string from which to get a substring
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @returns {string} substring
  * @private
  */
-
 function _getSubstring(str, index) {
   if (!isIndex(index)) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
-
+  if (isEmptyIndex(index)) {
+    return '';
+  }
+  validateIndexSourceSize(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new DimensionError(index.size().length, 1);
-  } // validate whether the range is out of range
-
+  }
 
+  // validate whether the range is out of range
   var strLen = str.length;
   validateIndex(index.min()[0], strLen);
   validateIndex(index.max()[0], strLen);
@@ -106,28 +164,29 @@ function _getSubstring(str, index) {
   });
   return substr;
 }
+
 /**
  * Replace a substring in a string
  * @param {string} str            string to be replaced
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @param {string} replacement    Replacement string
- * @param {string} [defaultValue] Default value to be uses when resizing
+ * @param {string} [defaultValue] Default value to be used when resizing
  *                                the string. is ' ' by default
  * @returns {string} result
  * @private
  */
-
-
 function _setSubstring(str, index, replacement, defaultValue) {
   if (!index || index.isIndex !== true) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
-
+  if (isEmptyIndex(index)) {
+    return str;
+  }
+  validateIndexSourceSize(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new DimensionError(index.size().length, 1);
   }
-
   if (defaultValue !== undefined) {
     if (typeof defaultValue !== 'string' || defaultValue.length !== 1) {
       throw new TypeError('Single character expected as defaultValue');
@@ -135,29 +194,27 @@ function _setSubstring(str, index, replacement, defaultValue) {
   } else {
     defaultValue = ' ';
   }
-
   var range = index.dimension(0);
   var len = range.size()[0];
-
   if (len !== replacement.length) {
     throw new DimensionError(range.size()[0], replacement.length);
-  } // validate whether the range is out of range
-
+  }
 
+  // validate whether the range is out of range
   var strLen = str.length;
   validateIndex(index.min()[0]);
-  validateIndex(index.max()[0]); // copy the string into an array with characters
+  validateIndex(index.max()[0]);
 
+  // copy the string into an array with characters
   var chars = [];
-
   for (var i = 0; i < strLen; i++) {
     chars[i] = str.charAt(i);
   }
-
   range.forEach(function (v, i) {
     chars[v] = replacement.charAt(i[0]);
-  }); // initialize undefined characters with a space
+  });
 
+  // initialize undefined characters with a space
   if (chars.length > strLen) {
     for (var _i = strLen - 1, _len = chars.length; _i < _len; _i++) {
       if (!chars[_i]) {
@@ -165,9 +222,9 @@ function _setSubstring(str, index, replacement, defaultValue) {
       }
     }
   }
-
   return chars.join('');
 }
+
 /**
  * Retrieve a property from an object
  * @param {Object} object
@@ -175,21 +232,20 @@ function _setSubstring(str, index, replacement, defaultValue) {
  * @return {*} Returns the value of the property
  * @private
  */
-
-
 function _getObjectProperty(object, index) {
+  if (isEmptyIndex(index)) {
+    return undefined;
+  }
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }
-
   var key = index.dimension(0);
-
   if (typeof key !== 'string') {
     throw new TypeError('String expected as index to retrieve an object property');
   }
-
   return getSafeProperty(object, key);
 }
+
 /**
  * Set a property on an object
  * @param {Object} object
@@ -198,20 +254,19 @@ function _getObjectProperty(object, index) {
  * @return {*} Returns the updated object
  * @private
  */
-
-
 function _setObjectProperty(object, index, replacement) {
+  if (isEmptyIndex(index)) {
+    return object;
+  }
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }
-
   var key = index.dimension(0);
-
   if (typeof key !== 'string') {
     throw new TypeError('String expected as index to retrieve an object property');
-  } // clone the object, and apply the property to the clone
-
+  }
 
+  // clone the object, and apply the property to the clone
   var updated = clone(object);
   setSafeProperty(updated, key, replacement);
   return updated;

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

@@ -3,13 +3,12 @@ import { format } from '../../utils/string.js';
 import { factory } from '../../utils/factory.js';
 var name = 'trace';
 var dependencies = ['typed', 'matrix', 'add'];
-export var createTrace = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createTrace = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     add
   } = _ref;
-
   /**
    * Calculate the trace of a matrix: the sum of the elements on the main
    * diagonal of a square matrix.
@@ -46,12 +45,12 @@ export var createTrace = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     DenseMatrix: _denseTrace,
     any: clone
   });
-
   function _denseTrace(m) {
     // matrix size & data
     var size = m._size;
-    var data = m._data; // process dimensions
+    var data = m._data;
 
+    // process dimensions
     switch (size.length) {
       case 1:
         // vector
@@ -59,80 +58,71 @@ export var createTrace = /* #__PURE__ */factory(name, dependencies, (_ref) => {
           // return data[0]
           return clone(data[0]);
         }
-
         throw new RangeError('Matrix must be square (size: ' + format(size) + ')');
-
       case 2:
         {
           // two dimensional
           var rows = size[0];
           var cols = size[1];
-
           if (rows === cols) {
             // calulate sum
-            var sum = 0; // loop diagonal
-
+            var sum = 0;
+            // loop diagonal
             for (var i = 0; i < rows; i++) {
               sum = add(sum, data[i][i]);
-            } // return trace
-
-
+            }
+            // return trace
             return sum;
           } else {
             throw new RangeError('Matrix must be square (size: ' + format(size) + ')');
           }
         }
-
       default:
         // multi dimensional
         throw new RangeError('Matrix must be two dimensional (size: ' + format(size) + ')');
     }
   }
-
   function _sparseTrace(m) {
     // matrix arrays
     var values = m._values;
     var index = m._index;
     var ptr = m._ptr;
-    var size = m._size; // check dimensions
-
+    var size = m._size;
+    // check dimensions
     var rows = size[0];
-    var columns = size[1]; // matrix must be square
-
+    var columns = size[1];
+    // matrix must be square
     if (rows === columns) {
       // calulate sum
-      var sum = 0; // check we have data (avoid looping columns)
-
+      var sum = 0;
+      // check we have data (avoid looping columns)
       if (values.length > 0) {
         // loop columns
         for (var j = 0; j < columns; j++) {
           // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
           var k0 = ptr[j];
-          var k1 = ptr[j + 1]; // loop k within [k0, k1[
-
+          var k1 = ptr[j + 1];
+          // loop k within [k0, k1[
           for (var k = k0; k < k1; k++) {
             // row index
-            var i = index[k]; // check row
-
+            var i = index[k];
+            // check row
             if (i === j) {
               // accumulate value
-              sum = add(sum, values[k]); // exit loop
-
+              sum = add(sum, values[k]);
+              // exit loop
               break;
             }
-
             if (i > j) {
               // exit loop, no value on the diagonal for column j
               break;
             }
           }
         }
-      } // return trace
-
-
+      }
+      // return trace
       return sum;
     }
-
     throw new RangeError('Matrix must be square (size: ' + format(size) + ')');
   }
 });

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

@@ -3,12 +3,11 @@ import { format } from '../../utils/string.js';
 import { factory } from '../../utils/factory.js';
 var name = 'transpose';
 var dependencies = ['typed', 'matrix'];
-export var createTranspose = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createTranspose = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix
   } = _ref;
-
   /**
    * Transpose a matrix. All values of the matrix are reflected over its
    * main diagonal. Only applicable to two dimensional matrices containing
@@ -31,139 +30,125 @@ export var createTranspose = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @param {Array | Matrix} x  Matrix to be transposed
    * @return {Array | Matrix}   The transposed matrix
    */
-  return typed('transpose', {
-    Array: function Array(x) {
-      // use dense matrix implementation
-      return this(matrix(x)).valueOf();
-    },
-    Matrix: function Matrix(x) {
-      // matrix size
-      var size = x.size(); // result
-
-      var c; // process dimensions
-
-      switch (size.length) {
-        case 1:
-          // vector
-          c = x.clone();
-          break;
-
-        case 2:
-          {
-            // rows and columns
-            var rows = size[0];
-            var columns = size[1]; // check columns
-
-            if (columns === 0) {
-              // throw exception
-              throw new RangeError('Cannot transpose a 2D matrix with no columns (size: ' + format(size) + ')');
-            } // process storage format
-
-
-            switch (x.storage()) {
-              case 'dense':
-                c = _denseTranspose(x, rows, columns);
-                break;
-
-              case 'sparse':
-                c = _sparseTranspose(x, rows, columns);
-                break;
-            }
+  return typed(name, {
+    Array: x => transposeMatrix(matrix(x)).valueOf(),
+    Matrix: transposeMatrix,
+    any: clone // scalars
+  });
+  function transposeMatrix(x) {
+    // matrix size
+    var size = x.size();
+
+    // result
+    var c;
+
+    // process dimensions
+    switch (size.length) {
+      case 1:
+        // vector
+        c = x.clone();
+        break;
+      case 2:
+        {
+          // rows and columns
+          var rows = size[0];
+          var columns = size[1];
+
+          // check columns
+          if (columns === 0) {
+            // throw exception
+            throw new RangeError('Cannot transpose a 2D matrix with no columns (size: ' + format(size) + ')');
           }
-          break;
 
-        default:
-          // multi dimensional
-          throw new RangeError('Matrix must be a vector or two dimensional (size: ' + format(this._size) + ')');
-      }
-
-      return c;
-    },
-    // scalars
-    any: function any(x) {
-      return clone(x);
+          // process storage format
+          switch (x.storage()) {
+            case 'dense':
+              c = _denseTranspose(x, rows, columns);
+              break;
+            case 'sparse':
+              c = _sparseTranspose(x, rows, columns);
+              break;
+          }
+        }
+        break;
+      default:
+        // multi dimensional
+        throw new RangeError('Matrix must be a vector or two dimensional (size: ' + format(size) + ')');
     }
-  });
-
+    return c;
+  }
   function _denseTranspose(m, rows, columns) {
     // matrix array
-    var data = m._data; // transposed matrix data
-
+    var data = m._data;
+    // transposed matrix data
     var transposed = [];
-    var transposedRow; // loop columns
-
+    var transposedRow;
+    // loop columns
     for (var j = 0; j < columns; j++) {
       // initialize row
-      transposedRow = transposed[j] = []; // loop rows
-
+      transposedRow = transposed[j] = [];
+      // loop rows
       for (var i = 0; i < rows; i++) {
         // set data
         transposedRow[i] = clone(data[i][j]);
       }
-    } // return matrix
-
-
+    }
+    // return matrix
     return m.createDenseMatrix({
       data: transposed,
       size: [columns, rows],
       datatype: m._datatype
     });
   }
-
   function _sparseTranspose(m, rows, columns) {
     // matrix arrays
     var values = m._values;
     var index = m._index;
-    var ptr = m._ptr; // result matrices
-
+    var ptr = m._ptr;
+    // result matrices
     var cvalues = values ? [] : undefined;
     var cindex = [];
-    var cptr = []; // row counts
-
+    var cptr = [];
+    // row counts
     var w = [];
-
     for (var x = 0; x < rows; x++) {
       w[x] = 0;
-    } // vars
-
-
-    var p, l, j; // loop values in matrix
-
+    }
+    // vars
+    var p, l, j;
+    // loop values in matrix
     for (p = 0, l = index.length; p < l; p++) {
       // number of values in row
       w[index[p]]++;
-    } // cumulative sum
-
-
-    var sum = 0; // initialize cptr with the cummulative sum of row counts
-
+    }
+    // cumulative sum
+    var sum = 0;
+    // initialize cptr with the cummulative sum of row counts
     for (var i = 0; i < rows; i++) {
       // update cptr
-      cptr.push(sum); // update sum
-
-      sum += w[i]; // update w
-
+      cptr.push(sum);
+      // update sum
+      sum += w[i];
+      // update w
       w[i] = cptr[i];
-    } // update cptr
-
-
-    cptr.push(sum); // loop columns
-
+    }
+    // update cptr
+    cptr.push(sum);
+    // loop columns
     for (j = 0; j < columns; j++) {
       // values & index in column
       for (var k0 = ptr[j], k1 = ptr[j + 1], k = k0; k < k1; k++) {
         // C values & index
-        var q = w[index[k]]++; // C[j, i] = A[i, j]
-
-        cindex[q] = j; // check we need to process values (pattern matrix)
-
+        var q = w[index[k]]++;
+        // C[j, i] = A[i, j]
+        cindex[q] = j;
+        // check we need to process values (pattern matrix)
         if (values) {
           cvalues[q] = clone(values[k]);
         }
       }
-    } // return matrix
-
-
+    }
+    // return matrix
     return m.createSparseMatrix({
       values: cvalues,
       index: cindex,