mathjs 7.2.0 → 7.5.1

package/es/expression/embeddedDocs/embeddedDocs.js

@@ -9,6 +9,9 @@ import { isNegativeDocs } from './function/utils/isNegative';
 import { isIntegerDocs } from './function/utils/isInteger';
 import { isNaNDocs } from './function/utils/isNaN';
 import { formatDocs } from './function/utils/format';
+import { binDocs } from './function/utils/bin';
+import { octDocs } from './function/utils/oct';
+import { hexDocs } from './function/utils/hex';
 import { cloneDocs } from './function/utils/clone';
 import { toDocs } from './function/units/to';
 import { tanhDocs } from './function/trigonometry/tanh';
@@ -167,11 +170,13 @@ import { addDocs } from './function/arithmetic/add';
 import { absDocs } from './function/arithmetic/abs';
 import { qrDocs } from './function/algebra/qr';
 import { usolveDocs } from './function/algebra/usolve';
+import { usolveAllDocs } from './function/algebra/usolveAll';
 import { sluDocs } from './function/algebra/slu';
 import { rationalizeDocs } from './function/algebra/rationalize';
 import { simplifyDocs } from './function/algebra/simplify';
 import { lupDocs } from './function/algebra/lup';
 import { lsolveDocs } from './function/algebra/lsolve';
+import { lsolveAllDocs } from './function/algebra/lsolveAll';
 import { derivativeDocs } from './function/algebra/derivative';
 import { versionDocs } from './constants/version';
 import { trueDocs } from './constants/true';
@@ -209,6 +214,7 @@ import { sinDocs } from './function/trigonometry/sin';
 import { numericDocs } from './function/utils/numeric';
 import { columnDocs } from './function/matrix/column';
 import { rowDocs } from './function/matrix/row';
