mathjs 8.1.0 → 12.2.1

package/lib/esm/function/algebra/solver/lusolve.js

@@ -4,7 +4,7 @@ import { createSolveValidation } from './utils/solveValidation.js';
 import { csIpvec } from '../sparse/csIpvec.js';
 var name = 'lusolve';
 var dependencies = ['typed', 'matrix', 'lup', 'slu', 'usolve', 'lsolve', 'DenseMatrix'];
-export var createLusolve = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createLusolve = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
@@ -17,6 +17,7 @@ export var createLusolve = /* #__PURE__ */factory(name, dependencies, (_ref) =>
   var solveValidation = createSolveValidation({
     DenseMatrix
   });
+
   /**
    * Solves the linear system `A * x = b` where `A` is an [n x n] matrix and `b` is a [n] column vector.
    *
@@ -50,14 +51,11 @@ export var createLusolve = /* #__PURE__ */factory(name, dependencies, (_ref) =>
    *
    * @return {DenseMatrix | Array}           Column vector with the solution to the linear system A * x = b
    */
-
   return typed(name, {
     'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
       a = matrix(a);
       var d = lup(a);
-
       var x = _lusolve(d.L, d.U, d.p, null, b);
-
       return x.valueOf();
     },
     'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(a, b) {
@@ -76,38 +74,35 @@ export var createLusolve = /* #__PURE__ */factory(name, dependencies, (_ref) =>
       return _lusolve(d.L, d.U, d.p, d.q, b);
     }
   });
-
   function _toMatrix(a) {
     if (isMatrix(a)) {
       return a;
     }
-
     if (isArray(a)) {
       return matrix(a);
     }
-
     throw new TypeError('Invalid Matrix LU decomposition');
   }
-
   function _lusolve(l, u, p, q, b) {
     // verify decomposition
     l = _toMatrix(l);
-    u = _toMatrix(u); // apply row permutations if needed (b is a DenseMatrix)
+    u = _toMatrix(u);
 
+    // apply row permutations if needed (b is a DenseMatrix)
     if (p) {
       b = solveValidation(l, b, true);
       b._data = csIpvec(p, b._data);
-    } // use forward substitution to resolve L * y = b
-
-
-    var y = lsolve(l, b); // use backward substitution to resolve U * x = y
+    }
 
-    var x = usolve(u, y); // apply column permutations if needed (x is a DenseMatrix)
+    // use forward substitution to resolve L * y = b
+    var y = lsolve(l, b);
+    // use backward substitution to resolve U * x = y
+    var x = usolve(u, y);
 
+    // apply column permutations if needed (x is a DenseMatrix)
     if (q) {
       x._data = csIpvec(q, x._data);
     }
-
     return x;
   }
 });

package/lib/esm/function/algebra/solver/usolve.js

@@ -1,20 +1,21 @@
 import { factory } from '../../../utils/factory.js';
 import { createSolveValidation } from './utils/solveValidation.js';
 var name = 'usolve';
-var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
-export var createUsolve = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
+export var createUsolve = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     divideScalar,
     multiplyScalar,
-    subtract,
+    subtractScalar,
     equalScalar,
     DenseMatrix
   } = _ref;
   var solveValidation = createSolveValidation({
     DenseMatrix
   });
+
   /**
    * Finds one solution of a linear equation system by backward substitution. Matrix must be an upper triangular matrix. Throws an error if there's no solution.
    *
@@ -39,7 +40,6 @@ export var createUsolve = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    *
    * @return {DenseMatrix | Array}  A column vector with the linear system solution (x)
    */
-
   return typed(name, {
     'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
       return _sparseBackwardSubstitution(m, b);
@@ -49,59 +49,52 @@ export var createUsolve = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     },
     'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
       var m = matrix(a);
-
       var r = _denseBackwardSubstitution(m, b);
-
       return r.valueOf();
     }
   });
