mathjs 11.2.1 → 11.3.1

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

@@ -12,7 +12,6 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrix,
     isInteger
   } = _ref;
-
   /**
    * Concatenate two or more matrices.
    *
@@ -48,31 +47,29 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
       var i;
       var len = args.length;
       var dim = -1; // zero-based dimension
-
       var prevDim;
       var asMatrix = false;
       var matrices = []; // contains multi dimensional arrays
 
       for (i = 0; i < len; i++) {
-        var arg = args[i]; // test whether we need to return a Matrix (if not we return an Array)
+        var arg = args[i];
 
+        // test whether we need to return a Matrix (if not we return an Array)
         if (isMatrix(arg)) {
           asMatrix = true;
         }
-
         if (isNumber(arg) || isBigNumber(arg)) {
           if (i !== len - 1) {
             throw new Error('Dimension must be specified as last argument');
-          } // last argument contains the dimension on which to concatenate
-
+          }
 
+          // last argument contains the dimension on which to concatenate
           prevDim = dim;
           dim = arg.valueOf(); // change BigNumber to number
 
           if (!isInteger(dim)) {
             throw new TypeError('Integer number expected for dimension');
           }
-
           if (dim < 0 || i > 0 && dim > prevDim) {
             // TODO: would be more clear when throwing a DimensionError here
             throw new IndexError(dim, prevDim + 1);
@@ -83,24 +80,21 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
           var size = arraySize(m);
           matrices[i] = m;
           prevDim = dim;
-          dim = size.length - 1; // verify whether each of the matrices has the same number of dimensions
+          dim = size.length - 1;
 
+          // verify whether each of the matrices has the same number of dimensions
           if (i > 0 && dim !== prevDim) {
             throw new DimensionError(prevDim + 1, dim + 1);
           }
         }
       }
-
       if (matrices.length === 0) {
         throw new SyntaxError('At least one matrix expected');
       }
-
       var res = matrices.shift();
-
       while (matrices.length) {
         res = _concat(res, matrices.shift(), dim, 0);
       }
-
       return asMatrix ? matrix(res) : res;
     },
     '...string': function string(args) {
@@ -108,6 +102,7 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
   });
 });
+
 /**
  * Recursively concatenate two matrices.
  * The contents of the matrices is not cloned.
@@ -118,20 +113,16 @@ export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @return {Array} c            The concatenated matrix
  * @private
  */
