mathjs 7.3.0 → 7.6.0

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/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
    *

package/src/function/matrix/rotate.js

@@ -0,0 +1,79 @@
+import { factory } from '../../utils/factory'
+import { arraySize } from '../../utils/array'
+
+const name = 'rotate'
+const dependencies = [
+  'typed',
+  'multiply',
+  'rotationMatrix'
+]
+
+export const createRotate = /* #__PURE__ */ factory(name, dependencies, (
+  {
+    typed, multiply, rotationMatrix
+  }) => {
+  /**
+     * Rotate a vector of size 1x2 counter-clockwise by a given angle
+     * Rotate a vector of size 1x3 counter-clockwise by a given angle around the given axis
+     *
+     * Syntax:
+     *
+     *    math.rotate(w, theta)
+     *    math.rotate(w, theta, v)
+     *
+     * Examples:
+     *
+     *    math.rotate([11, 12], math.pi / 2)                           // returns matrix([-12, 11])
+     *    math.rotate(matrix([11, 12]), math.pi / 2)                   // returns matrix([-12, 11])
+     *
+     *    math.rotate([1, 0, 0], unit('90deg'), [0, 0, 1])             // returns matrix([0, 1, 0])
+     *    math.rotate(matrix([1, 0, 0]), unit('90deg'), [0, 0, 1])     // returns matrix([0, 1, 0])
+     *
+     *    math.rotate([1, 0], math.complex(1 + i))                     // returns matrix([cos(1 + i) - sin(1 + i), sin(1 + i) + cos(1 + i)])
+     *
+     * See also:
+     *
+     *    matrix, rotationMatrix
+     *
+     * @param {Array | Matrix} w                             Vector to rotate
+     * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+     * @param {Array | Matrix} [v]                           Rotation axis
+     * @return {Array | Matrix}                              Multiplication of the rotation matrix and w
+     */
+  return typed(name, {
+    'Array , number | BigNumber | Complex | Unit': function (w, theta) {
+      _validateSize(w, 2)
+      const matrixRes = multiply(rotationMatrix(theta), w)
+      return matrixRes.toArray()
+    },
+
+    'Matrix , number | BigNumber | Complex | Unit': function (w, theta) {
+      _validateSize(w, 2)
+      return multiply(rotationMatrix(theta), w)
+    },
+
+    'Array, number | BigNumber | Complex | Unit, Array | Matrix': function (w, theta, v) {
+      _validateSize(w, 3)
+      const matrixRes = multiply(rotationMatrix(theta, v), w)
+      return matrixRes
+    },
+
+    'Matrix, number | BigNumber | Complex | Unit, Array | Matrix': function (w, theta, v) {
+      _validateSize(w, 3)
+      return multiply(rotationMatrix(theta, v), w)
+    }
+  })
+
+  function _validateSize (v, expectedSize) {
+    const actualSize = Array.isArray(v) ? arraySize(v) : v.size()
+    if (actualSize.length > 2) {
+      throw new RangeError(`Vector must be of dimensions 1x${expectedSize}`)
+    }
+    if (actualSize.length === 2 && actualSize[1] !== 1) {
+      throw new RangeError(`Vector must be of dimensions 1x${expectedSize}`)
+    }
+    if (actualSize[0] !== expectedSize) {
+      throw new RangeError(`Vector must be of dimensions 1x${expectedSize}`)
+    }
+  }
+})

package/src/function/matrix/rotationMatrix.js