-
   function _denseBackwardSubstitution(m, b) {
     // make b into a column vector
     b = solveValidation(m, b, true);
     var bdata = b._data;
     var rows = m._size[0];
-    var columns = m._size[1]; // result
+    var columns = m._size[1];
 
+    // result
     var x = [];
-    var mdata = m._data; // loop columns backwards
-
+    var mdata = m._data;
+    // loop columns backwards
     for (var j = columns - 1; j >= 0; j--) {
       // b[j]
-      var bj = bdata[j][0] || 0; // x[j]
-
+      var bj = bdata[j][0] || 0;
+      // x[j]
       var xj = void 0;
-
       if (!equalScalar(bj, 0)) {
         // value at [j, j]
         var vjj = mdata[j][j];
-
         if (equalScalar(vjj, 0)) {
           // system cannot be solved
           throw new Error('Linear system cannot be solved since matrix is singular');
         }
+        xj = divideScalar(bj, vjj);
 
-        xj = divideScalar(bj, vjj); // loop rows
-
+        // loop rows
         for (var i = j - 1; i >= 0; i--) {
           // update copy of b
-          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
+          bdata[i] = [subtractScalar(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
         }
       } else {
         // zero value at j
         xj = 0;
-      } // update x
-
-
+      }
+      // update x
       x[j] = [xj];
     }
-
     return new DenseMatrix({
       data: x,
       size: [rows, 1]
     });
   }
-
   function _sparseBackwardSubstitution(m, b) {
     // make b into a column vector
     b = solveValidation(m, b, true);
@@ -110,26 +103,32 @@ export var createUsolve = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     var columns = m._size[1];
     var values = m._values;
     var index = m._index;
-    var ptr = m._ptr; // result
+    var ptr = m._ptr;
 
-    var x = []; // loop columns backwards
+    // result
+    var x = [];
 
+    // loop columns backwards
     for (var j = columns - 1; j >= 0; j--) {
       var bj = bdata[j][0] || 0;
-
       if (!equalScalar(bj, 0)) {
         // non-degenerate row, find solution
-        var vjj = 0; // upper triangular matrix values & index (column j)
 
+        var vjj = 0;
+
+        // upper triangular matrix values & index (column j)
         var jValues = [];
-        var jIndices = []; // first & last indeces in column
+        var jIndices = [];
 
+        // first & last indeces in column
         var firstIndex = ptr[j];
-        var lastIndex = ptr[j + 1]; // values in column, find value at [j, j], loop backwards
+        var lastIndex = ptr[j + 1];
 
+        // values in column, find value at [j, j], loop backwards
         for (var k = lastIndex - 1; k >= firstIndex; k--) {
-          var i = index[k]; // check row (rows are not sorted!)
+          var i = index[k];
 
+          // check row (rows are not sorted!)
           if (i === j) {
             vjj = values[k];
           } else if (i < j) {
@@ -137,27 +136,23 @@ export var createUsolve = /* #__PURE__ */factory(name, dependencies, (_ref) => {
             jValues.push(values[k]);
             jIndices.push(i);
           }
-        } // at this point we must have a value in vjj
-
+        }
 
+        // at this point we must have a value in vjj
         if (equalScalar(vjj, 0)) {
           throw new Error('Linear system cannot be solved since matrix is singular');
         }
-
         var xj = divideScalar(bj, vjj);
-
         for (var _k = 0, _lastIndex = jIndices.length; _k < _lastIndex; _k++) {
           var _i = jIndices[_k];
-          bdata[_i] = [subtract(bdata[_i][0], multiplyScalar(xj, jValues[_k]))];
+          bdata[_i] = [subtractScalar(bdata[_i][0], multiplyScalar(xj, jValues[_k]))];
         }
-
         x[j] = [xj];
       } else {
         // degenerate row, we can choose any value
         x[j] = [0];
       }
     }
-
     return new DenseMatrix({
       data: x,
       size: [rows, 1]

package/lib/esm/function/algebra/solver/usolveAll.js

@@ -1,20 +1,21 @@
 import { factory } from '../../../utils/factory.js';
 import { createSolveValidation } from './utils/solveValidation.js';
 var name = 'usolveAll';
-var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
-export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
+export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     divideScalar,
     multiplyScalar,
-    subtract,
+    subtractScalar,
     equalScalar,
     DenseMatrix
   } = _ref;
   var solveValidation = createSolveValidation({
     DenseMatrix
   });
+
   /**
    * Finds all solutions of a linear equation system by backward substitution. Matrix must be an upper triangular matrix.
    *
@@ -22,13 +23,13 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *
    * Syntax:
    *
-   *    math.usolve(U, b)
+   *    math.usolveAll(U, b)
    *
    * Examples:
    *
    *    const a = [[-2, 3], [2, 1]]
    *    const b = [11, 9]
-   *    const x = usolve(a, b)  // [ [[8], [9]] ]
+   *    const x = usolveAll(a, b)  // [ [[8], [9]] ]
    *
    * See also:
    *
@@ -39,7 +40,6 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *
    * @return {DenseMatrix[] | Array[]}  An array of affine-independent column vectors (x) that solve the linear system
    */
-
   return typed(name, {
     'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
       return _sparseBackwardSubstitution(m, b);
@@ -49,38 +49,38 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) =
     },
     'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
       var m = matrix(a);
-
       var R = _denseBackwardSubstitution(m, b);
-
       return R.map(r => r.valueOf());
     }
   });
-
   function _denseBackwardSubstitution(m, b_) {
     // the algorithm is derived from
-    // https://www.overleaf.com/project/5e6c87c554a3190001a3fc93
+    // https://www.overleaf.com/read/csvgqdxggyjv
+
     // array of right-hand sides
     var B = [solveValidation(m, b_, true)._data.map(e => e[0])];
     var M = m._data;
     var rows = m._size[0];
-    var columns = m._size[1]; // loop columns backwards
+    var columns = m._size[1];
 
+    // loop columns backwards
     for (var i = columns - 1; i >= 0; i--) {
-      var L = B.length; // loop right-hand sides
+      var L = B.length;
 
+      // loop right-hand sides
       for (var k = 0; k < L; k++) {
         var b = B[k];
-
         if (!equalScalar(M[i][i], 0)) {
           // non-singular row
-          b[i] = divideScalar(b[i], M[i][i]);
 
+          b[i] = divideScalar(b[i], M[i][i]);
           for (var j = i - 1; j >= 0; j--) {
             // b[j] -= b[i] * M[j,i]
-            b[j] = subtract(b[j], multiplyScalar(b[i], M[j][i]));
+            b[j] = subtractScalar(b[j], multiplyScalar(b[i], M[j][i]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
+
           if (k === 0) {
             // There is no valid solution
             return [];
@@ -92,24 +92,21 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) =
           }
         } else if (k === 0) {
           // singular row, RHS is zero
+
           var bNew = [...b];
           bNew[i] = 1;
-
           for (var _j = i - 1; _j >= 0; _j--) {
-            bNew[_j] = subtract(bNew[_j], M[_j][i]);
+            bNew[_j] = subtractScalar(bNew[_j], M[_j][i]);
           }
-
           B.push(bNew);
         }
       }
     }
-
     return B.map(x => new DenseMatrix({
       data: x.map(e => [e]),
       size: [rows, 1]
     }));
   }
-
   function _sparseBackwardSubstitution(m, b_) {
     // array of right-hand sides
     var B = [solveValidation(m, b_, true)._data.map(e => e[0])];
@@ -117,25 +114,29 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) =
     var columns = m._size[1];
     var values = m._values;
     var index = m._index;
-    var ptr = m._ptr; // loop columns backwards
+    var ptr = m._ptr;
 
+    // loop columns backwards
     for (var i = columns - 1; i >= 0; i--) {
-      var L = B.length; // loop right-hand sides
+      var L = B.length;
 
+      // loop right-hand sides
       for (var k = 0; k < L; k++) {
-        var b = B[k]; // values & indices (column i)
+        var b = B[k];
 
+        // values & indices (column i)
         var iValues = [];
-        var iIndices = []; // first & last indeces in column
+        var iIndices = [];
 
+        // first & last indeces in column
         var firstIndex = ptr[i];
-        var lastIndex = ptr[i + 1]; // find the value at [i, i]
+        var lastIndex = ptr[i + 1];
 
+        // find the value at [i, i]
         var Mii = 0;
-
         for (var j = lastIndex - 1; j >= firstIndex; j--) {
-          var J = index[j]; // check row
-
+          var J = index[j];
+          // check row
           if (J === i) {
             Mii = values[j];
           } else if (J < i) {
@@ -144,17 +145,19 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) =
             iIndices.push(J);
           }
         }
-
         if (!equalScalar(Mii, 0)) {
           // non-singular row
-          b[i] = divideScalar(b[i], Mii); // loop upper triangular
 
+          b[i] = divideScalar(b[i], Mii);
+
+          // loop upper triangular
           for (var _j2 = 0, _lastIndex = iIndices.length; _j2 < _lastIndex; _j2++) {
             var _J = iIndices[_j2];
-            b[_J] = subtract(b[_J], multiplyScalar(b[i], iValues[_j2]));
+            b[_J] = subtractScalar(b[_J], multiplyScalar(b[i], iValues[_j2]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
+
           if (k === 0) {
             // There is no valid solution
             return [];
@@ -166,19 +169,19 @@ export var createUsolveAll = /* #__PURE__ */factory(name, dependencies, (_ref) =
           }
         } else if (k === 0) {
           // singular row, RHS is zero
+
           var bNew = [...b];
-          bNew[i] = 1; // loop upper triangular
+          bNew[i] = 1;
 
+          // loop upper triangular
           for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {
             var _J2 = iIndices[_j3];
-            bNew[_J2] = subtract(bNew[_J2], iValues[_j3]);
+            bNew[_J2] = subtractScalar(bNew[_J2], iValues[_j3]);
           }
-
           B.push(bNew);
         }
       }
     }
-
     return B.map(x => new DenseMatrix({
       data: x.map(e => [e]),
       size: [rows, 1]

package/lib/esm/function/algebra/solver/utils/solveValidation.js

@@ -5,7 +5,6 @@ export function createSolveValidation(_ref) {
   var {
     DenseMatrix
   } = _ref;
-
   /**
    * Validates matrix and column vector b for backward/forward substitution algorithms.
    *
@@ -17,122 +16,99 @@ export function createSolveValidation(_ref) {
    */
   return function solveValidation(m, b, copy) {
     var mSize = m.size();
-
     if (mSize.length !== 2) {
       throw new RangeError('Matrix must be two dimensional (size: ' + format(mSize) + ')');
     }
-
     var rows = mSize[0];
     var columns = mSize[1];
-
     if (rows !== columns) {
       throw new RangeError('Matrix must be square (size: ' + format(mSize) + ')');
     }
-
     var data = [];
-
     if (isMatrix(b)) {
       var bSize = b.size();
-      var bdata = b._data; // 1-dim vector
+      var bdata = b._data;
 
+      // 1-dim vector
       if (bSize.length === 1) {
         if (bSize[0] !== rows) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
         }
-
         for (var i = 0; i < rows; i++) {
           data[i] = [bdata[i]];
         }
-
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1],
           datatype: b._datatype
         });
-      } // 2-dim column
-
+      }
 
+      // 2-dim column
       if (bSize.length === 2) {
         if (bSize[0] !== rows || bSize[1] !== 1) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
         }
-
         if (isDenseMatrix(b)) {
           if (copy) {
             data = [];
-
             for (var _i = 0; _i < rows; _i++) {
               data[_i] = [bdata[_i][0]];
             }
-
             return new DenseMatrix({
-              data: data,
+              data,
               size: [rows, 1],
               datatype: b._datatype
             });
           }
-
           return b;
         }
-
         if (isSparseMatrix(b)) {
           for (var _i2 = 0; _i2 < rows; _i2++) {
             data[_i2] = [0];
           }
-
           var values = b._values;
           var index = b._index;
           var ptr = b._ptr;
-
           for (var k1 = ptr[1], k = ptr[0]; k < k1; k++) {
             var _i3 = index[k];
             data[_i3][0] = values[k];
           }
-
           return new DenseMatrix({
-            data: data,
+            data,
             size: [rows, 1],
             datatype: b._datatype
           });
         }
       }
-
       throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.');
     }
-
     if (isArray(b)) {
       var bsize = arraySize(b);
-
       if (bsize.length === 1) {
         if (bsize[0] !== rows) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
         }
-
         for (var _i4 = 0; _i4 < rows; _i4++) {
           data[_i4] = [b[_i4]];
         }
-
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }
-
       if (bsize.length === 2) {
         if (bsize[0] !== rows || bsize[1] !== 1) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
         }
-
         for (var _i5 = 0; _i5 < rows; _i5++) {
           data[_i5] = [b[_i5][0]];
         }
-
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }
-
       throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.');
     }
   };