mathjs 11.2.1 → 11.3.1

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

@@ -17,7 +17,6 @@ export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _re
     cos,
     sin
   } = _ref;
-
   /**
    * Create a 2-dimensional counter-clockwise rotation matrix (2x2) for a given angle (expressed in radians).
    * Create a 2-dimensional counter-clockwise rotation matrix (3x3) by a given angle (expressed in radians) around a given axis (1x3).
@@ -50,6 +49,7 @@ export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _re
    * @param {string} [format]                              Result Matrix storage format
    * @return {Array | Matrix}                              Rotation matrix
    */
+
   return typed(name, {
     '': function _() {
       return config.matrix === 'Matrix' ? matrix([]) : [];
@@ -65,30 +65,25 @@ export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _re
     },
     'number | BigNumber | Complex | Unit, Array': function numberBigNumberComplexUnitArray(theta, v) {
       var matrixV = matrix(v);
-
       _validateVector(matrixV);
-
       return _rotationMatrix3x3(theta, matrixV, undefined);
     },
     'number | BigNumber | Complex | Unit, Matrix': function numberBigNumberComplexUnitMatrix(theta, v) {
       _validateVector(v);
-
       var storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined);
       return _rotationMatrix3x3(theta, v, storageType);
     },
     'number | BigNumber | Complex | Unit, Array, string': function numberBigNumberComplexUnitArrayString(theta, v, format) {
       var matrixV = matrix(v);
-
       _validateVector(matrixV);
-
       return _rotationMatrix3x3(theta, matrixV, format);
     },
     'number | BigNumber | Complex | Unit, Matrix, string': function numberBigNumberComplexUnitMatrixString(theta, v, format) {
       _validateVector(v);
-
       return _rotationMatrix3x3(theta, v, format);
     }
   });
+
   /**
    * Returns 2x2 matrix of 2D rotation of angle theta
    *
@@ -97,7 +92,6 @@ export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _re
    * @returns {Matrix}
    * @private
    */
-
   function _rotationMatrix2x2(theta, format) {
     var Big = isBigNumber(theta);
     var minusOne = Big ? new BigNumber(-1) : -1;
@@ -106,34 +100,28 @@ export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _re
     var data = [[cosTheta, multiplyScalar(minusOne, sinTheta)], [sinTheta, cosTheta]];
     return _convertToFormat(data, format);
   }
-
   function _validateVector(v) {
     var size = v.size();
-
     if (size.length < 1 || size[0] !== 3) {
       throw new RangeError('Vector must be of dimensions 1x3');
     }
   }
-
   function _mul(array) {
     return array.reduce((p, curr) => multiplyScalar(p, curr));
   }
-
   function _convertToFormat(data, format) {
     if (format) {
       if (format === 'sparse') {
         return new SparseMatrix(data);
       }
-
       if (format === 'dense') {
         return new DenseMatrix(data);
       }
-
       throw new TypeError("Unknown matrix type \"".concat(format, "\""));
     }
-
     return data;
   }
+
   /**
    * Returns a 3x3 matrix of rotation of angle theta around vector v
    *
@@ -143,15 +131,11 @@ export var createRotationMatrix = /* #__PURE__ */factory(name, dependencies, _re
    * @returns {Matrix}
    * @private
    */
-
-
   function _rotationMatrix3x3(theta, v, format) {
     var normV = norm(v);
-
     if (normV === 0) {
       throw new RangeError('Rotation around zero vector');
     }
-
     var Big = isBigNumber(theta) ? BigNumber : null;
     var one = Big ? new Big(1) : 1;
     var minusOne = Big ? new Big(-1) : -1;

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

@@ -10,7 +10,6 @@ export var createRow = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrix,
     range
   } = _ref;
-
   /**
    * Return a row from a Matrix.
    *
@@ -38,19 +37,18 @@ export var createRow = /* #__PURE__ */factory(name, dependencies, _ref => {
       return _row(matrix(clone(value)), row).valueOf();
     }
   });
+
   /**
    * Retrieve a row of a matrix
    * @param {Matrix } value  A matrix
    * @param {number} row     The index of the row
    * @return {Matrix}        The retrieved row
    */
-
   function _row(value, row) {
     // check dimensions
     if (value.size().length !== 2) {
       throw new Error('Only two dimensional matrix is supported');
     }
-
     validateIndex(row, value.size()[0]);
     var columnRange = range(0, value.size()[1]);
     var index = new Index(row, columnRange);

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

@@ -9,7 +9,6 @@ export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
     config,
     matrix
   } = _ref;
