mathjs 8.1.0 → 12.2.1

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

@@ -4,25 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSubset = void 0;
-
 var _is = require("../../utils/is.js");
-
 var _object = require("../../utils/object.js");
-
 var _array = require("../../utils/array.js");
-
 var _customs = require("../../utils/customs.js");
-
 var _DimensionError = require("../../error/DimensionError.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'subset';
-var dependencies = ['typed', 'matrix'];
-var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var dependencies = ['typed', 'matrix', 'zeros', 'add'];
+var createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix;
-
+    matrix = _ref.matrix,
+    zeros = _ref.zeros,
+    add = _ref.add;
   /**
    * Get or set a subset of a matrix or string.
    *
@@ -34,21 +28,33 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    *     // 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
@@ -57,58 +63,103 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *                                          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 ((0, _array.isEmptyIndex)(index)) {
+        return matrix();
+      }
+      (0, _array.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((0, _object.clone)(value)).subset(index, replacement, undefined).valueOf();
-    },
-    'Array, Index, any, any': function ArrayIndexAnyAny(value, index, replacement, defaultValue) {
-      return matrix((0, _object.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 ((0, _array.isEmptyIndex)(index)) {
+        return value;
+      }
+      (0, _array.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(function (d) {
+      return 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
  */
-
-exports.createSubset = createSubset;
-
 function _getSubstring(str, index) {
   if (!(0, _is.isIndex)(index)) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
-
+  if ((0, _array.isEmptyIndex)(index)) {
+    return '';
+  }
+  (0, _array.validateIndexSourceSize)(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new _DimensionError.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;
   (0, _array.validateIndex)(index.min()[0], strLen);
   (0, _array.validateIndex)(index.max()[0], strLen);
@@ -119,28 +170,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 ((0, _array.isEmptyIndex)(index)) {
+    return str;
+  }
+  (0, _array.validateIndexSourceSize)(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new _DimensionError.DimensionError(index.size().length, 1);
   }
-
   if (defaultValue !== undefined) {
     if (typeof defaultValue !== 'string' || defaultValue.length !== 1) {
       throw new TypeError('Single character expected as defaultValue');
@@ -148,29 +200,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.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;
   (0, _array.validateIndex)(index.min()[0]);
-  (0, _array.validateIndex)(index.max()[0]); // copy the string into an array with characters
+  (0, _array.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]) {
@@ -178,9 +228,9 @@ function _setSubstring(str, index, replacement, defaultValue) {
       }
     }
   }
-
   return chars.join('');
 }
+
 /**
  * Retrieve a property from an object
  * @param {Object} object
@@ -188,21 +238,20 @@ function _setSubstring(str, index, replacement, defaultValue) {
  * @return {*} Returns the value of the property
  * @private
  */
-
-
 function _getObjectProperty(object, index) {
+  if ((0, _array.isEmptyIndex)(index)) {
+    return undefined;
+  }
   if (index.size().length !== 1) {
     throw new _DimensionError.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 (0, _customs.getSafeProperty)(object, key);
 }
+
 /**
  * Set a property on an object
  * @param {Object} object
@@ -211,20 +260,19 @@ function _getObjectProperty(object, index) {
  * @return {*} Returns the updated object
  * @private
  */
-
-
 function _setObjectProperty(object, index, replacement) {
+  if ((0, _array.isEmptyIndex)(index)) {
+    return object;
+  }
   if (index.size().length !== 1) {
     throw new _DimensionError.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 = (0, _object.clone)(object);
   (0, _customs.setSafeProperty)(updated, key, replacement);
   return updated;

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

@@ -4,20 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createTrace = void 0;
-
 var _object = require("../../utils/object.js");
-
 var _string = require("../../utils/string.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'trace';
 var dependencies = ['typed', 'matrix', 'add'];
-var createTrace = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createTrace = exports.createTrace = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      add = _ref.add;
-
+    matrix = _ref.matrix,
+    add = _ref.add;
   /**
    * Calculate the trace of a matrix: the sum of the elements on the main
    * diagonal of a square matrix.
@@ -54,12 +49,12 @@ var createTrace = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     DenseMatrix: _denseTrace,
     any: _object.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
@@ -67,81 +62,71 @@ var createTrace = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
           // return data[0]
           return (0, _object.clone)(data[0]);
         }
-
         throw new RangeError('Matrix must be square (size: ' + (0, _string.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: ' + (0, _string.format)(size) + ')');
           }
         }
-
       default:
         // multi dimensional
         throw new RangeError('Matrix must be two dimensional (size: ' + (0, _string.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: ' + (0, _string.format)(size) + ')');
   }
-});
-exports.createTrace = createTrace;
+});