mathjs 11.2.1 → 11.3.0

package/lib/esm/function/algebra/sparse/csSqr.js

@@ -20,6 +20,7 @@ export var createCsSqr = /* #__PURE__ */factory(name, dependencies, _ref => {
   var csCounts = createCsCounts({
     transpose
   });
+
   /**
    * Symbolic ordering and analysis for QR and LU decompositions.
    *
@@ -32,35 +33,33 @@ export var createCsSqr = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Reference: http://faculty.cse.tamu.edu/davis/publications.html
    */
-
   return function csSqr(order, a, qr) {
     // a arrays
     var aptr = a._ptr;
-    var asize = a._size; // columns
-
-    var n = asize[1]; // vars
-
-    var k; // symbolic analysis result
-
-    var s = {}; // fill-reducing ordering
-
-    s.q = csAmd(order, a); // validate results
-
+    var asize = a._size;
+    // columns
+    var n = asize[1];
+    // vars
+    var k;
+    // symbolic analysis result
+    var s = {};
+    // fill-reducing ordering
+    s.q = csAmd(order, a);
+    // validate results
     if (order && !s.q) {
       return null;
-    } // QR symbolic analysis
-
-
+    }
+    // QR symbolic analysis
     if (qr) {
       // apply permutations if needed
-      var c = order ? csPermute(a, null, s.q, 0) : a; // etree of C'*C, where C=A(:,q)
-
-      s.parent = csEtree(c, 1); // post order elimination tree
-
-      var post = csPost(s.parent, n); // col counts chol(C'*C)
-
-      s.cp = csCounts(c, s.parent, post, 1); // check we have everything needed to calculate number of nonzero elements
-
+      var c = order ? csPermute(a, null, s.q, 0) : a;
+      // etree of C'*C, where C=A(:,q)
+      s.parent = csEtree(c, 1);
+      // post order elimination tree
+      var post = csPost(s.parent, n);
+      // col counts chol(C'*C)
+      s.cp = csCounts(c, s.parent, post, 1);
+      // check we have everything needed to calculate number of nonzero elements
       if (c && s.parent && s.cp && _vcount(c, s)) {
         // calculate number of nonzero elements
         for (s.unz = 0, k = 0; k < n; k++) {
@@ -71,125 +70,109 @@ export var createCsSqr = /* #__PURE__ */factory(name, dependencies, _ref => {
       // for LU factorization only, guess nnz(L) and nnz(U)
       s.unz = 4 * aptr[n] + n;
       s.lnz = s.unz;
-    } // return result S
-
-
+    }
+    // return result S
     return s;
   };
+
   /**
    * Compute nnz(V) = s.lnz, s.pinv, s.leftmost, s.m2 from A and s.parent
    */
-
   function _vcount(a, s) {
     // a arrays
     var aptr = a._ptr;
     var aindex = a._index;
-    var asize = a._size; // rows & columns
-
+    var asize = a._size;
+    // rows & columns
     var m = asize[0];
-    var n = asize[1]; // initialize s arrays
-
+    var n = asize[1];
+    // initialize s arrays
     s.pinv = []; // (m + n)
-
     s.leftmost = []; // (m)
     // vars
-
     var parent = s.parent;
     var pinv = s.pinv;
-    var leftmost = s.leftmost; // workspace, next: first m entries, head: next n entries, tail: next n entries, nque: next n entries
-
+    var leftmost = s.leftmost;
+    // workspace, next: first m entries, head: next n entries, tail: next n entries, nque: next n entries
     var w = []; // (m + 3 * n)
-
     var next = 0;
     var head = m;
     var tail = m + n;
-    var nque = m + 2 * n; // vars
-
-    var i, k, p, p0, p1; // initialize w
-
+    var nque = m + 2 * n;
+    // vars
+    var i, k, p, p0, p1;
+    // initialize w
     for (k = 0; k < n; k++) {
       // queue k is empty
       w[head + k] = -1;
       w[tail + k] = -1;
       w[nque + k] = 0;
-    } // initialize row arrays
-
-
+    }
+    // initialize row arrays
     for (i = 0; i < m; i++) {
       leftmost[i] = -1;
-    } // loop columns backwards
-
-
+    }
+    // loop columns backwards
     for (k = n - 1; k >= 0; k--) {
       // values & index for column k
       for (p0 = aptr[k], p1 = aptr[k + 1], p = p0; p < p1; p++) {
         // leftmost[i] = min(find(A(i,:)))
         leftmost[aindex[p]] = k;
       }
-    } // scan rows in reverse order
-
-
+    }
+    // scan rows in reverse order
     for (i = m - 1; i >= 0; i--) {
       // row i is not yet ordered
       pinv[i] = -1;
-      k = leftmost[i]; // check row i is empty
-
+      k = leftmost[i];
+      // check row i is empty
       if (k === -1) {
         continue;
-      } // first row in queue k
-
-
+      }
+      // first row in queue k
       if (w[nque + k]++ === 0) {
         w[tail + k] = i;
-      } // put i at head of queue k
-
-
+      }
+      // put i at head of queue k
       w[next + i] = w[head + k];
       w[head + k] = i;
     }