-
   /**
    * Calculate the size of a matrix or scalar.
    *

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

@@ -10,8 +10,8 @@ export var createSort = /* #__PURE__ */factory(name, dependencies, _ref => {
     compareNatural
   } = _ref;
   var compareAsc = compare;
-
   var compareDesc = (a, b) => -compare(a, b);
+
   /**
    * Sort the items in a matrix.
    *
@@ -43,46 +43,38 @@ export var createSort = /* #__PURE__ */factory(name, dependencies, _ref => {
    *        and 0 when a == b.
    * @return {Matrix | Array} Returns the sorted matrix.
    */
-
-
   return typed(name, {
     Array: function Array(x) {
       _arrayIsVector(x);
-
       return x.sort(compareAsc);
     },
     Matrix: function Matrix(x) {
       _matrixIsVector(x);
-
       return matrix(x.toArray().sort(compareAsc), x.storage());
     },
     'Array, function': function ArrayFunction(x, _comparator) {
       _arrayIsVector(x);
-
       return x.sort(_comparator);
     },
     'Matrix, function': function MatrixFunction(x, _comparator) {
       _matrixIsVector(x);
-
       return matrix(x.toArray().sort(_comparator), x.storage());
     },
     'Array, string': function ArrayString(x, order) {
       _arrayIsVector(x);
-
       return x.sort(_comparator(order));
     },
     'Matrix, string': function MatrixString(x, order) {
       _matrixIsVector(x);
-
       return matrix(x.toArray().sort(_comparator(order)), x.storage());
     }
   });
+
   /**
    * Get the comparator for given order ('asc', 'desc', 'natural')
    * @param {'asc' | 'desc' | 'natural'} order
    * @return {Function} Returns a _comparator function
    */
-
   function _comparator(order) {
     if (order === 'asc') {
       return compareAsc;
@@ -94,27 +86,25 @@ export var createSort = /* #__PURE__ */factory(name, dependencies, _ref => {
       throw new Error('String "asc", "desc", or "natural" expected');
     }
   }
+
   /**
    * Validate whether an array is one dimensional
    * Throws an error when this is not the case
    * @param {Array} array
    * @private
    */
-
-
   function _arrayIsVector(array) {
     if (size(array).length !== 1) {
       throw new Error('One dimensional array expected');
     }
   }
+
   /**
    * Validate whether a matrix is one dimensional
    * Throws an error when this is not the case
    * @param {Matrix} matrix
    * @private
    */
-
-
   function _matrixIsVector(matrix) {
     if (matrix.size().length !== 1) {
       throw new Error('One dimensional matrix expected');

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

@@ -20,6 +20,7 @@ export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
   var _maxIterations = 1e3;
   var _tolerance = 1e-6;
+
   /**
    * Calculate the principal square root matrix using the Denman–Beavers iterative method
    *
@@ -29,26 +30,23 @@ export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Array | Matrix}     The principal square root of matrix `A`
    * @private
    */
-
   function _denmanBeavers(A) {
     var error;
     var iterations = 0;
     var Y = A;
     var Z = identity(size(A));
-
     do {
       var Yk = Y;
       Y = multiply(0.5, add(Yk, inv(Z)));
       Z = multiply(0.5, add(Z, inv(Yk)));
       error = max(abs(subtract(Y, Yk)));
-
       if (error > _tolerance && ++iterations > _maxIterations) {
         throw new Error('computing square root of matrix: iterative method could not converge');
       }
     } while (error > _tolerance);
-
     return Y;
   }
+
   /**
    * Calculate the principal square root of a square matrix.
    * The principal square root matrix `X` of another matrix `A` is such that `X * X = A`.
@@ -70,12 +68,9 @@ export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param  {Array | Matrix} A   The square matrix `A`
    * @return {Array | Matrix}     The principal square root of matrix `A`
    */
-
-
   return typed(name, {
     'Array | Matrix': function ArrayMatrix(A) {
       var size = isMatrix(A) ? A.size() : arraySize(A);
-
       switch (size.length) {
         case 1:
           // Single element Array | Matrix
@@ -84,20 +79,17 @@ export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
           } else {
             throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
           }
-
         case 2:
           {
             // Two-dimensional Array | Matrix
             var rows = size[0];
             var cols = size[1];
-
             if (rows === cols) {
               return _denmanBeavers(A);
             } else {
               throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
             }
           }
-
         default:
           // Multi dimensional array
           throw new RangeError('Matrix must be at most two dimensional ' + '(size: ' + format(size) + ')');

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

@@ -8,7 +8,6 @@ export var createSqueeze = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     matrix
   } = _ref;
-
   /**
    * Squeeze a matrix, remove inner and outer singleton dimensions from a matrix.
    *
@@ -43,8 +42,8 @@ export var createSqueeze = /* #__PURE__ */factory(name, dependencies, _ref => {
       return arraySqueeze(clone(x));
     },
     Matrix: function Matrix(x) {
-      var res = arraySqueeze(x.toArray()); // FIXME: return the same type of matrix as the input
-
+      var res = arraySqueeze(x.toArray());
+      // FIXME: return the same type of matrix as the input
       return Array.isArray(res) ? matrix(res) : res;
     },
     any: function any(x) {

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

@@ -11,7 +11,6 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     matrix
   } = _ref;
-
   /**
    * Get or set a subset of a matrix or string.
    *
@@ -61,9 +60,9 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
     '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) {
       return value.subset(index);
     },
@@ -87,6 +86,7 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Object, Index, any': _setObjectProperty
   });
 });
+
 /**
  * Retrieve a subset of a string
  * @param {string} str            string from which to get a substring
@@ -94,18 +94,16 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @returns {string} substring
  * @private
  */
-
 function _getSubstring(str, index) {
   if (!isIndex(index)) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
-
   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);
@@ -116,6 +114,7 @@ function _getSubstring(str, index) {
   });
   return substr;
 }
+
 /**
  * Replace a substring in a string
  * @param {string} str            string to be replaced
@@ -126,18 +125,14 @@ function _getSubstring(str, index) {
  * @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 (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');
@@ -145,29 +140,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]) {
@@ -175,9 +168,9 @@ function _setSubstring(str, index, replacement, defaultValue) {
       }
     }
   }
-
   return chars.join('');
 }
+
 /**
  * Retrieve a property from an object
  * @param {Object} object
@@ -185,21 +178,17 @@ function _setSubstring(str, index, replacement, defaultValue) {
  * @return {*} Returns the value of the property
  * @private
  */
-
-
 function _getObjectProperty(object, index) {
   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
@@ -208,20 +197,16 @@ function _getObjectProperty(object, index) {
  * @return {*} Returns the updated object
  * @private
  */
-
-
 function _setObjectProperty(object, index, replacement) {
   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

@@ -9,7 +9,6 @@ export var createTrace = /* #__PURE__ */factory(name, dependencies, _ref => {
     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) + ')');
   }
 });