mathjs 7.2.0 → 7.5.1

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

@@ -0,0 +1,223 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUsolveAll = void 0;
+
+var _factory = require("../../../utils/factory");
+
+var _solveValidation = require("./utils/solveValidation");
+
+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; }
+
+var name = 'usolveAll';
+var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
+var createUsolveAll = /* #__PURE__ */(0, _factory.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 = (0, _solveValidation.createSolveValidation)({
+    DenseMatrix: DenseMatrix
+  });
+  /**
+   * Finds all solutions of a linear equation system by backward substitution. Matrix must be an upper triangular matrix.
+   *
+   * `U * x = b`
+   *
+   * Syntax:
+   *
+   *    math.usolve(U, b)
+   *
+   * Examples:
+   *
+   *    const a = [[-2, 3], [2, 1]]
+   *    const b = [11, 9]
+   *    const x = usolve(a, b)  // [ [[8], [9]] ]
+   *
+   * See also:
+   *
+   *    usolve, lup, slu, usolve, lusolve
+   *
+   * @param {Matrix, Array} U       A N x N matrix or array (U)
+   * @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 _sparseBackwardSubstitution(m, b);
+    },
+    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+      return _denseBackwardSubstitution(m, b);
+    },
+    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
+      var m = matrix(a);
+
+      var R = _denseBackwardSubstitution(m, b);
+
+      return R.map(function (r) {
+        return r.valueOf();
+      });
+    }
+  });
+
+  function _denseBackwardSubstitution(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 backwards
+
+    for (var i = columns - 1; i >= 0; 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 >= 0; 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 >= 0; _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 _sparseBackwardSubstitution(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 backwards
+
+    for (var i = columns - 1; i >= 0; 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 = lastIndex - 1; j >= firstIndex; j--) {
+          var J = index[j]; // check row
+
+          if (J === i) {
+            Mii = values[j];
+          } else if (J < i) {
+            // store upper triangular
+            iValues.push(values[j]);
+            iIndices.push(J);
+          }
+        }
+
+        if (!equalScalar(Mii, 0)) {
+          // non-singular row
+          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]));
+          }
+        } 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; // loop upper triangular
+
+          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]
+      });
+    });
+  }
+});
+exports.createUsolveAll = createUsolveAll;

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

@@ -24,135 +24,101 @@ function createSolveValidation(_ref) {
    * @return {DenseMatrix}        Dense column vector b
    */
   return function solveValidation(m, b, copy) {
-    // matrix size
-    var size = m.size(); // validate matrix dimensions
-
-    if (size.length !== 2) {
-      throw new RangeError('Matrix must be two dimensional (size: ' + (0, _string.format)(size) + ')');
-    } // rows & columns
+    var mSize = m.size();
 
+    if (mSize.length !== 2) {
+      throw new RangeError('Matrix must be two dimensional (size: ' + (0, _string.format)(mSize) + ')');
+    }
 
-    var rows = size[0];
-    var columns = size[1]; // validate rows & columns
+    var rows = mSize[0];
+    var columns = mSize[1];
 
     if (rows !== columns) {
-      throw new RangeError('Matrix must be square (size: ' + (0, _string.format)(size) + ')');
-    } // vars
-
+      throw new RangeError('Matrix must be square (size: ' + (0, _string.format)(mSize) + ')');
+    }
 
-    var data, i, bdata; // check b is matrix
+    var data = [];
 
     if ((0, _is.isMatrix)(b)) {
-      // matrix size
-      var msize = b.size(); // vector
+      var bSize = b.size();
+      var bdata = b._data; // 1-dim vector
 
-      if (msize.length === 1) {
-        // check vector length
-        if (msize[0] !== rows) {
+      if (bSize.length === 1) {
+        if (bSize[0] !== rows) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
-        } // create data array
-
+        }
 
-        data = []; // matrix data (DenseMatrix)
-
-        bdata = b._data; // loop b data
-
-        for (i = 0; i < rows; i++) {
-          // row array
+        for (var i = 0; i < rows; i++) {
           data[i] = [bdata[i]];
-        } // return Dense Matrix
-
+        }
 
         return new DenseMatrix({
           data: data,
           size: [rows, 1],
           datatype: b._datatype
         });
-      } // two dimensions
+      } // 2-dim column
 
 
-      if (msize.length === 2) {
-        // array must be a column vector
-        if (msize[0] !== rows || msize[1] !== 1) {
+      if (bSize.length === 2) {
+        if (bSize[0] !== rows || bSize[1] !== 1) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
-        } // check matrix type
-
+        }
 
         if ((0, _is.isDenseMatrix)(b)) {
-          // check a copy is needed
           if (copy) {
-            // create data array
-            data = []; // matrix data (DenseMatrix)
-
-            bdata = b._data; // loop b data
-
-            for (i = 0; i < rows; i++) {
-              // row array
-              data[i] = [bdata[i][0]];
-            } // return Dense Matrix
+            data = [];
 
+            for (var _i = 0; _i < rows; _i++) {
+              data[_i] = [bdata[_i][0]];
+            }
 
             return new DenseMatrix({
               data: data,
               size: [rows, 1],
               datatype: b._datatype
             });
-          } // b is already a column vector
-
+          }
 
           return b;
-        } // create data array
-
-
-        data = [];
-
-        for (i = 0; i < rows; i++) {
-          data[i] = [0];
-        } // sparse matrix arrays
-
-
-        var values = b._values;
-        var index = b._index;
-        var ptr = b._ptr; // loop values in column 0
-
-        for (var k1 = ptr[1], k = ptr[0]; k < k1; k++) {
-          // row
-          i = index[k]; // add to data
-
-          data[i][0] = values[k];
-        } // return Dense Matrix
-
-
-        return new DenseMatrix({
-          data: data,
-          size: [rows, 1],
-          datatype: b._datatype
-        });
-      } // throw error
-
-
-      throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
-    } // check b is array
+        }
+
+        if ((0, _is.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,
+            size: [rows, 1],
+            datatype: b._datatype
+          });
+        }
+      }
 