-
 function _concat(a, b, concatDim, dim) {
   if (dim < concatDim) {
     // recurse into next dimension
     if (a.length !== b.length) {
       throw new DimensionError(a.length, b.length);
     }
-
     var c = [];
-
     for (var i = 0; i < a.length; i++) {
       c[i] = _concat(a[i], b[i], concatDim, dim + 1);
     }
-
     return c;
   } else {
     // concatenate this dimension

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

@@ -7,7 +7,6 @@ export var createCount = /* #__PURE__ */factory(name, dependencies, _ref => {
     size,
     prod
   } = _ref;
-
   /**
    * Count the number of elements of a matrix, array or string.
    *

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

@@ -9,7 +9,6 @@ export var createCross = /* #__PURE__ */factory(name, dependencies, _ref => {
     subtract,
     multiply
   } = _ref;
-
   /**
    * Calculate the cross product for two vectors in three dimensional space.
    * The cross product of `A = [a1, a2, a3]` and `B = [b1, b2, b3]` is defined
@@ -55,6 +54,7 @@ export var createCross = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     'Array, Array': _cross
   });
+
   /**
    * Calculate the cross product for two arrays
    * @param {Array} x  First vector
@@ -62,20 +62,16 @@ export var createCross = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {Array} Returns the cross product of x and y
    * @private
    */
-
   function _cross(x, y) {
     var highestDimension = Math.max(arraySize(x).length, arraySize(y).length);
     x = squeeze(x);
     y = squeeze(y);
     var xSize = arraySize(x);
     var ySize = arraySize(y);
-
     if (xSize.length !== 1 || ySize.length !== 1 || xSize[0] !== 3 || ySize[0] !== 3) {
       throw new RangeError('Vectors with length 3 expected ' + '(Size A = [' + xSize.join(', ') + '], B = [' + ySize.join(', ') + '])');
     }
-
     var product = [subtract(multiply(x[1], y[2]), multiply(x[2], y[1])), subtract(multiply(x[2], y[0]), multiply(x[0], y[2])), subtract(multiply(x[0], y[1]), multiply(x[1], y[0]))];
-
     if (highestDimension > 1) {
       return [product];
     } else {

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

@@ -7,7 +7,6 @@ export var createCtranspose = /* #__PURE__ */factory(name, dependencies, _ref =>
     transpose,
     conj
   } = _ref;
-
   /**
    * Transpose and complex conjugate a matrix. All values of the matrix are
    * reflected over its main diagonal and then the complex conjugate is

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

@@ -14,7 +14,6 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
     isZero,
     unaryMinus
   } = _ref;
-
   /**
    * Calculate the determinant of a matrix.
    *
@@ -46,7 +45,6 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     'Array | Matrix': function det(x) {
       var size;
-
       if (isMatrix(x)) {
         size = x.size();
       } else if (Array.isArray(x)) {
@@ -56,12 +54,10 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
         // a scalar
         size = [];
       }
-
       switch (size.length) {
         case 0:
           // scalar
           return clone(x);
-
         case 1:
           // vector
           if (size[0] === 1) {
@@ -69,26 +65,24 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
           } else {
             throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
           }
-
         case 2:
           {
             // two dimensional array
             var rows = size[0];
             var cols = size[1];
-
             if (rows === cols) {
               return _det(x.clone().valueOf(), rows, cols);
             } else {
               throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
             }
           }
-
         default:
           // multi dimensional array
           throw new RangeError('Matrix must be two dimensional ' + '(size: ' + format(size) + ')');
       }
     }
   });
+
   /**
    * Calculate the determinant of a matrix
    * @param {Array[]} matrix  A square, two dimensional matrix
@@ -97,7 +91,6 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {number} det
    * @private
    */
-
   function _det(matrix, rows, cols) {
     if (rows === 1) {
       // this is a 1 x 1 matrix
@@ -112,13 +105,10 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
       // but it preserve precision of floating point more relative to the LUP decomposition
       var negated = false;
       var rowIndices = new Array(rows).fill(0).map((_, i) => i); // matrix index of row i
-
       for (var k = 0; k < rows; k++) {
         var k_ = rowIndices[k];
-
         if (isZero(matrix[k_][k])) {
           var _k = void 0;
-
           for (_k = k + 1; _k < rows; _k++) {
             if (!isZero(matrix[rowIndices[_k]][k])) {
               k_ = rowIndices[_k];
@@ -128,22 +118,18 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
               break;
             }
           }
-
           if (_k === rows) return matrix[k_][k]; // some zero of the type
         }
 
         var piv = matrix[k_][k];
         var piv_ = k === 0 ? 1 : matrix[rowIndices[k - 1]][k - 1];
-
         for (var i = k + 1; i < rows; i++) {
           var i_ = rowIndices[i];
-
           for (var j = k + 1; j < rows; j++) {
             matrix[i_][j] = divideScalar(subtract(multiply(matrix[i_][j], piv), multiply(matrix[i_][k], matrix[k_][j])), piv_);
           }
         }
       }
-
       var det = matrix[rowIndices[rows - 1]][rows - 1];
       return negated ? unaryMinus(det) : det;
     }

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

@@ -11,7 +11,6 @@ export var createDiag = /* #__PURE__ */factory(name, dependencies, _ref => {
     DenseMatrix,
     SparseMatrix
   } = _ref;
-
   /**
    * Create a diagonal matrix or retrieve the diagonal of a matrix
    *
@@ -51,6 +50,7 @@ export var createDiag = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     // FIXME: simplify this huge amount of signatures as soon as typed-function supports optional arguments
+
     Array: function Array(x) {
       return _diag(x, 0, arraySize(x), null);
     },
@@ -88,6 +88,7 @@ export var createDiag = /* #__PURE__ */factory(name, dependencies, _ref => {
       return _diag(x, k.toNumber(), x.size(), format);
     }
   });
+
   /**
    * Creeate diagonal matrix from a vector or vice versa
    * @param {Array | Matrix} x
@@ -97,68 +98,58 @@ export var createDiag = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {Array | Matrix}
    * @private
    */
-
   function _diag(x, k, size, format) {
     if (!isInteger(k)) {
       throw new TypeError('Second parameter in function diag must be an integer');
     }
-
     var kSuper = k > 0 ? k : 0;
-    var kSub = k < 0 ? -k : 0; // check dimensions
+    var kSub = k < 0 ? -k : 0;
 
+    // check dimensions
     switch (size.length) {
       case 1:
         return _createDiagonalMatrix(x, k, format, size[0], kSub, kSuper);
-
       case 2:
         return _getDiagonal(x, k, format, size, kSub, kSuper);
     }
-
     throw new RangeError('Matrix for function diag must be 2 dimensional');
   }
-
   function _createDiagonalMatrix(x, k, format, l, kSub, kSuper) {
     // matrix size
     var ms = [l + kSub, l + kSuper];
-
     if (format && format !== 'sparse' && format !== 'dense') {
       throw new TypeError("Unknown matrix type ".concat(format, "\""));
-    } // create diagonal matrix
-
-
-    var m = format === 'sparse' ? SparseMatrix.diagonal(ms, x, k) : DenseMatrix.diagonal(ms, x, k); // check we need to return a matrix
+    }
 
+    // create diagonal matrix
+    var m = format === 'sparse' ? SparseMatrix.diagonal(ms, x, k) : DenseMatrix.diagonal(ms, x, k);
+    // check we need to return a matrix
     return format !== null ? m : m.valueOf();
   }
-
   function _getDiagonal(x, k, format, s, kSub, kSuper) {
     // check x is a Matrix
     if (isMatrix(x)) {
       // get diagonal matrix
-      var dm = x.diagonal(k); // check we need to return a matrix
-
+      var dm = x.diagonal(k);
+      // check we need to return a matrix
       if (format !== null) {
         // check we need to change matrix format
         if (format !== dm.storage()) {
           return matrix(dm, format);
         }
-
         return dm;
       }
-
       return dm.valueOf();
-    } // vector size
-
-
-    var n = Math.min(s[0] - kSub, s[1] - kSuper); // diagonal values
-
-    var vector = []; // loop diagonal
-
+    }
+    // vector size
+    var n = Math.min(s[0] - kSub, s[1] - kSuper);
+    // diagonal values
+    var vector = [];
+    // loop diagonal
     for (var i = 0; i < n; i++) {
       vector[i] = x[i + kSub][i + kSuper];
-    } // check we need to return a matrix
-
-
+    }
+    // check we need to return a matrix
     return format !== null ? matrix(vector) : vector;
   }
 });

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

@@ -10,7 +10,6 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
     subtract,
     number
   } = _ref;
-
   /**
    * Create a new matrix or array of the difference between elements of the given array
    * The optional dim parameter lets you specify the dimension to evaluate the difference of
@@ -68,7 +67,6 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     'Array | Matrix, number': function ArrayMatrixNumber(arr, dim) {
       if (!isInteger(dim)) throw new RangeError('Dimension must be a whole number');
-
       if (isMatrix(arr)) {
         return matrix(_recursive(arr.toArray(), dim));
       } else {
@@ -78,6 +76,7 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Array, BigNumber': typed.referTo('Array,number', selfAn => (arr, dim) => selfAn(arr, number(dim))),
     'Matrix, BigNumber': typed.referTo('Matrix,number', selfMn => (arr, dim) => selfMn(arr, number(dim)))
   });
+
   /**
    * Recursively find the correct dimension in the array/matrix
    * Then Apply _diff to that dimension
@@ -86,7 +85,6 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param {number} dim     Dimension
    * @return {Array}         resulting array
    */
-
   function _recursive(arr, dim) {
     if (isMatrix(arr)) {
       arr = arr.toArray(); // Makes sure arrays like [ matrix([0, 1]), matrix([1, 0]) ] are processed properly
@@ -95,7 +93,6 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
     if (!Array.isArray(arr)) {
       throw RangeError('Array/Matrix does not have that many dimensions');
     }
-
     if (dim > 0) {
       var result = [];
       arr.forEach(element => {
@@ -108,24 +105,22 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
       throw RangeError('Cannot have negative dimension');
     }
   }
+
   /**
    * Difference between elements in the array
    *
    * @param {Array} arr      An array
    * @return {Array}         resulting array
    */
-
-
   function _diff(arr) {
     var result = [];
     var size = arr.length;
-
     for (var i = 1; i < size; i++) {
       result.push(_ElementDiff(arr[i - 1], arr[i]));
     }
-
     return result;
   }
+
   /**
    * Difference between 2 objects
    *
@@ -133,25 +128,22 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param {Object} obj2    Second object
    * @return {Array}         resulting array
    */
-
-
   function _ElementDiff(obj1, obj2) {
     // Convert matrices to arrays
     if (isMatrix(obj1)) obj1 = obj1.toArray();
     if (isMatrix(obj2)) obj2 = obj2.toArray();
     var obj1IsArray = Array.isArray(obj1);
     var obj2IsArray = Array.isArray(obj2);
-
     if (obj1IsArray && obj2IsArray) {
       return _ArrayDiff(obj1, obj2);
     }
-
     if (!obj1IsArray && !obj2IsArray) {
       return subtract(obj2, obj1); // Difference is (second - first) NOT (first - second)
     }
 
     throw TypeError('Cannot calculate difference between 1 array and 1 non-array');
   }
+
   /**
    * Difference of elements in 2 arrays
    *
@@ -159,20 +151,15 @@ export var createDiff = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param {Array} arr2     Array 2
    * @return {Array}         resulting array
    */
-
-
   function _ArrayDiff(arr1, arr2) {
     if (arr1.length !== arr2.length) {
       throw RangeError('Not all sub-arrays have the same length');
     }
-
     var result = [];
     var size = arr1.length;
-
     for (var i = 0; i < size; i++) {
       result.push(_ElementDiff(arr1[i], arr2[i]));
     }
-
     return result;
   }
 });

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

@@ -10,7 +10,6 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     conj,
     size
   } = _ref;
-
   /**
    * Calculate the dot product of two vectors. The dot product of
    * `A = [a1, a2, ..., an]` and `B = [b1, b2, ..., bn]` is defined as:
@@ -38,14 +37,10 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Array | DenseMatrix, Array | DenseMatrix': _denseDot,
     'SparseMatrix, SparseMatrix': _sparseDot
   });
-
   function _validateDim(x, y) {
     var xSize = _size(x);
-
     var ySize = _size(y);
-
     var xLen, yLen;
-
     if (xSize.length === 1) {
       xLen = xSize[0];
     } else if (xSize.length === 2 && xSize[1] === 1) {
@@ -53,7 +48,6 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     } else {
       throw new RangeError('Expected a column vector, instead got a matrix of size (' + xSize.join(', ') + ')');
     }
-
     if (ySize.length === 1) {
       yLen = ySize[0];
     } else if (ySize.length === 2 && ySize[1] === 1) {
@@ -61,116 +55,101 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     } else {
       throw new RangeError('Expected a column vector, instead got a matrix of size (' + ySize.join(', ') + ')');
     }
-
     if (xLen !== yLen) throw new RangeError('Vectors must have equal length (' + xLen + ' != ' + yLen + ')');
     if (xLen === 0) throw new RangeError('Cannot calculate the dot product of empty vectors');
     return xLen;
   }
-
   function _denseDot(a, b) {
     var N = _validateDim(a, b);
-
     var adata = isMatrix(a) ? a._data : a;
     var adt = isMatrix(a) ? a._datatype : undefined;
     var bdata = isMatrix(b) ? b._data : b;
-    var bdt = isMatrix(b) ? b._datatype : undefined; // are these 2-dimensional column vectors? (as opposed to 1-dimensional vectors)
+    var bdt = isMatrix(b) ? b._datatype : undefined;
 
+    // are these 2-dimensional column vectors? (as opposed to 1-dimensional vectors)
     var aIsColumn = _size(a).length === 2;
     var bIsColumn = _size(b).length === 2;
     var add = addScalar;
-    var mul = multiplyScalar; // process data types
+    var mul = multiplyScalar;
 
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
-      var dt = adt; // find signatures that matches (dt, dt)
-
+      var dt = adt;
+      // find signatures that matches (dt, dt)
       add = typed.find(addScalar, [dt, dt]);
       mul = typed.find(multiplyScalar, [dt, dt]);
-    } // both vectors 1-dimensional
-
+    }
 
+    // both vectors 1-dimensional
     if (!aIsColumn && !bIsColumn) {
       var c = mul(conj(adata[0]), bdata[0]);
-
       for (var i = 1; i < N; i++) {
         c = add(c, mul(conj(adata[i]), bdata[i]));
       }
-
       return c;
-    } // a is 1-dim, b is column
-
+    }
 
+    // a is 1-dim, b is column
     if (!aIsColumn && bIsColumn) {
       var _c = mul(conj(adata[0]), bdata[0][0]);
-
       for (var _i = 1; _i < N; _i++) {
         _c = add(_c, mul(conj(adata[_i]), bdata[_i][0]));
       }
-
       return _c;
-    } // a is column, b is 1-dim
-
+    }
 
+    // a is column, b is 1-dim
     if (aIsColumn && !bIsColumn) {
       var _c2 = mul(conj(adata[0][0]), bdata[0]);
-
       for (var _i2 = 1; _i2 < N; _i2++) {
         _c2 = add(_c2, mul(conj(adata[_i2][0]), bdata[_i2]));
       }
-
       return _c2;
-    } // both vectors are column
-
+    }
 
+    // both vectors are column
     if (aIsColumn && bIsColumn) {
       var _c3 = mul(conj(adata[0][0]), bdata[0][0]);
-
       for (var _i3 = 1; _i3 < N; _i3++) {
         _c3 = add(_c3, mul(conj(adata[_i3][0]), bdata[_i3][0]));
       }
-
       return _c3;
     }
   }
-
   function _sparseDot(x, y) {
     _validateDim(x, y);
-
     var xindex = x._index;
     var xvalues = x._values;
     var yindex = y._index;
-    var yvalues = y._values; // TODO optimize add & mul using datatype
+    var yvalues = y._values;
 
+    // TODO optimize add & mul using datatype
     var c = 0;
     var add = addScalar;
     var mul = multiplyScalar;
     var i = 0;
     var j = 0;
-
     while (i < xindex.length && j < yindex.length) {
       var I = xindex[i];
       var J = yindex[j];
-
       if (I < J) {
         i++;
         continue;
       }
-
       if (I > J) {
         j++;
         continue;
       }
-
       if (I === J) {
         c = add(c, mul(xvalues[i], yvalues[j]));
         i++;
         j++;
       }
     }
-
     return c;
-  } // TODO remove this once #1771 is fixed
-
+  }
 
+  // TODO remove this once #1771 is fixed
   function _size(x) {
     return isMatrix(x) ? x.size() : size(x);
   }