-
     s.lnz = 0;
-    s.m2 = m; // find row permutation and nnz(V)
-
+    s.m2 = m;
+    // find row permutation and nnz(V)
     for (k = 0; k < n; k++) {
       // remove row i from queue k
-      i = w[head + k]; // count V(k,k) as nonzero
-
-      s.lnz++; // add a fictitious row
-
+      i = w[head + k];
+      // count V(k,k) as nonzero
+      s.lnz++;
+      // add a fictitious row
       if (i < 0) {
         i = s.m2++;
-      } // associate row i with V(:,k)
-
-
-      pinv[i] = k; // skip if V(k+1:m,k) is empty
-
+      }
+      // associate row i with V(:,k)
+      pinv[i] = k;
+      // skip if V(k+1:m,k) is empty
       if (--nque[k] <= 0) {
         continue;
-      } // nque[k] is nnz (V(k+1:m,k))
-
-
-      s.lnz += w[nque + k]; // move all rows to parent of k
-
+      }
+      // nque[k] is nnz (V(k+1:m,k))
+      s.lnz += w[nque + k];
+      // move all rows to parent of k
       var pa = parent[k];
-
       if (pa !== -1) {
         if (w[nque + pa] === 0) {
           w[tail + pa] = w[tail + k];
         }
-
         w[next + w[tail + k]] = w[head + pa];
         w[head + pa] = w[next + i];
         w[nque + pa] += w[nque + k];
       }
     }
-
     for (i = 0; i < m; i++) {
       if (pinv[i] < 0) {
         pinv[i] = k++;
       }
     }
-
     return true;
   }
 });

package/lib/esm/function/algebra/sparse/csSymperm.js

@@ -7,7 +7,6 @@ export var createCsSymperm = /* #__PURE__ */factory(name, dependencies, _ref =>
     conj,
     SparseMatrix
   } = _ref;
