mathjs 7.2.0 → 7.5.1

package/src/function/matrix/rotationMatrix.js

@@ -0,0 +1,185 @@
+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(45))               // returns [[ bignumber(1 / sqrt(2)), - bignumber(1 / sqrt(2))], [ bignumber(1 / sqrt(2)),  bignumber(1 / sqrt(2))]]
+   *    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, config.matrix === 'Matrix' ? 'dense' : undefined)
+    },
+
+    'number | BigNumber | Complex | Unit, Matrix': function (theta, v) {
+      _validateVector(v)
+      return _rotationMatrix3x3(theta, v, config.matrix === 'Matrix' ? 'dense' : undefined)
+    },
+
+    '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) {
+      return _convertToFormat([], format)
+    }
+
+    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/statistics/variance.js

@@ -97,7 +97,7 @@ export const createVariance = /* #__PURE__ */ factory(name, dependencies, ({ typ
    * @private
    */
   function _var (array, normalization) {
-    let sum = 0
+    let sum
     let num = 0
 
     if (array.length === 0) {
@@ -107,7 +107,7 @@ export const createVariance = /* #__PURE__ */ factory(name, dependencies, ({ typ
     // calculate the mean and number of elements
     deepForEach(array, function (value) {
       try {
-        sum = add(sum, value)
+        sum = sum === undefined ? value : add(sum, value)
         num++
       } catch (err) {
         throw improveErrorMessage(err, 'variance', value)
@@ -118,10 +118,10 @@ export const createVariance = /* #__PURE__ */ factory(name, dependencies, ({ typ
     const mean = divide(sum, num)
 
     // calculate the variance
-    sum = 0
+    sum = undefined
     deepForEach(array, function (value) {
       const diff = subtract(value, mean)
-      sum = add(sum, multiply(diff, diff))
+      sum = sum === undefined ? multiply(diff, diff) : add(sum, multiply(diff, diff))
     })
 
     if (isNaN(sum)) {

package/src/function/string/baseUtils.js

@@ -0,0 +1,29 @@
+import { factory } from '../../utils/factory'
+import { isInteger } from '../../utils/number'
+
+function baseFormatter (base) {
+  const prefixes = { 2: '0b', 8: '0o', 16: '0x' }
+  const prefix = prefixes[base]
+  return function (n) {
+    if (n > 2 ** 31 - 1 || n < -(2 ** 31)) {
+      throw new Error('Value must be in range [-2^31, 2^31-1]')
+    }
+    if (!isInteger(n)) {
+      throw new Error('Value must be an integer')
+    }
+    if (n < 0) {
+      n = n + 2 ** 32
+    }
+    return `${prefix}${n.toString(base)}`
+  }
+}
+
+const dependencies = ['typed']
+
+export function createBaseFormatterFactory (name, base) {
+  return factory(name, dependencies, ({ typed }) => {
+    return typed(name, {
+      number: baseFormatter(base)
+    })
+  })
+}

package/src/function/string/bin.js

@@ -0,0 +1,23 @@
+import { createBaseFormatterFactory } from './baseUtils'
+
+/**
+ * Format a number as binary.
+ *
+ * Syntax:
+ *
+ *    math.bin(value)
+ *
+ * Examples:
+ *
+ *    //the following outputs "0b10"
+ *    math.bin(2)
+ *
+ * See also:
+ *
+ *    oct
+ *    hex
+ *
+ * @param {number} value    Value to be stringified
+ * @return {string}         The formatted value
+ */
+export const createBin = createBaseFormatterFactory('bin', 2)

package/src/function/string/hex.js

@@ -0,0 +1,23 @@
+import { createBaseFormatterFactory } from './baseUtils'
+
+/**
+ * Format a number as hexadecimal.
+ *
+ * Syntax:
+ *
+ *    math.hex(value)
+ *
+ * Examples:
+ *
+ *    //the following outputs "0xF0"
+ *    math.hex(240)
+ *
+ * See also:
+ *
+ *    oct
+ *    bin
+ *
+ * @param {number} value    Value to be stringified
+ * @return {string}         The formatted value
+ */
+export const createHex = createBaseFormatterFactory('hex', 16)

package/src/function/string/oct.js

@@ -0,0 +1,24 @@
+import { createBaseFormatterFactory } from './baseUtils'
+
+/**
+ * Format a number as octal.
+ *
+ * Syntax:
+ *
+ *    math.oct(value)
+ *
+ * Examples:
+ *
+ *    //the following outputs "0o70"
+ *    math.oct(56)
+ *
+ * See also:
+ *
+ *    bin
+ *    hex
+ *
+ * @param {number} value  Value to be stringified
+ * @return {string}       The formatted value
+ */
+
+export const createOct = createBaseFormatterFactory('oct', 8)

package/src/type/bignumber/BigNumber.js

@@ -5,7 +5,8 @@ const name = 'BigNumber'
 const dependencies = ['?on', 'config']
 
 export const createBigNumberClass = /* #__PURE__ */ factory(name, dependencies, ({ on, config }) => {
-  const BigNumber = Decimal.clone({ precision: config.precision })
+  const EUCLID = 9 // Use euclidian division for mod calculation
+  const BigNumber = Decimal.clone({ precision: config.precision, modulo: EUCLID })
 
   /**
    * Attach type information

package/src/type/number.js

@@ -41,10 +41,18 @@ export const createNumber = /* #__PURE__ */ factory(name, dependencies, ({ typed
 
     string: function (x) {
       if (x === 'NaN') return NaN
-      const num = Number(x)
+      let num = Number(x)
       if (isNaN(num)) {
         throw new SyntaxError('String "' + x + '" is no valid number')
       }
+      if (['0b', '0o', '0x'].includes(x.substring(0, 2))) {
+        if (num > 2 ** 32 - 1) {
+          throw new SyntaxError(`String "${x}" is out of range`)
+        }
+        if (num & 0x80000000) {
+          num = -1 * ~(num - 1)
+        }
+      }
       return num
     },
 

package/src/utils/object.js

@@ -86,7 +86,9 @@ export function deepExtend (a, b) {
   }
 
   for (const prop in b) {
-    if (hasOwnProperty(b, prop)) {
+    // We check against prop not being in Object.prototype or Function.prototype
+    // to prevent polluting for example Object.__proto__.
+    if (hasOwnProperty(b, prop) && !(prop in Object.prototype) && !(prop in Function.prototype)) {
       if (b[prop] && b[prop].constructor === Object) {
         if (a[prop] === undefined) {
           a[prop] = {}

package/src/version.js

@@ -1,3 +1,3 @@
-export const version = '7.2.0'
+export const version = '7.5.1'
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.