+      throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.');
+    }
 
     if ((0, _is.isArray)(b)) {
-      // size
-      var asize = (0, _array.arraySize)(b); // check matrix dimensions, vector
+      var bsize = (0, _array.arraySize)(b);
 
-      if (asize.length === 1) {
-        // check vector length
-        if (asize[0] !== rows) {
+      if (bsize.length === 1) {
+        if (bsize[0] !== rows) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
-        } // create data array
-
-
-        data = []; // loop b
-
-        for (i = 0; i < rows; i++) {
-          // row array
-          data[i] = [b[i]];
-        } // return Dense Matrix
+        }
 
+        for (var _i4 = 0; _i4 < rows; _i4++) {
+          data[_i4] = [b[_i4]];
+        }
 
         return new DenseMatrix({
           data: data,
@@ -160,29 +126,22 @@ function createSolveValidation(_ref) {
         });
       }
 
-      if (asize.length === 2) {
-        // array must be a column vector
-        if (asize[0] !== rows || asize[1] !== 1) {
+      if (bsize.length === 2) {
+        if (bsize[0] !== rows || bsize[1] !== 1) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
-        } // create data array
-
-
-        data = []; // loop b data
-
-        for (i = 0; i < rows; i++) {
-          // row array
-          data[i] = [b[i][0]];
-        } // return Dense Matrix
+        }
 
+        for (var _i5 = 0; _i5 < rows; _i5++) {
+          data[_i5] = [b[_i5][0]];
+        }
 
         return new DenseMatrix({
           data: data,
           size: [rows, 1]
         });
-      } // throw error
-
+      }
 
-      throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
+      throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.');
     }
   };
 }

package/lib/function/arithmetic/ceil.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createCeil = void 0;
 
+var _decimal = require("decimal.js");
+
 var _factory = require("../../utils/factory");
 
 var _collection = require("../../utils/collection");
@@ -15,13 +17,37 @@ var _nearlyEqual = require("../../utils/bignumber/nearlyEqual");
 
 var _number2 = require("../../plain/number");
 
+var _algorithm = require("../../type/matrix/utils/algorithm11");
+
+var _algorithm2 = require("../../type/matrix/utils/algorithm14");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 var name = 'ceil';
-var dependencies = ['typed', 'config', 'round'];
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
 var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
-      round = _ref.round;
-
+      round = _ref.round,
+      matrix = _ref.matrix,
+      equalScalar = _ref.equalScalar;
+  var algorithm11 = (0, _algorithm.createAlgorithm11)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var algorithm14 = (0, _algorithm2.createAlgorithm14)({
+    typed: typed
+  });
   /**
    * Round a value towards plus infinity
    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
@@ -30,6 +56,7 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    * Syntax:
    *
    *    math.ceil(x)
+   *    math.ceil(x, n)
    *
    * Examples:
    *
@@ -38,18 +65,27 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    *    math.ceil(-4.2)              // returns number -4
    *    math.ceil(-4.7)              // returns number -4
    *
-   *    const c = math.complex(3.2, -2.7)
+   *    math.ceil(3.212, 2)          // returns number 3.22
+   *    math.ceil(3.288, 2)          // returns number 3.29
+   *    math.ceil(-4.212, 2)         // returns number -4.21
+   *    math.ceil(-4.782, 2)         // returns number -4.78
+   *
+   *    const c = math.complex(3.24, -2.71)
    *    math.ceil(c)                 // returns Complex 4 - 2i
+   *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
    *
    *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
+   *    math.ceil([3.21, 3.82, -4.71], 1)  // returns Array [3.3, 3.9, -4.7]
    *
    * See also:
    *
    *    floor, fix, round
    *
    * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
+
   return typed('ceil', {
     number: function number(x) {
       if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
@@ -58,9 +94,32 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
         return (0, _number2.ceilNumber)(x);
       }
     },
+    'number, number': function numberNumber(x, n) {
+      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var _$split = "".concat(x, "e").split('e'),
+            _$split2 = _slicedToArray(_$split, 2),
+            number = _$split2[0],
+            exponent = _$split2[1];
+
+        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
+
+        var _$split3 = "".concat(result, "e").split('e');
+
+        var _$split4 = _slicedToArray(_$split3, 2);
+
+        number = _$split4[0];
+        exponent = _$split4[1];
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    },
     Complex: function Complex(x) {
       return x.ceil();
     },
+    'Complex, number': function ComplexNumber(x, n) {
+      return x.ceil(n);
+    },
     BigNumber: function BigNumber(x) {
       if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.epsilon)) {
         return round(x);
@@ -68,12 +127,40 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
         return x.ceil();
       }
     },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), _decimal.Decimal.ROUND_CEIL);
+      }
+    },
     Fraction: function Fraction(x) {
       return x.ceil();
     },
+    'Fraction, number': function FractionNumber(x, n) {
+      return x.ceil(n);
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since ceil(0) = 0
       return (0, _collection.deepMap)(x, this, true);
+    },
+    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+      var _this = this;
+
+      // deep map collection, skip zeros since ceil(0) = 0
+      return (0, _collection.deepMap)(x, function (i) {
+        return _this(i, n);
+      }, true);
+    },
+    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
+      return algorithm11(x, y, this, false);
+    },
+    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
+      return algorithm14(x, y, this, false);
+    },
+    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf();
     }
   });
 });