mathjs 7.2.0 → 7.5.1

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

@@ -1,4 +1,4 @@
-import { isArray, isDenseMatrix, isMatrix } from '../../../../utils/is'
+import { isArray, isMatrix, isDenseMatrix, isSparseMatrix } from '../../../../utils/is'
 import { arraySize } from '../../../../utils/array'
 import { format } from '../../../../utils/string'
 
@@ -13,131 +13,123 @@ export function createSolveValidation ({ DenseMatrix }) {
    * @return {DenseMatrix}        Dense column vector b
    */
   return function solveValidation (m, b, copy) {
-    // matrix size
-    const size = m.size()
-    // validate matrix dimensions
-    if (size.length !== 2) { throw new RangeError('Matrix must be two dimensional (size: ' + format(size) + ')') }
-    // rows & columns
-    const rows = size[0]
-    const columns = size[1]
-    // validate rows & columns
-    if (rows !== columns) { throw new RangeError('Matrix must be square (size: ' + format(size) + ')') }
-    // vars
-    let data, i, bdata
-    // check b is matrix
+    const mSize = m.size()
+
+    if (mSize.length !== 2) {
+      throw new RangeError('Matrix must be two dimensional (size: ' + format(mSize) + ')')
+    }
+
+    const rows = mSize[0]
+    const columns = mSize[1]
+
+    if (rows !== columns) {
+      throw new RangeError('Matrix must be square (size: ' + format(mSize) + ')')
+    }
+
+    let data = []
+
     if (isMatrix(b)) {
-      // matrix size
-      const msize = b.size()
-      // vector
-      if (msize.length === 1) {
-        // check vector length
-        if (msize[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
+      const bSize = b.size()
+      const 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 (let 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
-      if (msize.length === 2) {
-        // array must be a column vector
-        if (msize[0] !== rows || msize[1] !== 1) { throw new RangeError('Dimension mismatch. Matrix columns must match vector length.') }
-        // check matrix type
+
+      // 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)) {
-          // 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
+
+            for (let i = 0; i < rows; i++) {
               data[i] = [bdata[i][0]]
             }
-            // return Dense Matrix
+
             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
-        const values = b._values
-        const index = b._index
-        const ptr = b._ptr
-        // loop values in column 0
-        for (let k1 = ptr[1], k = ptr[0]; k < k1; k++) {
-          // row
-          i = index[k]
-          // add to data
-          data[i][0] = values[k]
+
+        if (isSparseMatrix(b)) {
+          for (let i = 0; i < rows; i++) { data[i] = [0] }
+
+          const values = b._values
+          const index = b._index
+          const ptr = b._ptr
+
+          for (let k1 = ptr[1], k = ptr[0]; k < k1; k++) {
+            const i = index[k]
+            data[i][0] = values[k]
+          }
+
+          return new DenseMatrix({
+            data: data,
+            size: [rows, 1],
+            datatype: b._datatype
+          })
         }
-        // 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.')
+
+      throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.')
     }
-    // check b is array
+
     if (isArray(b)) {
-      // size
-      const asize = arraySize(b)
-      // check matrix dimensions, vector
-      if (asize.length === 1) {
-        // check vector length
-        if (asize[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
+      const bsize = arraySize(b)
+
+      if (bsize.length === 1) {
+        if (bsize[0] !== rows) {
+          throw new RangeError('Dimension mismatch. Matrix columns must match vector length.')
+        }
+
+        for (let i = 0; i < rows; i++) {
           data[i] = [b[i]]
         }
-        // return Dense Matrix
+
         return new DenseMatrix({
           data: data,
           size: [rows, 1]
         })
       }
-      if (asize.length === 2) {
-        // array must be a column vector
-        if (asize[0] !== rows || asize[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
+
+      if (bsize.length === 2) {
+        if (bsize[0] !== rows || bsize[1] !== 1) {
+          throw new RangeError('Dimension mismatch. Matrix columns must match vector length.')
+        }
+
+        for (let i = 0; i < rows; i++) {
           data[i] = [b[i][0]]
         }
-        // return Dense Matrix
+
         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/src/function/arithmetic/ceil.js

@@ -1,13 +1,19 @@
+import { Decimal } from 'decimal.js'
 import { factory } from '../../utils/factory'
 import { deepMap } from '../../utils/collection'
 import { nearlyEqual } from '../../utils/number'
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual'
 import { ceilNumber } from '../../plain/number'
+import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11'
+import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14'
 
 const name = 'ceil'
-const dependencies = ['typed', 'config', 'round']
+const dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar']
+
+export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, round, matrix, equalScalar }) => {
+  const algorithm11 = createAlgorithm11({ typed, equalScalar })
+  const algorithm14 = createAlgorithm14({ typed })
 
-export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, round }) => {
   /**
    * Round a value towards plus infinity
    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
@@ -16,6 +22,7 @@ export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed,
    * Syntax:
    *
    *    math.ceil(x)
+   *    math.ceil(x, n)
    *
    * Examples:
    *
@@ -24,16 +31,24 @@ export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed,
    *    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', {
@@ -45,10 +60,25 @@ export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed,
       }
     },
 
+    'number, number': function (x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n)
+      } else {
+        let [number, exponent] = `${x}e`.split('e')
+        const result = Math.ceil(Number(`${number}e${Number(exponent) + n}`));
+        [number, exponent] = `${result}e`.split('e')
+        return Number(`${number}e${Number(exponent) - n}`)
+      }
+    },
+
     Complex: function (x) {
       return x.ceil()
     },
 
+    'Complex, number': function (x, n) {
+      return x.ceil(n)
+    },
+
     BigNumber: function (x) {
       if (bigNearlyEqual(x, round(x), config.epsilon)) {
         return round(x)
@@ -57,13 +87,43 @@ export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed,
       }
     },
 
+    'BigNumber, BigNumber': function (x, n) {
+      if (bigNearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n)
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_CEIL)
+      }
+    },
+
     Fraction: function (x) {
       return x.ceil()
     },
 
+    'Fraction, number': function (x, n) {
+      return x.ceil(n)
+    },
+
     'Array | Matrix': function (x) {
       // deep map collection, skip zeros since ceil(0) = 0
       return deepMap(x, this, true)
+    },
+
+    'Array | Matrix, number': function (x, n) {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return deepMap(x, i => this(i, n), true)
+    },
+
+    'SparseMatrix, number | BigNumber': function (x, y) {
+      return algorithm11(x, y, this, false)
+    },
+
+    'DenseMatrix, number | BigNumber': function (x, y) {
+      return algorithm14(x, y, this, false)
+    },
+
+    'number | Complex | BigNumber, Array': function (x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf()
     }
   })
 })

package/src/function/arithmetic/fix.js

@@ -1,10 +1,12 @@
 import { factory } from '../../utils/factory'
 import { deepMap } from '../../utils/collection'
+import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14'
 
 const name = 'fix'
-const dependencies = ['typed', 'Complex', 'ceil', 'floor']
+const dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor']
 
-export const createFix = /* #__PURE__ */ factory(name, dependencies, ({ typed, Complex, ceil, floor }) => {
+export const createFix = /* #__PURE__ */ factory(name, dependencies, ({ typed, Complex, matrix, ceil, floor }) => {
+  const algorithm14 = createAlgorithm14({ typed })
   /**
    * Round a value towards zero.
    * For matrices, the function is evaluated element wise.
@@ -20,23 +22,35 @@ export const createFix = /* #__PURE__ */ factory(name, dependencies, ({ typed, C
    *    math.fix(-4.2)               // returns number -4
    *    math.fix(-4.7)               // returns number -4
    *
-   *    const c = math.complex(3.2, -2.7)
+   *    math.fix(3.12, 1)                // returns number 3.1
+   *    math.fix(3.18, 1)                // returns number 3.1
+   *    math.fix(-4.12, 1)               // returns number -4.1
+   *    math.fix(-4.17, 1)               // returns number -4.1
+   *
+   *    const c = math.complex(3.22, -2.78)
    *    math.fix(c)                  // returns Complex 3 - 2i
+   *    math.fix(c, 1)               // returns Complex 3.2 - 2.7i
    *
-   *    math.fix([3.2, 3.8, -4.7])   // returns Array [3, 3, -4]
+   *    math.fix([3.2, 3.8, -4.7])      // returns Array [3, 3, -4]
+   *    math.fix([3.2, 3.8, -4.7], 1)   // returns Array [3.2, 3.8, -4.7]
    *
    * See also:
    *
    *    ceil, floor, round
    *
-   * @param {number | BigNumber | Fraction | Complex | Array | Matrix} x Number to be rounded
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix}            Rounded value
+   * @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('fix', {
     number: function (x) {
       return (x > 0) ? floor(x) : ceil(x)
     },
 
+    'number, number | BigNumber': function (x, n) {
+      return (x > 0) ? floor(x, n) : ceil(x, n)
+    },
+
     Complex: function (x) {
       return new Complex(
         (x.re > 0) ? Math.floor(x.re) : Math.ceil(x.re),
@@ -44,17 +58,42 @@ export const createFix = /* #__PURE__ */ factory(name, dependencies, ({ typed, C
       )
     },
 
+    'Complex, number | BigNumber': function (x, n) {
+      return new Complex(
+        (x.re > 0) ? floor(x.re, n) : ceil(x.re, n),
+        (x.im > 0) ? floor(x.im, n) : ceil(x.im, n)
+      )
+    },
+
     BigNumber: function (x) {
       return x.isNegative() ? ceil(x) : floor(x)
     },
 
+    'BigNumber, number | BigNumber': function (x, n) {
+      return x.isNegative() ? ceil(x, n) : floor(x, n)
+    },
+
     Fraction: function (x) {
       return x.s < 0 ? x.ceil() : x.floor()
     },
 
+    'Fraction, number | BigNumber': function (x, n) {
+      return x.s < 0 ? x.ceil(n) : x.floor(n)
+    },
+
     'Array | Matrix': function (x) {
       // deep map collection, skip zeros since fix(0) = 0
       return deepMap(x, this, true)
+    },
+
+    'Array | Matrix, number | BigNumber': function (x, n) {
+      // deep map collection, skip zeros since fix(0) = 0
+      return deepMap(x, i => this(i, n), true)
+    },
+
+    'number | Complex | BigNumber, Array': function (x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf()
     }
   })
 })

package/src/function/arithmetic/floor.js

@@ -1,12 +1,18 @@
+import { Decimal } from 'decimal.js'
 import { factory } from '../../utils/factory'
 import { deepMap } from '../../utils/collection'
 import { nearlyEqual } from '../../utils/number'
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual'
+import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11'
+import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14'
 
 const name = 'floor'
-const dependencies = ['typed', 'config', 'round']
+const dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar']
+
+export const createFloor = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, round, matrix, equalScalar }) => {
+  const algorithm11 = createAlgorithm11({ typed, equalScalar })
+  const algorithm14 = createAlgorithm14({ typed })
 
-export const createFloor = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, round }) => {
   /**
    * Round a value towards minus infinity.
    * For matrices, the function is evaluated element wise.
@@ -14,6 +20,7 @@ export const createFloor = /* #__PURE__ */ factory(name, dependencies, ({ typed,
    * Syntax:
    *
    *    math.floor(x)
+   *    math.floor(x, n)
    *
    * Examples:
    *
@@ -22,16 +29,24 @@ export const createFloor = /* #__PURE__ */ factory(name, dependencies, ({ typed,
    *    math.floor(-4.2)             // returns number -5
    *    math.floor(-4.7)             // returns number -5
    *
-   *    const c = math.complex(3.2, -2.7)
-   *    math.floor(c)                // returns Complex 3 - 3i
+   *    math.floor(3.212, 2)          // returns number 3.21
+   *    math.floor(3.288, 2)          // returns number 3.28
+   *    math.floor(-4.212, 2)         // returns number -4.22
+   *    math.floor(-4.782, 2)         // returns number -4.79
+   *
+   *    const c = math.complex(3.24, -2.71)
+   *    math.floor(c)                 // returns Complex 3 - 3i
+   *    math.floor(c, 1)              // returns Complex 3.2 - 2.8i
    *
-   *    math.floor([3.2, 3.8, -4.7]) // returns Array [3, 3, -5]
+   *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
+   *    math.floor([3.21, 3.82, -4.71], 1)  // returns Array [3.2, 3.8, -4.8]
    *
    * See also:
    *
    *    ceil, 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('floor', {
@@ -43,10 +58,25 @@ export const createFloor = /* #__PURE__ */ factory(name, dependencies, ({ typed,
       }
     },
 
+    'number, number': function (x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n)
+      } else {
+        let [number, exponent] = `${x}e`.split('e')
+        const result = Math.floor(Number(`${number}e${Number(exponent) + n}`));
+        [number, exponent] = `${result}e`.split('e')
+        return Number(`${number}e${Number(exponent) - n}`)
+      }
+    },
+
     Complex: function (x) {
       return x.floor()
     },
 
+    'Complex, number': function (x, n) {
+      return x.floor(n)
+    },
+
     BigNumber: function (x) {
       if (bigNearlyEqual(x, round(x), config.epsilon)) {
         return round(x)
@@ -55,13 +85,43 @@ export const createFloor = /* #__PURE__ */ factory(name, dependencies, ({ typed,
       }
     },
 
+    'BigNumber, BigNumber': function (x, n) {
+      if (bigNearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n)
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_FLOOR)
+      }
+    },
+
     Fraction: function (x) {
       return x.floor()
     },
 
+    'Fraction, number': function (x, n) {
+      return x.floor(n)
+    },
+
     'Array | Matrix': function (x) {
       // deep map collection, skip zeros since floor(0) = 0
       return deepMap(x, this, true)
+    },
+
+    'Array | Matrix, number': function (x, n) {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return deepMap(x, i => this(i, n), true)
+    },
+
+    'SparseMatrix, number | BigNumber': function (x, y) {
+      return algorithm11(x, y, this, false)
+    },
+
+    'DenseMatrix, number | BigNumber': function (x, y) {
+      return algorithm14(x, y, this, false)
+    },
+
+    'number | Complex | BigNumber, Array': function (x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf()
     }
   })
 })

package/src/function/arithmetic/mod.js

@@ -65,11 +65,18 @@ export const createMod = /* #__PURE__ */ factory(name, dependencies, ({ typed, m
     'number, number': modNumber,
 
     'BigNumber, BigNumber': function (x, y) {
+      if (y.isNeg()) {
+        throw new Error('Cannot calculate mod for a negative divisor')
+      }
       return y.isZero() ? x : x.mod(y)
     },
 
     'Fraction, Fraction': function (x, y) {
-      return x.mod(y)
+      if (y.compare(0) < 0) {
+        throw new Error('Cannot calculate mod for a negative divisor')
+      }
+      // Workaround suggested in Fraction.js library to calculate correct modulo for negative dividend
+      return x.compare(0) >= 0 ? x.mod(y) : x.mod(y).add(y).mod(y)
     },
 
     'SparseMatrix, SparseMatrix': function (x, y) {

package/src/function/arithmetic/round.js

@@ -34,10 +34,14 @@ export const createRound = /* #__PURE__ */ factory(name, dependencies, ({ typed,
    *
    * Examples:
    *
-   *    math.round(3.2)              // returns number 3
-   *    math.round(3.8)              // returns number 4
+   *    math.round(3.22)             // returns number 3
+   *    math.round(3.82)             // returns number 4
    *    math.round(-4.2)             // returns number -4
    *    math.round(-4.7)             // returns number -5
+   *    math.round(3.22, 1)          // returns number 3.2
+   *    math.round(3.88, 1)          // returns number 3.8
+   *    math.round(-4.21, 1)         // returns number -4.2
+   *    math.round(-4.71, 1)         // returns number -4.7
    *    math.round(math.pi, 3)       // returns number 3.142
    *    math.round(123.45678, 2)     // returns number 123.46
    *