@@ -0,0 +1,186 @@
+import { isBigNumber } from '../../utils/is'
+import { factory } from '../../utils/factory'
+
+const name = 'rotationMatrix'
+const dependencies = [
+  'typed',
+  'config',
+  'multiplyScalar',
+  'addScalar',
+  'unaryMinus',
+  'norm',
+  'matrix',
+  'BigNumber',
+  'DenseMatrix',
+  'SparseMatrix',
+  'cos',
+  'sin'
+]
+
+export const createRotationMatrix = /* #__PURE__ */ factory(name, dependencies, (
+  {
+    typed, config, multiplyScalar,
+    addScalar, unaryMinus, norm, BigNumber,
+    matrix, DenseMatrix, SparseMatrix, cos, sin
+  }) => {
+  /**
+   * Create a 2-dimensional counter-clockwise rotation matrix (2x2) for a given angle (expressed in radians).
+   * Create a 2-dimensional counter-clockwise rotation matrix (3x3) by a given angle (expressed in radians) around a given axis (1x3).
+   *
+   * Syntax:
+   *
+   *    math.rotationMatrix(theta)
+   *    math.rotationMatrix(theta, format)
+   *    math.rotationMatrix(theta, [v])
+   *    math.rotationMatrix(theta, [v], format)
+   *
+   * Examples:
+   *
+   *    math.rotationMatrix(math.pi / 2)                      // returns [[0, -1], [1, 0]]
+   *    math.rotationMatrix(math.bignumber(1))                // returns [[bignumber(cos(1)), bignumber(-sin(1))], [bignumber(sin(1)), bignumber(cos(1))]]
+   *    math.rotationMatrix(math.complex(1 + i))              // returns [[cos(1 + i), -sin(1 + i)], [sin(1 + i), cos(1 + i)]]
+   *    math.rotationMatrix(math.unit('1rad'))                // returns [[cos(1), -sin(1)], [sin(1), cos(1)]]
+   *
+   *    math.rotationMatrix(math.pi / 2, [0, 1, 0])           // returns [[0, 0, 1], [0, 1, 0], [-1, 0, 0]]
+   *    math.rotationMatrix(math.pi / 2, matrix([0, 1, 0]))   // returns matrix([[0, 0, 1], [0, 1, 0], [-1, 0, 0]])
+   *
+   *
+   * See also:
+   *
+   *    matrix, cos, sin
+   *
+   *
+   * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+   * @param {Array | Matrix} [v]                           Rotation axis
+   * @param {string} [format]                              Result Matrix storage format
+   * @return {Array | Matrix}                              Rotation matrix
+   */
+
+  return typed(name, {
+    '': function () {
+      return (config.matrix === 'Matrix') ? matrix([]) : []
+    },
+
+    string: function (format) {
+      return matrix(format)
+    },
+
+    'number | BigNumber | Complex | Unit': function (theta) {
+      return _rotationMatrix2x2(theta, config.matrix === 'Matrix' ? 'dense' : undefined)
+    },
+
+    'number | BigNumber | Complex | Unit, string': function (theta, format) {
+      return _rotationMatrix2x2(theta, format)
+    },
+
+    'number | BigNumber | Complex | Unit, Array': function (theta, v) {
+      const matrixV = matrix(v)
+      _validateVector(matrixV)
+      return _rotationMatrix3x3(theta, matrixV, undefined)
+    },
+
+    'number | BigNumber | Complex | Unit, Matrix': function (theta, v) {
+      _validateVector(v)
+      const storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined)
+      return _rotationMatrix3x3(theta, v, storageType)
+    },
+
+    'number | BigNumber | Complex | Unit, Array, string': function (theta, v, format) {
+      const matrixV = matrix(v)
+      _validateVector(matrixV)
+      return _rotationMatrix3x3(theta, matrixV, format)
+    },
+
+    'number | BigNumber | Complex | Unit, Matrix, string': function (theta, v, format) {
+      _validateVector(v)
+      return _rotationMatrix3x3(theta, v, format)
+    }
+
+  })
+
+  /**
+   * Returns 2x2 matrix of 2D rotation of angle theta
+   *
+   * @param {number | BigNumber | Complex | Unit} theta  The rotation angle
+   * @param {string} format                              The result Matrix storage format
+   * @returns {Matrix}
+   * @private
+   */
+  function _rotationMatrix2x2 (theta, format) {
+    const Big = isBigNumber(theta)
+
+    const minusOne = Big ? new BigNumber(-1) : -1
+    const cosTheta = cos(theta)
+    const sinTheta = sin(theta)
+    const data = [[cosTheta, multiplyScalar(minusOne, sinTheta)], [sinTheta, cosTheta]]
+
+    return _convertToFormat(data, format)
+  }
+
+  function _validateVector (v) {
+    const size = v.size()
+    if (size.length < 1 || size[0] !== 3) {
+      throw new RangeError('Vector must be of dimensions 1x3')
+    }
+  }
+
+  function _mul (array) {
+    return array.reduce((p, curr) => multiplyScalar(p, curr))
+  }
+
+  function _convertToFormat (data, format) {
+    if (format) {
+      if (format === 'sparse') {
+        return new SparseMatrix(data)
+      }
+      if (format === 'dense') {
+        return new DenseMatrix(data)
+      }
+      throw new TypeError(`Unknown matrix type "${format}"`)
+    }
+    return data
+  }
+
+  /**
+   * Returns a 3x3 matrix of rotation of angle theta around vector v
+   *
+   * @param {number | BigNumber | Complex | Unit} theta The rotation angle
+   * @param {Matrix} v                                  The rotation axis vector
+   * @param {string} format                             The storage format of the resulting matrix
+   * @returns {Matrix}
+   * @private
+   */
+  function _rotationMatrix3x3 (theta, v, format) {
+    const normV = norm(v)
+    if (normV === 0) {
+      throw new RangeError('Rotation around zero vector')
+    }
+
+    const Big = isBigNumber(theta) ? BigNumber : null
+
+    const one = Big ? new Big(1) : 1
+    const minusOne = Big ? new Big(-1) : -1
+    const vx = Big ? new Big(v.get([0]) / normV) : v.get([0]) / normV
+    const vy = Big ? new Big(v.get([1]) / normV) : v.get([1]) / normV
+    const vz = Big ? new Big(v.get([2]) / normV) : v.get([2]) / normV
+    const c = cos(theta)
+    const oneMinusC = addScalar(one, unaryMinus(c))
+    const s = sin(theta)
+
+    const r11 = addScalar(c, _mul([vx, vx, oneMinusC]))
+    const r12 = addScalar(_mul([vx, vy, oneMinusC]), _mul([minusOne, vz, s]))
+    const r13 = addScalar(_mul([vx, vz, oneMinusC]), _mul([vy, s]))
+
+    const r21 = addScalar(_mul([vx, vy, oneMinusC]), _mul([vz, s]))
+    const r22 = addScalar(c, _mul([vy, vy, oneMinusC]))
+    const r23 = addScalar(_mul([vy, vz, oneMinusC]), _mul([minusOne, vx, s]))
+
+    const r31 = addScalar(_mul([vx, vz, oneMinusC]), _mul([minusOne, vy, s]))
+    const r32 = addScalar(_mul([vy, vz, oneMinusC]), _mul([vx, s]))
+    const r33 = addScalar(c, _mul([vz, vz, oneMinusC]))
+
+    const data = [[r11, r12, r13], [r21, r22, r23], [r31, r32, r33]]
+
+    return _convertToFormat(data, format)
+  }
+})

