mathjs 12.4.2 → 13.0.0

package/lib/cjs/function/algebra/solver/lsolveAll.js

@@ -1,25 +1,25 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLsolveAll = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _factory = require("../../../utils/factory.js");
 var _solveValidation = require("./utils/solveValidation.js");
-var name = 'lsolveAll';
-var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
-var createLsolveAll = exports.createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    divideScalar = _ref.divideScalar,
-    multiplyScalar = _ref.multiplyScalar,
-    subtractScalar = _ref.subtractScalar,
-    equalScalar = _ref.equalScalar,
-    DenseMatrix = _ref.DenseMatrix;
-  var solveValidation = (0, _solveValidation.createSolveValidation)({
-    DenseMatrix: DenseMatrix
+const name = 'lsolveAll';
+const dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
+const createLsolveAll = exports.createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    divideScalar,
+    multiplyScalar,
+    subtractScalar,
+    equalScalar,
+    DenseMatrix
+  } = _ref;
+  const solveValidation = (0, _solveValidation.createSolveValidation)({
+    DenseMatrix
   });
 
   /**
@@ -47,18 +47,16 @@ var createLsolveAll = exports.createLsolveAll = /* #__PURE__ */(0, _factory.fact
    * @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) {
+    'SparseMatrix, Array | Matrix': function (m, b) {
       return _sparseForwardSubstitution(m, b);
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+    'DenseMatrix, Array | Matrix': function (m, b) {
       return _denseForwardSubstitution(m, b);
     },
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
-      var m = matrix(a);
-      var R = _denseForwardSubstitution(m, b);
-      return R.map(function (r) {
-        return r.valueOf();
-      });
+    'Array, Array | Matrix': function (a, b) {
+      const m = matrix(a);
+      const R = _denseForwardSubstitution(m, b);
+      return R.map(r => r.valueOf());
     }
   });
   function _denseForwardSubstitution(m, b_) {
@@ -66,25 +64,23 @@ var createLsolveAll = exports.createLsolveAll = /* #__PURE__ */(0, _factory.fact
     // https://www.overleaf.com/read/csvgqdxggyjv
 
     // array of right-hand sides
-    var B = [solveValidation(m, b_, true)._data.map(function (e) {
-      return e[0];
-    })];
-    var M = m._data;
-    var rows = m._size[0];
-    var columns = m._size[1];
+    const B = [solveValidation(m, b_, true)._data.map(e => e[0])];
+    const M = m._data;
+    const rows = m._size[0];
+    const columns = m._size[1];
 
     // loop columns
-    for (var i = 0; i < columns; i++) {
-      var L = B.length;
+    for (let i = 0; i < columns; i++) {
+      let L = B.length;
 
       // loop right-hand sides
-      for (var k = 0; k < L; k++) {
-        var b = B[k];
+      for (let k = 0; k < L; k++) {
+        const b = B[k];
         if (!equalScalar(M[i][i], 0)) {
           // non-singular row
 
           b[i] = divideScalar(b[i], M[i][i]);
-          for (var j = i + 1; j < columns; j++) {
+          for (let j = i + 1; j < columns; j++) {
             // b[j] -= b[i] * M[j,i]
             b[j] = subtractScalar(b[j], multiplyScalar(b[i], M[j][i]));
           }
@@ -103,55 +99,49 @@ var createLsolveAll = exports.createLsolveAll = /* #__PURE__ */(0, _factory.fact
         } else if (k === 0) {
           // singular row, RHS is zero
 
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          const bNew = [...b];
           bNew[i] = 1;
-          for (var _j = i + 1; _j < columns; _j++) {
-            bNew[_j] = subtractScalar(bNew[_j], M[_j][i]);
+          for (let j = i + 1; j < columns; j++) {
+            bNew[j] = subtractScalar(bNew[j], M[j][i]);
           }
           B.push(bNew);
         }
       }
     }
-    return B.map(function (x) {
-      return new DenseMatrix({
-        data: x.map(function (e) {
-          return [e];
-        }),
-        size: [rows, 1]
-      });
-    });
+    return B.map(x => new DenseMatrix({
+      data: x.map(e => [e]),
+      size: [rows, 1]
+    }));
   }
   function _sparseForwardSubstitution(m, b_) {
     // array of right-hand sides
-    var B = [solveValidation(m, b_, true)._data.map(function (e) {
-      return e[0];
-    })];
-    var rows = m._size[0];
-    var columns = m._size[1];
-    var values = m._values;
-    var index = m._index;
-    var ptr = m._ptr;
+    const B = [solveValidation(m, b_, true)._data.map(e => e[0])];
+    const rows = m._size[0];
+    const columns = m._size[1];
+    const values = m._values;
+    const index = m._index;
+    const ptr = m._ptr;
 
     // loop columns
-    for (var i = 0; i < columns; i++) {
-      var L = B.length;
+    for (let i = 0; i < columns; i++) {
+      let L = B.length;
 
       // loop right-hand sides
-      for (var k = 0; k < L; k++) {
-        var b = B[k];
+      for (let k = 0; k < L; k++) {
+        const b = B[k];
 
         // values & indices (column i)
-        var iValues = [];
-        var iIndices = [];
+        const iValues = [];
+        const iIndices = [];
 
         // first & last indeces in column
-        var firstIndex = ptr[i];
-        var lastIndex = ptr[i + 1];
+        const firstIndex = ptr[i];
+        const lastIndex = ptr[i + 1];
 
         // find the value at [i, i]
-        var Mii = 0;
-        for (var j = firstIndex; j < lastIndex; j++) {
-          var J = index[j];
+        let Mii = 0;
+        for (let j = firstIndex; j < lastIndex; j++) {
+          const J = index[j];
           // check row
           if (J === i) {
             Mii = values[j];
@@ -165,9 +155,9 @@ var createLsolveAll = exports.createLsolveAll = /* #__PURE__ */(0, _factory.fact
           // non-singular row
 
           b[i] = divideScalar(b[i], Mii);
-          for (var _j2 = 0, _lastIndex = iIndices.length; _j2 < _lastIndex; _j2++) {
-            var _J = iIndices[_j2];
-            b[_J] = subtractScalar(b[_J], multiplyScalar(b[i], iValues[_j2]));
+          for (let j = 0, lastIndex = iIndices.length; j < lastIndex; j++) {
+            const J = iIndices[j];
+            b[J] = subtractScalar(b[J], multiplyScalar(b[i], iValues[j]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
@@ -184,23 +174,19 @@ var createLsolveAll = exports.createLsolveAll = /* #__PURE__ */(0, _factory.fact
         } else if (k === 0) {
           // singular row, RHS is zero
 
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          const bNew = [...b];
           bNew[i] = 1;
-          for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {
-            var _J2 = iIndices[_j3];
-            bNew[_J2] = subtractScalar(bNew[_J2], iValues[_j3]);
+          for (let j = 0, lastIndex = iIndices.length; j < lastIndex; j++) {
+            const J = iIndices[j];
+            bNew[J] = subtractScalar(bNew[J], iValues[j]);
           }
           B.push(bNew);
         }
       }
     }
-    return B.map(function (x) {
-      return new DenseMatrix({
-        data: x.map(function (e) {
-          return [e];
-        }),
-        size: [rows, 1]
-      });
-    });
+    return B.map(x => new DenseMatrix({
+      data: x.map(e => [e]),
+      size: [rows, 1]
+    }));
   }
 });

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

@@ -8,18 +8,20 @@ var _is = require("../../../utils/is.js");
 var _factory = require("../../../utils/factory.js");
 var _solveValidation = require("./utils/solveValidation.js");
 var _csIpvec = require("../sparse/csIpvec.js");
-var name = 'lusolve';
-var dependencies = ['typed', 'matrix', 'lup', 'slu', 'usolve', 'lsolve', 'DenseMatrix'];
-var createLusolve = exports.createLusolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    lup = _ref.lup,
-    slu = _ref.slu,
-    usolve = _ref.usolve,
-    lsolve = _ref.lsolve,
-    DenseMatrix = _ref.DenseMatrix;
-  var solveValidation = (0, _solveValidation.createSolveValidation)({
-    DenseMatrix: DenseMatrix
+const name = 'lusolve';
+const dependencies = ['typed', 'matrix', 'lup', 'slu', 'usolve', 'lsolve', 'DenseMatrix'];
+const createLusolve = exports.createLusolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    lup,
+    slu,
+    usolve,
+    lsolve,
+    DenseMatrix
+  } = _ref;
+  const solveValidation = (0, _solveValidation.createSolveValidation)({
+    DenseMatrix
   });
 
   /**
@@ -56,25 +58,25 @@ var createLusolve = exports.createLusolve = /* #__PURE__ */(0, _factory.factory)
    * @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) {
+    'Array, Array | Matrix': function (a, b) {
       a = matrix(a);
-      var d = lup(a);
-      var x = _lusolve(d.L, d.U, d.p, null, b);
+      const d = lup(a);
+      const x = _lusolve(d.L, d.U, d.p, null, b);
       return x.valueOf();
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(a, b) {
-      var d = lup(a);
+    'DenseMatrix, Array | Matrix': function (a, b) {
+      const d = lup(a);
       return _lusolve(d.L, d.U, d.p, null, b);
     },
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(a, b) {
-      var d = lup(a);
+    'SparseMatrix, Array | Matrix': function (a, b) {
+      const d = lup(a);
       return _lusolve(d.L, d.U, d.p, null, b);
     },
-    'SparseMatrix, Array | Matrix, number, number': function SparseMatrixArrayMatrixNumberNumber(a, b, order, threshold) {
-      var d = slu(a, order, threshold);
+    'SparseMatrix, Array | Matrix, number, number': function (a, b, order, threshold) {
+      const d = slu(a, order, threshold);
       return _lusolve(d.L, d.U, d.p, d.q, b);
     },
-    'Object, Array | Matrix': function ObjectArrayMatrix(d, b) {
+    'Object, Array | Matrix': function (d, b) {
       return _lusolve(d.L, d.U, d.p, d.q, b);
     }
   });
@@ -99,9 +101,9 @@ var createLusolve = exports.createLusolve = /* #__PURE__ */(0, _factory.factory)
     }
 
     // use forward substitution to resolve L * y = b
-    var y = lsolve(l, b);
+    const y = lsolve(l, b);
     // use backward substitution to resolve U * x = y
-    var x = usolve(u, y);
+    const x = usolve(u, y);
 
     // apply column permutations if needed (x is a DenseMatrix)
     if (q) {

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

@@ -6,18 +6,20 @@ Object.defineProperty(exports, "__esModule", {
 exports.createUsolve = void 0;
 var _factory = require("../../../utils/factory.js");
 var _solveValidation = require("./utils/solveValidation.js");
-var name = 'usolve';
-var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
-var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    divideScalar = _ref.divideScalar,
-    multiplyScalar = _ref.multiplyScalar,
-    subtractScalar = _ref.subtractScalar,
-    equalScalar = _ref.equalScalar,
-    DenseMatrix = _ref.DenseMatrix;
-  var solveValidation = (0, _solveValidation.createSolveValidation)({
-    DenseMatrix: DenseMatrix
+const name = 'usolve';
+const dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
+const createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    divideScalar,
+    multiplyScalar,
+    subtractScalar,
+    equalScalar,
+    DenseMatrix
+  } = _ref;
+  const solveValidation = (0, _solveValidation.createSolveValidation)({
+    DenseMatrix
   });
 
   /**
@@ -45,37 +47,37 @@ var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(n
    * @return {DenseMatrix | Array}  A column vector with the linear system solution (x)
    */
   return typed(name, {
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
+    'SparseMatrix, Array | Matrix': function (m, b) {
       return _sparseBackwardSubstitution(m, b);
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+    'DenseMatrix, Array | Matrix': function (m, b) {
       return _denseBackwardSubstitution(m, b);
     },
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
-      var m = matrix(a);
-      var r = _denseBackwardSubstitution(m, b);
+    'Array, Array | Matrix': function (a, b) {
+      const m = matrix(a);
+      const 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];
+    const bdata = b._data;
+    const rows = m._size[0];
+    const columns = m._size[1];
 
     // result
-    var x = [];
-    var mdata = m._data;
+    const x = [];
+    const mdata = m._data;
     // loop columns backwards
-    for (var j = columns - 1; j >= 0; j--) {
+    for (let j = columns - 1; j >= 0; j--) {
       // b[j]
-      var bj = bdata[j][0] || 0;
+      const bj = bdata[j][0] || 0;
       // x[j]
-      var xj = void 0;
+      let xj;
       if (!equalScalar(bj, 0)) {
         // value at [j, j]
-        var vjj = mdata[j][j];
+        const vjj = mdata[j][j];
         if (equalScalar(vjj, 0)) {
           // system cannot be solved
           throw new Error('Linear system cannot be solved since matrix is singular');
@@ -83,7 +85,7 @@ var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(n
         xj = divideScalar(bj, vjj);
 
         // loop rows
-        for (var i = j - 1; i >= 0; i--) {
+        for (let i = j - 1; i >= 0; i--) {
           // update copy of b
           bdata[i] = [subtractScalar(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
         }
@@ -102,35 +104,35 @@ var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(n
   function _sparseBackwardSubstitution(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];
-    var values = m._values;
-    var index = m._index;
-    var ptr = m._ptr;
+    const bdata = b._data;
+    const rows = m._size[0];
+    const columns = m._size[1];
+    const values = m._values;
+    const index = m._index;
+    const ptr = m._ptr;
 
     // result
-    var x = [];
+    const x = [];
 
     // loop columns backwards
-    for (var j = columns - 1; j >= 0; j--) {
-      var bj = bdata[j][0] || 0;
+    for (let j = columns - 1; j >= 0; j--) {
+      const bj = bdata[j][0] || 0;
       if (!equalScalar(bj, 0)) {
         // non-degenerate row, find solution
 
-        var vjj = 0;
+        let vjj = 0;
 
         // upper triangular matrix values & index (column j)
-        var jValues = [];
-        var jIndices = [];
+        const jValues = [];
+        const jIndices = [];
 
         // first & last indeces in column
-        var firstIndex = ptr[j];
-        var lastIndex = ptr[j + 1];
+        const firstIndex = ptr[j];
+        const 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];
+        for (let k = lastIndex - 1; k >= firstIndex; k--) {
+          const i = index[k];
 
           // check row (rows are not sorted!)
           if (i === j) {
@@ -146,10 +148,10 @@ var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(n
         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] = [subtractScalar(bdata[_i][0], multiplyScalar(xj, jValues[_k]))];
+        const xj = divideScalar(bj, vjj);
+        for (let k = 0, lastIndex = jIndices.length; k < lastIndex; k++) {
+          const i = jIndices[k];
+          bdata[i] = [subtractScalar(bdata[i][0], multiplyScalar(xj, jValues[k]))];
         }
         x[j] = [xj];
       } else {