-
   /**
    * Computes the symmetric permutation of matrix A accessing only
    * the upper triangular part of A.
@@ -27,69 +26,62 @@ export var createCsSymperm = /* #__PURE__ */factory(name, dependencies, _ref =>
     var avalues = a._values;
     var aindex = a._index;
     var aptr = a._ptr;
-    var asize = a._size; // columns
-
-    var n = asize[1]; // C matrix arrays
-
+    var asize = a._size;
+    // columns
+    var n = asize[1];
+    // C matrix arrays
     var cvalues = values && avalues ? [] : null;
     var cindex = []; // (nz)
-
     var cptr = []; // (n + 1)
     // variables
-
-    var i, i2, j, j2, p, p0, p1; // create workspace vector
-
+    var i, i2, j, j2, p, p0, p1;
+    // create workspace vector
     var w = []; // (n)
     // count entries in each column of C
-
     for (j = 0; j < n; j++) {
       // column j of A is column j2 of C
-      j2 = pinv ? pinv[j] : j; // loop values in column j
-
+      j2 = pinv ? pinv[j] : j;
+      // loop values in column j
       for (p0 = aptr[j], p1 = aptr[j + 1], p = p0; p < p1; p++) {
         // row
-        i = aindex[p]; // skip lower triangular part of A
-
+        i = aindex[p];
+        // skip lower triangular part of A
         if (i > j) {
           continue;
-        } // row i of A is row i2 of C
-
-
-        i2 = pinv ? pinv[i] : i; // column count of C
-
+        }
+        // row i of A is row i2 of C
+        i2 = pinv ? pinv[i] : i;
+        // column count of C
         w[Math.max(i2, j2)]++;
       }
-    } // compute column pointers of C
-
-
-    csCumsum(cptr, w, n); // loop columns
-
+    }
+    // compute column pointers of C
+    csCumsum(cptr, w, n);
+    // loop columns
     for (j = 0; j < n; j++) {
       // column j of A is column j2 of C
-      j2 = pinv ? pinv[j] : j; // loop values in column j
-
+      j2 = pinv ? pinv[j] : j;
+      // loop values in column j
       for (p0 = aptr[j], p1 = aptr[j + 1], p = p0; p < p1; p++) {
         // row
-        i = aindex[p]; // skip lower triangular part of A
-
+        i = aindex[p];
+        // skip lower triangular part of A
         if (i > j) {
           continue;
-        } // row i of A is row i2 of C
-
-
-        i2 = pinv ? pinv[i] : i; // C index for column j2
-
-        var q = w[Math.max(i2, j2)]++; // update C index for entry q
-
-        cindex[q] = Math.min(i2, j2); // check we need to process values
-
+        }
+        // row i of A is row i2 of C
+        i2 = pinv ? pinv[i] : i;
+        // C index for column j2
+        var q = w[Math.max(i2, j2)]++;
+        // update C index for entry q
+        cindex[q] = Math.min(i2, j2);
+        // check we need to process values
         if (cvalues) {
           cvalues[q] = i2 <= j2 ? avalues[p] : conj(avalues[p]);
         }
       }