+import { rotationMatrixDocs } from './function/matrix/rotationMatrix';
 export var embeddedDocs = {
   // construction functions
   bignumber: bignumberDocs,
@@ -450,12 +456,14 @@ export var embeddedDocs = {
   // functions - algebra
   derivative: derivativeDocs,
   lsolve: lsolveDocs,
+  lsolveAll: lsolveAllDocs,
   lup: lupDocs,
   lusolve: lusolveDocs,
   simplify: simplifyDocs,
   rationalize: rationalizeDocs,
   slu: sluDocs,
   usolve: usolveDocs,
+  usolveAll: usolveAllDocs,
   qr: qrDocs,
   // functions - arithmetic
   abs: absDocs,
@@ -550,6 +558,7 @@ export var embeddedDocs = {
   range: rangeDocs,
   resize: resizeDocs,
   reshape: reshapeDocs,
+  rotationMatrix: rotationMatrixDocs,
   row: rowDocs,
   size: sizeDocs,
   sort: sortDocs,
@@ -638,6 +647,9 @@ export var embeddedDocs = {
   // functions - utils
   clone: cloneDocs,
   format: formatDocs,
+  bin: binDocs,
+  oct: octDocs,
+  hex: hexDocs,
   isNaN: isNaNDocs,
   isInteger: isIntegerDocs,
   isNegative: isNegativeDocs,

package/es/expression/embeddedDocs/function/algebra/lsolve.js

@@ -2,7 +2,7 @@ export var lsolveDocs = {
   name: 'lsolve',
   category: 'Algebra',
   syntax: ['x=lsolve(L, b)'],
-  description: 'Solves the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
+  description: 'Finds one solution of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
   examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lsolve(a, b)'],
-  seealso: ['lup', 'lusolve', 'usolve', 'matrix', 'sparse']
+  seealso: ['lsolveAll', 'lup', 'lusolve', 'usolve', 'matrix', 'sparse']
 };

package/es/expression/embeddedDocs/function/algebra/lsolveAll.js

@@ -0,0 +1,8 @@
+export var lsolveAllDocs = {
+  name: 'lsolveAll',
+  category: 'Algebra',
+  syntax: ['x=lsolveAll(L, b)'],
+  description: 'Finds all solutions of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
+  examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lsolve(a, b)'],
+  seealso: ['lsolve', 'lup', 'lusolve', 'usolve', 'matrix', 'sparse']
+};

package/es/expression/embeddedDocs/function/algebra/usolve.js

@@ -2,7 +2,7 @@ export var usolveDocs = {
   name: 'usolve',
   category: 'Algebra',
   syntax: ['x=usolve(U, b)'],
-  description: 'Solves the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
+  description: 'Finds one solution of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
   examples: ['x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])'],
-  seealso: ['lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
+  seealso: ['usolveAll', 'lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
 };

package/es/expression/embeddedDocs/function/algebra/usolveAll.js

@@ -0,0 +1,8 @@
+export var usolveAllDocs = {
+  name: 'usolveAll',
+  category: 'Algebra',
+  syntax: ['x=usolve(U, b)'],
+  description: 'Finds all solutions of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
+  examples: ['x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])'],
+  seealso: ['usolve', 'lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
+};

package/es/expression/embeddedDocs/function/matrix/rotationMatrix.js

@@ -0,0 +1,8 @@
+export var rotationMatrixDocs = {
+  name: 'rotationMatrix',
+  category: 'Matrix',
+  syntax: ['rotationMatrix(theta)', 'rotationMatrix(theta, v)', 'rotationMatrix(theta, v, format)'],
+  description: 'Returns a 2-D rotation matrix (2x2) for a given angle (in radians). ' + 'Returns a 2-D rotation matrix (3x3) of a given angle (in radians) around given axis.',
+  examples: ['rotationMatrix(pi / 2)', 'rotationMatrix(unit("45deg"), [0, 0, 1])', 'rotationMatrix(1, matrix([0, 0, 1]), "sparse")'],
+  seealso: ['cos', 'sin']
+};

package/es/expression/embeddedDocs/function/utils/bin.js

@@ -0,0 +1,8 @@
+export var binDocs = {
+  name: 'bin',
+  category: 'Utils',
+  syntax: ['bin(value)'],
+  description: 'Format a number as binary',
+  examples: ['bin(2)'],
+  seealso: ['oct', 'hex']
+};

package/es/expression/embeddedDocs/function/utils/hex.js

@@ -0,0 +1,8 @@
+export var hexDocs = {
+  name: 'hex',
+  category: 'Utils',
+  syntax: ['hex(value)'],
+  description: 'Format a number as hexadecimal',
+  examples: ['hex(240)'],
+  seealso: ['bin', 'oct']
+};

package/es/expression/embeddedDocs/function/utils/oct.js

@@ -0,0 +1,8 @@
+export var octDocs = {
+  name: 'oct',
+  category: 'Utils',
+  syntax: ['oct(value)'],
+  description: 'Format a number as octal',
+  examples: ['oct(56)'],
+  seealso: ['bin', 'hex']
+};

package/es/expression/parse.js

@@ -302,7 +302,24 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, function (_r
 
 
     if (parse.isDigitDot(c1)) {
-      state.tokenType = TOKENTYPE.NUMBER; // get number, can have a single dot
+      state.tokenType = TOKENTYPE.NUMBER; // check for binary, octal, or hex
+
+      var _c = currentString(state, 2);
+
+      if (_c === '0b' || _c === '0o' || _c === '0x') {
+        state.token += currentCharacter(state);
+        next(state);
+        state.token += currentCharacter(state);
+        next(state);
+
+        while (parse.isHexDigit(currentCharacter(state))) {
+          state.token += currentCharacter(state);
+          next(state);
+        }
+
+        return;
+      } // get number, can have a single dot
+
 
       if (currentCharacter(state) === '.') {
         state.token += currentCharacter(state);
@@ -514,6 +531,16 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, function (_r
   parse.isDigit = function isDigit(c) {
     return c >= '0' && c <= '9';
   };
+  /**
+   * checks if the given char c is a hex digit
+   * @param {string} c   a string with one character
+   * @return {boolean}
+   */
+
+
+  parse.isHexDigit = function isHexDigit(c) {
+    return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
+  };
   /**
    * Start of the parse levels below, in order of precedence
    * @return {Node} node

package/es/factoriesAny.js

@@ -78,6 +78,7 @@ export { createOnes } from './function/matrix/ones';
 export { createRange } from './function/matrix/range';
 export { createReshape } from './function/matrix/reshape';
 export { createResize } from './function/matrix/resize';
+export { createRotationMatrix } from './function/matrix/rotationMatrix';
 export { createRow } from './function/matrix/row';
 export { createSize } from './function/matrix/size';
 export { createSqueeze } from './function/matrix/squeeze';
@@ -89,6 +90,9 @@ export { createErf } from './function/special/erf';
 export { createMode } from './function/statistics/mode';
 export { createProd } from './function/statistics/prod';
 export { createFormat } from './function/string/format';
+export { createBin } from './function/string/bin';
+export { createOct } from './function/string/oct';
+export { createHex } from './function/string/hex';
 export { createPrint } from './function/string/print';
 export { createTo } from './function/unit/to';
 export { createIsPrime } from './function/utils/isPrime';
@@ -103,6 +107,8 @@ export { createDotPow } from './function/arithmetic/dotPow';
 export { createDotDivide } from './function/arithmetic/dotDivide';
 export { createLsolve } from './function/algebra/solver/lsolve';
 export { createUsolve } from './function/algebra/solver/usolve';
+export { createLsolveAll } from './function/algebra/solver/lsolveAll';
+export { createUsolveAll } from './function/algebra/solver/usolveAll';
 export { createLeftShift } from './function/bitwise/leftShift';
 export { createRightArithShift } from './function/bitwise/rightArithShift';
 export { createRightLogShift } from './function/bitwise/rightLogShift';

package/es/function/algebra/solver/lsolve.js

@@ -14,7 +14,7 @@ export var createLsolve = /* #__PURE__ */factory(name, dependencies, function (_
     DenseMatrix: DenseMatrix
   });
   /**
-   * Solves the linear equation system by forwards substitution. Matrix must be a lower triangular matrix.
+   * Finds one solution of a linear equation system by forwards substitution. Matrix must be a lower triangular matrix. Throws an error if there's no solution.
    *
    * `L * x = b`
    *
@@ -30,7 +30,7 @@ export var createLsolve = /* #__PURE__ */factory(name, dependencies, function (_
    *
    * See also:
    *
-   *    lup, slu, usolve, lusolve
+   *    lsolveAll, lup, slu, usolve, lusolve
    *
    * @param {Matrix, Array} L       A N x N matrix or array (L)
    * @param {Matrix, Array} b       A column vector with the b values
@@ -40,19 +40,15 @@ export var createLsolve = /* #__PURE__ */factory(name, dependencies, function (_
 
   return typed(name, {
     'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
-      // process matrix
       return _sparseForwardSubstitution(m, b);
     },
     'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
-      // process matrix
       return _denseForwardSubstitution(m, b);
     },
     'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
-      // create dense matrix from array
-      var m = matrix(a); // use matrix implementation
-
-      var r = _denseForwardSubstitution(m, b); // result
+      var m = matrix(a);
 
+      var r = _denseForwardSubstitution(m, b);
 
       return r.valueOf();
     }
@@ -60,48 +56,38 @@ export var createLsolve = /* #__PURE__ */factory(name, dependencies, function (_
 
   function _denseForwardSubstitution(m, b) {
     // validate matrix and vector, return copy of column vector b
-    b = solveValidation(m, b, true); // column vector data
-
-    var bdata = b._data; // rows & columns
-
+    b = solveValidation(m, b, true);
+    var bdata = b._data;
     var rows = m._size[0];
     var columns = m._size[1]; // result
 
-    var x = []; // data
-
-    var data = m._data; // forward solve m * x = b, loop columns
+    var x = [];
+    var mdata = m._data; // loop columns
 
     for (var j = 0; j < columns; j++) {
-      // b[j]
-      var bj = bdata[j][0] || 0; // x[j]
-
-      var xj = void 0; // forward substitution (outer product) avoids inner looping when bj === 0
+      var bj = bdata[j][0] || 0;
+      var xj = void 0;
 
       if (!equalScalar(bj, 0)) {
-        // value @ [j, j]
-        var vjj = data[j][j]; // check vjj
+        // non-degenerate row, find solution
+        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');
-        } // calculate xj
-
+        }
 
         xj = divideScalar(bj, vjj); // loop rows
 
         for (var i = j + 1; i < rows; i++) {
-          // update copy of b
-          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, data[i][j]))];
+          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
         }
       } else {
-        // zero @ j
+        // degenerate row, we can choose any value
         xj = 0;
-      } // update x
-
+      }
 
       x[j] = [xj];
-    } // return vector
-
+    }
 
     return new DenseMatrix({
       data: x,
@@ -111,72 +97,59 @@ export var createLsolve = /* #__PURE__ */factory(name, dependencies, function (_
 
   function _sparseForwardSubstitution(m, b) {
     // validate matrix and vector, return copy of column vector b
-    b = solveValidation(m, b, true); // column vector data
-
-    var bdata = b._data; // rows & columns
-
+    b = solveValidation(m, b, true);
+    var bdata = b._data;
     var rows = m._size[0];
-    var columns = m._size[1]; // matrix arrays
-
+    var columns = m._size[1];
     var values = m._values;
     var index = m._index;
-    var ptr = m._ptr; // vars
+    var ptr = m._ptr; // result
 
-    var i, k; // result
-
-    var x = []; // forward solve m * x = b, loop columns
+    var x = []; // loop columns
 
     for (var j = 0; j < columns; j++) {
-      // b[j]
-      var bj = bdata[j][0] || 0; // forward substitution (outer product) avoids inner looping when bj === 0
+      var bj = bdata[j][0] || 0;
 
       if (!equalScalar(bj, 0)) {
-        // value @ [j, j]
-        var vjj = 0; // lower triangular matrix values & index (column j)
+        // non-degenerate row, find solution
+        var vjj = 0; // matrix values & indices (column j)
 
-        var jvalues = [];
-        var jindex = []; // last index in column
+        var jValues = [];
+        var jIndices = []; // first and last index in the column
 
-        var l = ptr[j + 1]; // values in column, find value @ [j, j]
+        var firstIndex = ptr[j];
+        var lastIndex = ptr[j + 1]; // values in column, find value at [j, j]
 
-        for (k = ptr[j]; k < l; k++) {
-          // row
-          i = index[k]; // check row (rows are not sorted!)
+        for (var k = firstIndex; k < lastIndex; k++) {
+          var i = index[k]; // check row (rows are not sorted!)
 
           if (i === j) {
-            // update vjj
             vjj = values[k];
           } else if (i > j) {
             // store lower triangular
-            jvalues.push(values[k]);
-            jindex.push(i);
+            jValues.push(values[k]);
+            jIndices.push(i);
           }
-        } // at this point we must have a value @ [j, j]
+        } // at this point we must have a value in vjj
 
 
         if (equalScalar(vjj, 0)) {
-          // system cannot be solved, there is no value @ [j, j]
           throw new Error('Linear system cannot be solved since matrix is singular');
-        } // calculate xj
-
-
-        var xj = divideScalar(bj, vjj); // loop lower triangular
-
-        for (k = 0, l = jindex.length; k < l; k++) {
-          // row
-          i = jindex[k]; // update copy of b
+        }
 
-          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, jvalues[k]))];
-        } // update x
+        var xj = divideScalar(bj, vjj);
 
+        for (var _k = 0, l = jIndices.length; _k < l; _k++) {
+          var _i = jIndices[_k];
+          bdata[_i] = [subtract(bdata[_i][0] || 0, multiplyScalar(xj, jValues[_k]))];
+        }
 
         x[j] = [xj];
       } else {
-        // update x
+        // degenerate row, we can choose any value
         x[j] = [0];
       }
-    } // return vector
-
+    }
 
     return new DenseMatrix({
       data: x,

package/es/function/algebra/solver/lsolveAll.js

@@ -0,0 +1,213 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { factory } from '../../../utils/factory';
+import { createSolveValidation } from './utils/solveValidation';
+var name = 'lsolveAll';
+var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
+export var createLsolveAll = /* #__PURE__ */factory(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      matrix = _ref.matrix,
+      divideScalar = _ref.divideScalar,
+      multiplyScalar = _ref.multiplyScalar,
+      subtract = _ref.subtract,
+      equalScalar = _ref.equalScalar,
+      DenseMatrix = _ref.DenseMatrix;
+  var solveValidation = createSolveValidation({
+    DenseMatrix: DenseMatrix
+  });
+  /**
+   * Finds all solutions of a linear equation system by forwards substitution. Matrix must be a lower triangular matrix.
+   *
+   * `L * x = b`
+   *
+   * Syntax:
+   *
+   *    math.lsolve(L, b)
+   *
+   * Examples:
+   *
+   *    const a = [[-2, 3], [2, 1]]
+   *    const b = [11, 9]
+   *    const x = lsolve(a, b)  // [ [[-5.5], [20]] ]
+   *
+   * See also:
+   *
+   *    lsolve, lup, slu, usolve, lusolve
+   *
+   * @param {Matrix, Array} L       A N x N matrix or array (L)
+   * @param {Matrix, Array} b       A column vector with the b values
+   *
+   * @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 _sparseForwardSubstitution(m, b);
+    },
+    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(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();
+      });
+    }
+  });
+
+  function _denseForwardSubstitution(m, b_) {
+    // the algorithm is derived from
+    // https://www.overleaf.com/project/5e6c87c554a3190001a3fc93
+    // 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]; // loop columns
+
+    for (var i = 0; i < columns; i++) {
+      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]);
+
+          for (var j = i + 1; j < columns; j++) {
+            // b[j] -= b[i] * M[j,i]
+            b[j] = subtract(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 [];
+          } else {
+            // This RHS is invalid but other solutions may still exist
+            B.splice(k, 1);
+            k -= 1;
+            L -= 1;
+          }
+        } else if (k === 0) {
+          // singular row, RHS is zero
+          var bNew = _toConsumableArray(b);
+
+          bNew[i] = 1;
+
+          for (var _j = i + 1; _j < columns; _j++) {
+            bNew[_j] = subtract(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]
+      });
+    });
+  }
+
+  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; // loop columns
+
+    for (var i = 0; i < columns; i++) {
+      var L = B.length; // loop right-hand sides
+
+      for (var k = 0; k < L; k++) {
+        var b = B[k]; // values & indices (column i)
+
+        var iValues = [];
+        var iIndices = []; // first & last indeces in column
+
+        var firstIndex = ptr[i];
+        var lastIndex = ptr[i + 1]; // find the value at [i, i]
+
+        var Mii = 0;
+
+        for (var j = firstIndex; j < lastIndex; j++) {
+          var J = index[j]; // check row
+
+          if (J === i) {
+            Mii = values[j];
+          } else if (J > i) {
+            // store lower triangular
+            iValues.push(values[j]);
+            iIndices.push(J);
+          }
+        }
+
+        if (!equalScalar(Mii, 0)) {
+          // 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] = subtract(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 [];
+          } else {
+            // This RHS is invalid but other solutions may still exist
+            B.splice(k, 1);
+            k -= 1;
+            L -= 1;
+          }
+        } else if (k === 0) {
+          // singular row, RHS is zero
+          var bNew = _toConsumableArray(b);
+
+          bNew[i] = 1;
+
+          for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {
+            var _J2 = iIndices[_j3];
+            bNew[_J2] = subtract(bNew[_J2], iValues[_j3]);
+          }
+
+          B.push(bNew);
+        }
+      }
+    }
+
+    return B.map(function (x) {
+      return new DenseMatrix({
+        data: x.map(function (e) {
+          return [e];
+        }),
+        size: [rows, 1]
+      });
+    });
+  }
+});