package/src/function/matrix/sqrtm.js

@@ -87,6 +87,10 @@ export const createSqrtm = /* #__PURE__ */ factory(name, dependencies, ({ typed,
               '(size: ' + format(size) + ')')
           }
         }
+        default:
+          // Multi dimensional array
+          throw new RangeError('Matrix must be at most two dimensional ' +
+          '(size: ' + format(size) + ')')
       }
     }
   })

package/src/function/probability/pickRandom.js

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory'
 import { isNumber } from '../../utils/is'
-import { arraySize } from '../../utils/array'
 import { createRng } from './util/seededRNG'
+import { flatten } from '../../utils/array'
 
 const name = 'pickRandom'
 const dependencies = ['typed', 'config', '?on']
@@ -76,15 +76,11 @@ export const createPickRandom = /* #__PURE__ */ factory(name, dependencies, ({ t
       number = 1
     }
 
-    possibles = possibles.valueOf() // get Array
+    possibles = flatten(possibles.valueOf()).valueOf() // get Array
     if (weights) {
       weights = weights.valueOf() // get Array
     }
 
-    if (arraySize(possibles).length > 1) {
-      throw new Error('Only one dimensional vectors supported')
-    }
-
     let totalWeights = 0
 
     if (typeof weights !== 'undefined') {

package/src/function/special/erf.js

@@ -1,3 +1,5 @@
+/* eslint-disable no-loss-of-precision */
+
 import { deepMap } from '../../utils/collection'
 import { sign } from '../../utils/number'
 import { factory } from '../../utils/factory'

package/src/plain/number/constants.js

@@ -2,4 +2,4 @@
 export const pi = Math.PI
 export const tau = 2 * Math.PI
 export const e = Math.E
-export const phi = 1.61803398874989484820458683436563811772030917980576286213545
+export const phi = 1.6180339887498948 // eslint-disable-line no-loss-of-precision