mathjs 7.5.1 → 7.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "7.5.1",
+  "version": "7.6.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -35,10 +35,10 @@
     "typed-function": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.11.6",
-    "@babel/plugin-transform-object-assign": "7.10.4",
-    "@babel/preset-env": "7.11.5",
-    "@babel/register": "7.11.5",
+    "@babel/core": "7.12.3",
+    "@babel/plugin-transform-object-assign": "7.12.1",
+    "@babel/preset-env": "7.12.1",
+    "@babel/register": "7.12.1",
     "babel-loader": "8.1.0",
     "benchmark": "2.1.4",
     "codecov": "3.8.0",
@@ -53,14 +53,14 @@
     "jsep": "0.3.5",
     "karma": "5.2.3",
     "karma-browserstack-launcher": "1.6.0",
-    "karma-firefox-launcher": "1.3.0",
+    "karma-firefox-launcher": "2.0.0",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "4.0.2",
     "lodash": "4.17.20",
     "math-expression-evaluator": "1.2.22",
     "mkdirp": "1.0.4",
-    "mocha": "8.1.3",
+    "mocha": "8.2.0",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
     "ndarray-gemm": "1.0.0",
@@ -69,9 +69,9 @@
     "numericjs": "1.2.6",
     "nyc": "15.1.0",
     "pad-right": "0.2.2",
-    "standard": "14.3.4",
+    "standard": "16.0.1",
     "sylvester": "0.0.21",
-    "uglify-js": "3.11.1",
+    "uglify-js": "3.11.4",
     "webpack": "4.44.2",
     "zeros": "1.0.0"
   },

package/src/core/function/import.js