-    } // return C matrix
-
-
+    }
+    // return C matrix
     return new SparseMatrix({
       values: cvalues,
       index: cindex,

package/lib/esm/function/algebra/sparse/csTdfs.js

@@ -13,30 +13,28 @@
  */
 export function csTdfs(j, k, w, head, next, post, stack) {
   // variables
-  var top = 0; // place j on the stack
-
-  w[stack] = j; // while (stack is not empty)
-
+  var top = 0;
+  // place j on the stack
+  w[stack] = j;
+  // while (stack is not empty)
   while (top >= 0) {
     // p = top of stack
-    var p = w[stack + top]; // i = youngest child of p
-
+    var p = w[stack + top];
+    // i = youngest child of p
     var i = w[head + p];
-
     if (i === -1) {
       // p has no unordered children left
-      top--; // node p is the kth postordered node
-
+      top--;
+      // node p is the kth postordered node
       post[k++] = p;
     } else {
       // remove i from children of p
-      w[head + p] = w[next + i]; // increment top
-
-      ++top; // start dfs on child node i
-
+      w[head + p] = w[next + i];
+      // increment top
+      ++top;
+      // start dfs on child node i
       w[stack + top] = i;
     }
   }
-
   return k;
 }

package/lib/esm/function/algebra/sparse/csUnflip.js

@@ -1,4 +1,5 @@
 import { csFlip } from './csFlip.js';
+
 /**
  * Flips the value if it is negative of returns the same value otherwise.
  *
@@ -6,7 +7,6 @@ import { csFlip } from './csFlip.js';
  *
  * Reference: http://faculty.cse.tamu.edu/davis/publications.html
  */
-
 export function csUnflip(i) {
   // flip the value if it is negative
   return i < 0 ? csFlip(i) : i;

package/lib/esm/function/algebra/symbolicEqual.js

@@ -9,7 +9,6 @@ export var createSymbolicEqual = /* #__PURE__ */factory(name, dependencies, _ref
     typed,
     OperatorNode
   } = _ref;
-
   /**
    * Attempts to determine if two expressions are symbolically equal, i.e.
    * one is the result of valid algebraic manipulations on the other.
@@ -54,7 +53,6 @@ export var createSymbolicEqual = /* #__PURE__ */factory(name, dependencies, _ref
     var simplified = simplify(diff, {}, options);
     return isConstantNode(simplified) && !simplified.value;
   }
-
   return typed(name, {
     'Node, Node': _symbolicEqual,
     'Node, Node, Object': _symbolicEqual

package/lib/esm/function/arithmetic/abs.js

@@ -7,7 +7,6 @@ export var createAbs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Calculate the absolute value of a number. For matrices, the function is
    * evaluated element wise.

package/lib/esm/function/arithmetic/add.js

@@ -29,6 +29,7 @@ export var createAdd = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     matrix
   });
+
   /**
    * Add two or more values, `x + y`.
    * For matrices, the function is evaluated element wise.
@@ -63,16 +64,13 @@ export var createAdd = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second value to add
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
    */
-
   return typed(name, {
     'any, any': addScalar,
     'any, any, ...any': typed.referToSelf(self => (x, y, rest) => {
       var result = self(x, y);
-
       for (var i = 0; i < rest.length; i++) {
         result = self(result, rest[i]);
       }
-
       return result;
     })
   }, matrixAlgorithmSuite({

package/lib/esm/function/arithmetic/addScalar.js

@@ -6,7 +6,6 @@ export var createAddScalar = /* #__PURE__ */factory(name, dependencies, _ref =>
   var {
     typed
   } = _ref;
-
   /**
    * Add two scalar values, `x + y`.
    * This function is meant for internal use: it is used by the public function
@@ -34,11 +33,9 @@ export var createAddScalar = /* #__PURE__ */factory(name, dependencies, _ref =>
       if (x.value === null || x.value === undefined) {
         throw new Error('Parameter x contains a unit with undefined value');
       }
-
       if (y.value === null || y.value === undefined) {
         throw new Error('Parameter y contains a unit with undefined value');
       }
-
       if (!x.equalBase(y)) throw new Error('Units do not match');
       var res = x.clone();
       res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);

package/lib/esm/function/arithmetic/cbrt.js

@@ -14,7 +14,6 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber,
     Fraction
   } = _ref;
-
   /**
    * Calculate the cubic root of a value.
    *
@@ -60,6 +59,7 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
     number: cbrtNumber,
     // note: signature 'number, boolean' is also supported,
     //       created by typed as it knows how to convert number to Complex
+
     Complex: _cbrtComplex,
     'Complex, boolean': _cbrtComplex,
     BigNumber: function BigNumber(x) {
@@ -67,6 +67,7 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     Unit: _cbrtUnit
   });
+
   /**
    * Calculate the cubic root for a complex number
    * @param {Complex} x
@@ -76,14 +77,14 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {Complex | Array.<Complex> | Matrix.<Complex>} Returns the cubic root(s) of x
    * @private
    */
-
   function _cbrtComplex(x, allRoots) {
     // https://www.wikiwand.com/en/Cube_root#/Complex_numbers
+
     var arg3 = x.arg() / 3;
-    var abs = x.abs(); // principal root:
+    var abs = x.abs();
 
+    // principal root:
     var principal = new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3).exp());
-
     if (allRoots) {
       var all = [principal, new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3 + Math.PI * 2 / 3).exp()), new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3 - Math.PI * 2 / 3).exp())];
       return config.matrix === 'Array' ? all : matrix(all);
@@ -91,33 +92,28 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
       return principal;
     }
   }
+
   /**
    * Calculate the cubic root for a Unit
    * @param {Unit} x
    * @return {Unit} Returns the cubic root of x
    * @private
    */
-
-
   function _cbrtUnit(x) {
     if (x.value && isComplex(x.value)) {
       var result = x.clone();
       result.value = 1.0;
       result = result.pow(1.0 / 3); // Compute the units
-
       result.value = _cbrtComplex(x.value); // Compute the value
-
       return result;
     } else {
       var negate = isNegative(x.value);
-
       if (negate) {
         x.value = unaryMinus(x.value);
-      } // TODO: create a helper function for this
-
+      }
 
+      // TODO: create a helper function for this
       var third;
-
       if (isBigNumber(x.value)) {
         third = new BigNumber(1).div(3);
       } else if (isFraction(x.value)) {
@@ -125,13 +121,10 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
       } else {
         third = 1 / 3;
       }
-
       var _result = x.pow(third);
-
       if (negate) {
         _result.value = unaryMinus(_result.value);
       }
-
       return _result;
     }
   }

package/lib/esm/function/arithmetic/ceil.js

@@ -97,7 +97,6 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
-
   return typed('ceil', {
     number: ceilNumber.signatures.number,
     'number,number': ceilNumber.signatures['number,number'],
@@ -153,11 +152,9 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     }),
     'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (x, y) => {
       if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
-
       if (y.storage() === 'dense') {
         return matAlgo14xDs(y, x, self, true);
       }
-
       return matAlgo12xSfs(y, x, self, true);
     })
   });

package/lib/esm/function/arithmetic/cube.js

@@ -6,7 +6,6 @@ export var createCube = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Compute the cube of a value, `x * x * x`.
    * To avoid confusion with `pow(M,3)`, this function does not apply to matrices.
@@ -37,12 +36,14 @@ export var createCube = /* #__PURE__ */factory(name, dependencies, _ref => {
     Complex: function Complex(x) {
       return x.mul(x).mul(x); // Is faster than pow(x, 3)
     },
+
     BigNumber: function BigNumber(x) {
       return x.times(x).times(x);
     },
     Fraction: function Fraction(x) {
       return x.pow(3); // Is faster than mul()mul()mul()
     },
+
     Unit: function Unit(x) {
       return x.pow(3);
     }

package/lib/esm/function/arithmetic/divide.js

@@ -20,6 +20,7 @@ export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
   var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
+
   /**
    * Divide two values, `x / y`.
    * To divide matrices, `x` is multiplied with the inverse of `y`: `x * inv(y)`.
@@ -51,9 +52,9 @@ export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} y          Denominator
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
    */
-
   return typed('divide', extend({
     // we extend the signatures of divideScalar with signatures dealing with matrices
+
     'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(x, y) {
       // TODO: implement matrix right division using pseudo inverse
       // https://www.mathworks.nl/help/matlab/ref/mrdivide.html

package/lib/esm/function/arithmetic/divideScalar.js

@@ -6,7 +6,6 @@ export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref
     typed,
     numeric
   } = _ref;
-
   /**
    * Divide two scalar values, `x / y`.
    * This function is meant for internal use: it is used by the public functions

package/lib/esm/function/arithmetic/dotDivide.js

@@ -38,6 +38,7 @@ export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref =>
     typed,
     matrix
   });
+
   /**
    * Divide two matrices element wise. The function accepts both matrices and
    * scalar values.
@@ -64,7 +65,6 @@ export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Denominator
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Quotient, `x ./ y`
    */
-
   return typed(name, matrixAlgorithmSuite({
     elop: divideScalar,
     SS: matAlgo07xSSf,

package/lib/esm/function/arithmetic/dotMultiply.js

@@ -28,6 +28,7 @@ export var createDotMultiply = /* #__PURE__ */factory(name, dependencies, _ref =
     typed,
     matrix
   });
+
   /**
    * Multiply two matrices element wise. The function accepts both matrices and
    * scalar values.
@@ -54,7 +55,6 @@ export var createDotMultiply = /* #__PURE__ */factory(name, dependencies, _ref =
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Right hand value
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Multiplication of `x` and `y`
    */
-
   return typed(name, matrixAlgorithmSuite({
     elop: multiplyScalar,
     SS: matAlgo09xS0Sf,