@@ -82,8 +82,8 @@ export function importFactory (typed, load, math, importedFactories) {
       } else if (isFactory(value) || name !== undefined) {
         const flatName = isFactory(value)
           ? isTransformFunctionFactory(value)
-            ? (value.fn + '.transform') // TODO: this is ugly
-            : value.fn
+              ? (value.fn + '.transform') // TODO: this is ugly
+              : value.fn
           : name
 
         // we allow importing the same function twice if it points to the same implementation

package/src/entry/dependenciesAny/dependenciesRotate.generated.js

@@ -0,0 +1,15 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { multiplyDependencies } from './dependenciesMultiply.generated'
+import { rotationMatrixDependencies } from './dependenciesRotationMatrix.generated'
+import { typedDependencies } from './dependenciesTyped.generated'
+import { createRotate } from '../../factoriesAny.js'
+
+export const rotateDependencies = {
+  multiplyDependencies,
+  rotationMatrixDependencies,
+  typedDependencies,
+  createRotate
+}

package/src/entry/dependenciesAny.generated.js

@@ -82,6 +82,7 @@ export { onesDependencies } from './dependenciesAny/dependenciesOnes.generated'
 export { rangeDependencies } from './dependenciesAny/dependenciesRange.generated'
 export { reshapeDependencies } from './dependenciesAny/dependenciesReshape.generated'
 export { resizeDependencies } from './dependenciesAny/dependenciesResize.generated'
+export { rotateDependencies } from './dependenciesAny/dependenciesRotate.generated'
 export { rotationMatrixDependencies } from './dependenciesAny/dependenciesRotationMatrix.generated'
 export { rowDependencies } from './dependenciesAny/dependenciesRow.generated'
 export { sizeDependencies } from './dependenciesAny/dependenciesSize.generated'

package/src/entry/impureFunctionsAny.generated.js

@@ -26,13 +26,13 @@ import {
   createParse,
   createEvaluate,
   createHelpClass,
+  createParserClass,
+  createHelp,
+  createCompile,
   createSimplify,
   createRationalize,
-  createCompile,
-  createHelp,
-  createParserClass,
-  createDerivative,
   createParser,
+  createDerivative,
   createApplyTransform,
   createFilterTransform,
   createMapTransform,
@@ -325,13 +325,14 @@ import {
   molarVolume,
   planckTime,
   thomsonCrossSection,
-  unit,
+  rotate,
   mad,
   coulomb,
   magneticFluxQuantum,
   rydberg,
-  planckConstant,
-  gasConstant
+  unit,
+  gasConstant,
+  planckConstant
 } from './pureFunctionsAny.generated'
 
 const math = {} // NOT pure!
@@ -360,13 +361,13 @@ export const FunctionNode = createFunctionNode({ Node, SymbolNode, math })
 export const parse = createParse({ AccessorNode, ArrayNode, AssignmentNode, BlockNode, ConditionalNode, ConstantNode, FunctionAssignmentNode, FunctionNode, IndexNode, ObjectNode, OperatorNode, ParenthesisNode, RangeNode, RelationalNode, SymbolNode, config, numeric, typed })
 export const evaluate = createEvaluate({ parse, typed })
 export const Help = createHelpClass({ parse })
+export const Parser = createParserClass({ parse })
+export const help = createHelp({ Help, mathWithTransform, typed })
+export const compile = createCompile({ parse, typed })
 export const simplify = createSimplify({ bignumber, fraction, ConstantNode, FunctionNode, OperatorNode, ParenthesisNode, SymbolNode, add, config, divide, equal, isZero, mathWithTransform, multiply, parse, pow, subtract, typed })
 export const rationalize = createRationalize({ bignumber, fraction, ConstantNode, FunctionNode, OperatorNode, ParenthesisNode, SymbolNode, add, config, divide, equal, isZero, mathWithTransform, multiply, parse, pow, simplify, subtract, typed })
-export const compile = createCompile({ parse, typed })
-export const help = createHelp({ Help, mathWithTransform, typed })
-export const Parser = createParserClass({ parse })
-export const derivative = createDerivative({ ConstantNode, FunctionNode, OperatorNode, ParenthesisNode, SymbolNode, config, equal, isZero, numeric, parse, simplify, typed })
 export const parser = createParser({ Parser, typed })
+export const derivative = createDerivative({ ConstantNode, FunctionNode, OperatorNode, ParenthesisNode, SymbolNode, config, equal, isZero, numeric, parse, simplify, typed })
 
 Object.assign(math, {
   reviver,
@@ -633,21 +634,22 @@ Object.assign(math, {
   molarVolume,
   planckTime,
   thomsonCrossSection,
-  unit,
+  rotate,
+  parse,
+  evaluate,
   mad,
   coulomb,
   magneticFluxQuantum,
   rydberg,
-  parse,
-  evaluate,
+  unit,
+  help,
+  gasConstant,
+  compile,
   simplify,
   rationalize,
+  parser,
   planckConstant,
-  compile,
-  help,
-  gasConstant,
   derivative,
-  parser,
   config
 })
 

package/src/entry/pureFunctionsAny.generated.js

@@ -277,13 +277,14 @@ import {
   createMolarVolume,
   createPlanckTime,
   createThomsonCrossSection,
-  createUnitFunction,
+  createRotate,
   createMad,
   createCoulomb,
   createMagneticFluxQuantum,
   createRydberg,
-  createPlanckConstant,
-  createGasConstant
+  createUnitFunction,
+  createGasConstant,
+  createPlanckConstant
 } from '../factoriesAny'
 
 export const ResultSet = /* #__PURE__ */ createResultSet({})
@@ -559,10 +560,11 @@ export const inverseConductanceQuantum = /* #__PURE__ */ createInverseConductanc
 export const molarVolume = /* #__PURE__ */ createMolarVolume({ BigNumber, Unit, config })
 export const planckTime = /* #__PURE__ */ createPlanckTime({ BigNumber, Unit, config })
 export const thomsonCrossSection = /* #__PURE__ */ createThomsonCrossSection({ BigNumber, Unit, config })
-export const unit = /* #__PURE__ */ createUnitFunction({ Unit, typed })
+export const rotate = /* #__PURE__ */ createRotate({ multiply, rotationMatrix, typed })
 export const mad = /* #__PURE__ */ createMad({ abs, map, median, subtract, typed })
 export const coulomb = /* #__PURE__ */ createCoulomb({ BigNumber, Unit, config })
 export const magneticFluxQuantum = /* #__PURE__ */ createMagneticFluxQuantum({ BigNumber, Unit, config })
 export const rydberg = /* #__PURE__ */ createRydberg({ BigNumber, Unit, config })
-export const planckConstant = /* #__PURE__ */ createPlanckConstant({ BigNumber, Unit, config })
+export const unit = /* #__PURE__ */ createUnitFunction({ Unit, typed })
 export const gasConstant = /* #__PURE__ */ createGasConstant({ BigNumber, Unit, config })
+export const planckConstant = /* #__PURE__ */ createPlanckConstant({ BigNumber, Unit, config })

package/src/expression/embeddedDocs/embeddedDocs.js

@@ -215,6 +215,7 @@ import { numericDocs } from './function/utils/numeric'
 import { columnDocs } from './function/matrix/column'
 import { rowDocs } from './function/matrix/row'
 import { rotationMatrixDocs } from './function/matrix/rotationMatrix'
+import { rotateDocs } from './function/matrix/rotate'
 
 export const embeddedDocs = {
 
@@ -427,6 +428,7 @@ export const embeddedDocs = {
   range: rangeDocs,
   resize: resizeDocs,
   reshape: reshapeDocs,
+  rotate: rotateDocs,
   rotationMatrix: rotationMatrixDocs,
   row: rowDocs,
   size: sizeDocs,

package/src/expression/embeddedDocs/function/matrix/rotate.js

@@ -0,0 +1,19 @@
+export const rotateDocs = {
+  name: 'rotate',
+  category: 'Matrix',
+  syntax: [
+    'rotate(w, theta)',
+    'rotate(w, theta, v)'
+  ],
+  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: [
+    'rotate([1, 0], math.pi / 2)',
+    'rotate(matrix([1, 0]), unit("35deg"))',
+    'rotate([1, 0, 0], unit("90deg"), [0, 0, 1])',
+    'rotate(matrix([1, 0, 0]), unit("90deg"), matrix([0, 0, 1]))'
+  ],
+  seealso: [
+    'matrix', 'rotationMatrix'
+  ]
+}

package/src/expression/node/FunctionNode.js

@@ -287,7 +287,7 @@ export const createFunctionNode = /* #__PURE__ */ factory(name, dependencies, ({
 
     // Match everything of the form ${identifier} or ${identifier[2]} or $$
     // while submatching identifier and 2 (in the second case)
-    const regex = new RegExp('\\$(?:\\{([a-z_][a-z_0-9]*)(?:\\[([0-9]+)\\])?\\}|\\$)', 'ig')
+    const regex = /\$(?:\{([a-z_][a-z_0-9]*)(?:\[([0-9]+)\])?\}|\$)/gi
 
     let inputPos = 0 // position in the input string
     let match

package/src/expression/node/Node.js

@@ -115,7 +115,8 @@ export const createNode = /* #__PURE__ */ factory(name, dependencies, ({ mathWit
    */
   Node.prototype.traverse = function (callback) {
     // execute callback for itself
-    callback(this, null, null) // eslint-disable-line standard/no-callback-literal
+    // eslint-disable-next-line
+    callback(this, null, null)
 
     // recursively traverse over all childs of a node
     function _traverse (node, callback) {

package/src/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 { createRotate } from './function/matrix/rotate'
 export { createRotationMatrix } from './function/matrix/rotationMatrix'
 export { createRow } from './function/matrix/row'
 export { createSize } from './function/matrix/size'

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

@@ -37,7 +37,7 @@ export const createRotationMatrix = /* #__PURE__ */ factory(name, dependencies,
    * 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.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)]]
    *
@@ -76,12 +76,13 @@ export const createRotationMatrix = /* #__PURE__ */ factory(name, dependencies,
     'number | BigNumber | Complex | Unit, Array': function (theta, v) {
       const matrixV = matrix(v)
       _validateVector(matrixV)
-      return _rotationMatrix3x3(theta, matrixV, config.matrix === 'Matrix' ? 'dense' : undefined)
+      return _rotationMatrix3x3(theta, matrixV, undefined)
     },
 
     'number | BigNumber | Complex | Unit, Matrix': function (theta, v) {
       _validateVector(v)
-      return _rotationMatrix3x3(theta, v, config.matrix === 'Matrix' ? 'dense' : undefined)
+      const storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined)
+      return _rotationMatrix3x3(theta, v, storageType)
     },
 
     'number | BigNumber | Complex | Unit, Array, string': function (theta, v, format) {
@@ -152,7 +153,7 @@ export const createRotationMatrix = /* #__PURE__ */ factory(name, dependencies,
   function _rotationMatrix3x3 (theta, v, format) {
     const normV = norm(v)
     if (normV === 0) {
-      return _convertToFormat([], format)
+      throw new RangeError('Rotation around zero vector')
     }
 
     const Big = isBigNumber(theta) ? BigNumber : null

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

package/src/plain/number/probability.js

@@ -1,3 +1,5 @@
+/* eslint-disable no-loss-of-precision */
+
 import { isInteger } from '../../utils/number'
 import { product } from '../../utils/product'
 

package/src/type/unit/Unit.js

@@ -216,20 +216,15 @@ export const createUnitClass = /* #__PURE__ */ factory(name, dependencies, ({
     let unitName = ''
 
     // Alphanumeric characters only; matches [a-zA-Z0-9]
-    let code = text.charCodeAt(index)
-    while ((code >= 48 && code <= 57) ||
-    (code >= 65 && code <= 90) ||
-    (code >= 97 && code <= 122)) {
+    while (isDigit(c) || Unit.isValidAlpha(c)) {
       unitName += c
       next()
-      code = text.charCodeAt(index)
     }
 
     // Must begin with [a-zA-Z]
-    code = unitName.charCodeAt(0)
-    if ((code >= 65 && code <= 90) ||
-      (code >= 97 && code <= 122)) {
-      return unitName || null
+    const firstC = unitName.charAt(0)
+    if (Unit.isValidAlpha(firstC)) {
+      return unitName
     } else {
       return null
     }
@@ -1103,7 +1098,8 @@ export const createUnitClass = /* #__PURE__ */ factory(name, dependencies, ({
     // Simplfy the unit list, unless it is valueless or was created directly in the
     // constructor or as the result of to or toSI
     const simp = this.skipAutomaticSimplification || this.value === null
-      ? this.clone() : this.simplify()
+      ? this.clone()
+      : this.simplify()
 
     // Apply some custom logic for handling VA and VAR. The goal is to express the value of the unit as a real value, if possible. Otherwise, use a real-valued unit instead of a complex-valued one.
     let isImaginary = false
@@ -3030,21 +3026,22 @@ export const createUnitClass = /* #__PURE__ */ factory(name, dependencies, ({
     }
   }
 
+  /**
+   * Checks if a character is a valid latin letter (upper or lower case).
+   * Note that this function can be overridden, for example to allow support of other alphabets.
+   * @param {string} c Tested character
+   */
+  Unit.isValidAlpha = function isValidAlpha (c) {
+    return /^[a-zA-Z]$/.test(c)
+  }
+
   function assertUnitNameIsValid (name) {
     for (let i = 0; i < name.length; i++) {
-      const c = name.charAt(i)
-
-      const isValidAlpha = function (p) {
-        return /^[a-zA-Z]$/.test(p)
-      }
-
-      const isDigit = function (c) {
-        return (c >= '0' && c <= '9')
-      }
+      c = name.charAt(i)
 
-      if (i === 0 && !isValidAlpha(c)) { throw new Error('Invalid unit name (must begin with alpha character): "' + name + '"') }
+      if (i === 0 && !Unit.isValidAlpha(c)) { throw new Error('Invalid unit name (must begin with alpha character): "' + name + '"') }
 
-      if (i > 0 && !(isValidAlpha(c) ||
+      if (i > 0 && !(Unit.isValidAlpha(c) ||
         isDigit(c))) { throw new Error('Invalid unit name (only alphanumeric characters are allowed): "' + name + '"') }
     }
   }

package/src/version.js

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