mathjs 10.5.2 → 10.5.3

package/examples/advanced/custom_relational_functions.js

@@ -1,62 +0,0 @@
-const { create, all, factory } = require('../..')
-
-// First let's see what the default behavior is:
-// strings are compared by their numerical value
-console.log('default (compare string by their numerical value)')
-const { evaluate } = create(all)
-evaluateAndLog(evaluate, '2 < 10') // true
-evaluateAndLog(evaluate, '"2" < "10"') // true
-evaluateAndLog(evaluate, '"a" == "b"') // Error: Cannot convert "a" to a number
-evaluateAndLog(evaluate, '"a" == "a"') // Error: Cannot convert "a" to a number
-console.log('')
-
-// Suppose we want different behavior for string comparisons. To achieve
-// this we can replace the factory functions for all relational functions
-// with our own. In this simple example we use the JavaScript implementation.
-console.log('custom (compare strings lexically)')
-
-const allWithCustomFunctions = {
-  ...all,
-
-  createEqual: factory('equal', [], () => function equal (a, b) {
-    return a === b
-  }),
-
-  createUnequal: factory('unequal', [], () => function unequal (a, b) {
-    return a !== b
-  }),
-
-  createSmaller: factory('smaller', [], () => function smaller (a, b) {
-    return a < b
-  }),
-
-  createSmallerEq: factory('smallerEq', [], () => function smallerEq (a, b) {
-    return a <= b
-  }),
-
-  createLarger: factory('larger', [], () => function larger (a, b) {
-    return a > b
-  }),
-
-  createLargerEq: factory('largerEq', [], () => function largerEq (a, b) {
-    return a >= b
-  }),
-
-  createCompare: factory('compare', [], () => function compare (a, b) {
-    return a > b ? 1 : a < b ? -1 : 0
-  })
-}
-const evaluateCustom = create(allWithCustomFunctions).evaluate
-evaluateAndLog(evaluateCustom, '2 < 10') // true
-evaluateAndLog(evaluateCustom, '"2" < "10"') // false
-evaluateAndLog(evaluateCustom, '"a" == "b"') // false
-evaluateAndLog(evaluateCustom, '"a" == "a"') // true
-
-// helper function to evaluate an expression and print the results
-function evaluateAndLog (evaluate, expression) {
-  try {
-    console.log(expression, evaluate(expression))
-  } catch (err) {
-    console.error(expression, err.toString())
-  }
-}

package/examples/advanced/custom_scope_objects.js

@@ -1,115 +0,0 @@
-const { create, all } = require('../..')
-
-const math = create(all)
-
-// The expression evaluator accepts an optional scope object.
-// This is the symbol table for variable defintions and function declations.
-
-// Scope can be a bare object.
-function withObjectScope () {
-  const scope = { x: 3 }
-
-  math.evaluate('x', scope) // 1
-  math.evaluate('y = 2 x', scope)
-  math.evaluate('scalar = 1', scope)
-  math.evaluate('area(length, width) = length * width * scalar', scope)
-  math.evaluate('A = area(x, y)', scope)
-
-  console.log('Object scope:', scope)
-}
-
-// Where flexibility is important, scope can duck type appear to be a Map.
-function withMapScope (scope, name) {
-  scope.set('x', 3)
-
-  math.evaluate('x', scope) // 1
-  math.evaluate('y = 2 x', scope)
-  math.evaluate('scalar = 1', scope)
-  math.evaluate('area(length, width) = length * width * scalar', scope)
-  math.evaluate('A = area(x, y)', scope)
-
-  console.log(`Map-like scope (${name}):`, scope.localScope)
-}
-
-// This is a minimal set of functions to look like a Map.
-class MapScope {
-  constructor () {
-    this.localScope = new Map()
-  }
-
-  get (key) {
-    // Remember to sanitize your inputs, or use
-    // a datastructure that isn't a footgun.
-    return this.localScope.get(key)
-  }
-
-  set (key, value) {
-    return this.localScope.set(key, value)
-  }
-
-  has (key) {
-    return this.localScope.has(key)
-  }
-
-  keys () {
-    return this.localScope.keys()
-  }
-}
-
-/*
- * This is a more fully featured example, with all methods
- * used in mathjs.
- *
- */
-class AdvancedMapScope extends MapScope {
-  constructor (parent) {
-    super()
-    this.parentScope = parent
-  }
-
-  get (key) {
-    return this.localScope.get(key) ?? this.parentScope?.get(key)
-  }
-
-  has (key) {
-    return this.localScope.has(key) ?? this.parentScope?.get(key)
-  }
-
-  keys () {
-    if (this.parentScope) {
-      return new Set([...this.localScope.keys(), ...this.parentScope.keys()])
-    } else {
-      return this.localScope.keys()
-    }
-  }
-
-  delete () {
-    return this.localScope.delete()
-  }
-
-  clear () {
-    return this.localScope.clear()
-  }
-
-  /**
-   * Creates a child scope from this one. This is used in function calls.
-   *
-   * @returns a new Map scope that has access to the symbols in the parent, but
-   * cannot overwrite them.
-   */
-  createSubScope () {
-    return new AdvancedMapScope(this)
-  }
-
-  toString () {
-    return this.localScope.toString()
-  }
-}
-
-withObjectScope()
-// Where safety is important, scope can also be a Map
-withMapScope(new Map(), 'simple Map')
-// Where flexibility is important, scope can duck type appear to be a Map.
-withMapScope(new MapScope(), 'MapScope example')
-// Extra methods allow even finer grain control.
-withMapScope(new AdvancedMapScope(), 'AdvancedScope example')

package/examples/advanced/expression_trees.js

@@ -1,55 +0,0 @@
-const { parse, ConstantNode } = require('../..')
-
-// Filter an expression tree
-console.log('Filter all symbol nodes "x" in the expression "x^2 + x/4 + 3*y"')
-const node = parse('x^2 + x/4 + 3*y')
-const filtered = node.filter(function (node) {
-  return node.isSymbolNode && node.name === 'x'
-})
-// returns an array with two entries: two SymbolNodes 'x'
-
-filtered.forEach(function (node) {
-  console.log(node.type, node.toString())
-})
-// outputs:
-//  SymbolNode x
-//  SymbolNode x
-
-// Traverse an expression tree
-console.log()
-console.log('Traverse the expression tree of expression "3 * x + 2"')
-const node1 = parse('3 * x + 2')
-node1.traverse(function (node, path, parent) {
-  switch (node.type) {
-    case 'OperatorNode':
-      console.log(node.type, node.op)
-      break
-    case 'ConstantNode':
-      console.log(node.type, node.value)
-      break
-    case 'SymbolNode':
-      console.log(node.type, node.name)
-      break
-    default: console.log(node.type)
-  }
-})
-// outputs:
-//   OperatorNode +
-//   OperatorNode *
-//   ConstantNode 3
-//   SymbolNode x
-//   ConstantNode 2
-
-// transform an expression tree
-console.log()
-console.log('Replace all symbol nodes "x" in expression "x^2 + 5*x" with a constant 3')
-const node2 = parse('x^2 + 5*x')
-const transformed = node2.transform(function (node, path, parent) {
-  if (node.isSymbolNode && node.name === 'x') {
-    return new ConstantNode(3)
-  } else {
-    return node
-  }
-})
-console.log(transformed.toString())
-// outputs: '3 ^ 2 + 5 * 3'

package/examples/advanced/function_transform.js

@@ -1,50 +0,0 @@
-/**
- * Function transforms
- *
- * When using functions via the expression parser, it is possible to preprocess
- * function arguments and post process a functions return value by writing a
- * *transform* for the function. A transform is a function wrapping around a
- * function to be transformed or completely replaces a function.
- */
-const { create, all } = require('../..')
-const math = create(all)
-
-// create a function
-function addIt (a, b) {
-  return a + b
-}
-
-// attach a transform function to the function addIt
-addIt.transform = function (a, b) {
-  console.log('input: a=' + a + ', b=' + b)
-  // we can manipulate the input arguments here before executing addIt
-
-  const res = addIt(a, b)
-
-  console.log('result: ' + res)
-  // we can manipulate the result here before returning
-
-  return res
-}
-
-// import the function into math.js
-math.import({
-  addIt: addIt
-})
-
-// use the function via the expression parser
-console.log('Using expression parser:')
-console.log('2+4=' + math.evaluate('addIt(2, 4)'))
-// This will output:
-//
-//     input: a=2, b=4
-//     result: 6
-//     2+4=6
-
-// when used via plain JavaScript, the transform is not invoked
-console.log('')
-console.log('Using plain JavaScript:')
-console.log('2+4=' + math.addIt(2, 4))
-// This will output:
-//
-//     6

package/examples/advanced/more_secure_eval.js

@@ -1,36 +0,0 @@
-// Expression parser security
-//
-// Executing arbitrary expressions like enabled by the expression parser of
-// mathjs involves a risk in general. When you're using mathjs to let users
-// execute arbitrary expressions, it's good to take a moment to think about
-// possible security and stability implications, especially when running the
-// code server side.
-//
-// There is a small number of functions which yield the biggest security risk
-// in the expression parser of math.js:
-//
-// - `import` and `createUnit` which alter the built-in functionality and allow
-//   overriding existing functions and units.
-// - `evaluate`, `parse`, `simplify`, and `derivative` which parse arbitrary input
-//   into a manipulable expression tree.
-//
-// To make the expression parser less vulnerable whilst still supporting most
-// functionality, these functions can be disabled, as demonstrated in this
-// example.
-
-const { create, all } = require('../..')
-const math = create(all)
-
-const limitedEvaluate = math.evaluate
-
-math.import({
-  import: function () { throw new Error('Function import is disabled') },
-  createUnit: function () { throw new Error('Function createUnit is disabled') },
-  evaluate: function () { throw new Error('Function evaluate is disabled') },
-  parse: function () { throw new Error('Function parse is disabled') },
-  simplify: function () { throw new Error('Function simplify is disabled') },
-  derivative: function () { throw new Error('Function derivative is disabled') }
-}, { override: true })
-
-console.log(limitedEvaluate('sqrt(16)')) // Ok, 4
-console.log(limitedEvaluate('parse("2+3")')) // Error: Function parse is disabled

package/examples/advanced/use_bigint.js

@@ -1,43 +0,0 @@
-// This example demonstrates how you could integrate support for BigInt
-// in mathjs. It's just a proof of concept, for full support you will
-// have to defined more functions and define conversions from and to
-// other data types.
-
-const { create, all, factory } = require('../..')
-const math = create(all)
-
-// we can also add conversions here from number or string to BigInt
-// and vice versa using math.typed.addConversion(...)
-
-math.import([
-  factory('BigInt', ['typed'], function createBigInt ({ typed }) {
-    typed.addType({
-      name: 'BigInt',
-      test: (x) => typeof x === 'bigint' // eslint-disable-line
-    })
-
-    return BigInt // eslint-disable-line
-  }, { lazy: false }),
-
-  factory('bigint', ['typed', 'BigInt'], function createBigint ({ typed, BigInt }) {
-    return typed('bigint', {
-      'number | string ': (x) => BigInt(x) // eslint-disable-line
-    })
-  }),
-
-  factory('add', ['typed'], function createBigIntAdd ({ typed }) {
-    return typed('add', {
-      'BigInt, BigInt': (a, b) => a + b
-    })
-  }),
-
-  factory('pow', ['typed'], function createBigIntPow ({ typed }) {
-    return typed('pow', {
-      'BigInt, BigInt': (a, b) => a ** b
-    })
-  })
-])
-
-console.log(math.evaluate('4349 + 5249'))
-console.log(math.evaluate('bigint(4349) + bigint(5249)'))
-console.log(math.evaluate('bigint(4349) ^ bigint(5249)'))

package/examples/advanced/web_server/math_worker.js

@@ -1,24 +0,0 @@
-const { create, all } = require('../../..')
-const workerpool = require('workerpool')
-const math = create(all)
-
-// disable the import function so the math.js instance cannot be changed
-function noImport () {
-  throw new Error('function import is disabled.')
-}
-math.import({ import: noImport }, { override: true })
-
-/**
- * Evaluate an expression
- * @param {string} expr
- * @return {string} result
- */
-function evaluate (expr) {
-  const ans = math.evaluate(expr)
-  return math.format(ans)
-}
-
-// create a worker and register public functions
-workerpool.worker({
-  evaluate: evaluate
-})

package/examples/advanced/web_server/server.js

@@ -1,80 +0,0 @@
-/**
- * This example demonstrates how to run math.js in a child process with limited
- * execution time.
- *
- * Prerequisites:
- *
- *     npm install express workerpool
- *
- * Start the server:
- *
- *     node ./server.js
- *
- * Make a request to the server:
- *
- *     GET http://localhost:8080/mathjs?expr=sqrt(16)
- *
- * Note that the query parameter `expr` should be properly url encoded.
- */
-const path = require('path')
-
-let express
-let workerpool
-try {
-  express = require('express')
-  workerpool = require('workerpool')
-} catch (err) {
-  console.log('Error: To run this example, install express and workerpool first via:\n\n' +
-      '    npm install express workerpool\n')
-  process.exit()
-}
-
-const app = express()
-const pool = workerpool.pool(path.join(__dirname, '/math_worker.js'))
-
-const TIMEOUT = 10000 // milliseconds
-
-/**
- * GET /mathjs?expr=...
- */
-app.get('/mathjs', function (req, res) {
-  const expr = req.query.expr
-  if (expr === undefined) {
-    return res.status(400).send('Error: Required query parameter "expr" missing in url.')
-  }
-
-  pool.exec('evaluate', [expr])
-    .timeout(TIMEOUT)
-    .then(function (result) {
-      res.send(result)
-    })
-    .catch(function (err) {
-      res.status(400).send(formatError(err))
-    })
-})
-
-/**
- * Format error messages as string
- * @param {Error} err
- * @return {String} message
- */
-function formatError (err) {
-  if (err instanceof workerpool.Promise.TimeoutError) {
-    return 'TimeoutError: Evaluation exceeded maximum duration of ' + TIMEOUT / 1000 + ' seconds'
-  } else {
-    return err.toString()
-  }
-}
-
-// handle uncaught exceptions so the application cannot crash
-process.on('uncaughtException', function (err) {
-  console.log('Caught exception: ' + err)
-  console.trace()
-})
-
-// start the server
-const PORT = process.env.PORT || 8080
-app.listen(PORT, function () {
-  console.log('Listening at http://localhost:' + PORT)
-  console.log('Example request:\n    GET http://localhost:' + PORT + '/mathjs?expr=sqrt(16)')
-})

package/examples/algebra.js

@@ -1,34 +0,0 @@
-// algebra
-//
-// math.js has support for symbolic computation (CAS). It can parse
-// expressions in an expression tree and do algebraic operations like
-// simplification and derivation on this tree.
-
-// load math.js (using node.js)
-const { simplify, parse, derivative } = require('..')
-
-// simplify an expression
-console.log('simplify expressions')
-console.log(simplify('3 + 2 / 4').toString()) // '7 / 2'
-console.log(simplify('2x + 3x').toString()) // '5 * x'
-console.log(simplify('2 * 3 * x', { x: 4 }).toString()) // '24'
-console.log(simplify('x^2 + x + 3 + x^2').toString()) // '2 * x ^ 2 + x + 3'
-console.log(simplify('x * y * -x / (x ^ 2)').toString()) // '-y'
-
-// work with an expression tree, evaluate results
-const f = parse('2x + x')
-const simplified = simplify(f)
-console.log(simplified.toString()) // '3 * x'
-console.log(simplified.evaluate({ x: 4 })) // 12
-console.log()
-
-// calculate a derivative
-console.log('calculate derivatives')
-console.log(derivative('2x^2 + 3x + 4', 'x').toString()) // '4 * x + 3'
-console.log(derivative('sin(2x)', 'x').toString()) // '2 * cos(2 * x)'
-
-// work with an expression tree, evaluate results
-const h = parse('x^2 + x')
-const dh = derivative(h, 'x')
-console.log(dh.toString()) // '2 * x + 1'
-console.log(dh.evaluate({ x: 3 })) // '7'

package/examples/basic_usage.js

@@ -1,49 +0,0 @@
-// basic usage
-
-// load math.js (using node.js)
-const math = require('..')
-
-// functions and constants
-console.log('functions and constants')
-print(math.round(math.e, 3)) // 2.718
-print(math.atan2(3, -3) / math.pi) // 0.75
-print(math.log(10000, 10)) // 4
-print(math.sqrt(-4)) // 2i
-print(math.pow([[-1, 2], [3, 1]], 2)) // [[7, 0], [0, 7]]
-print(math.derivative('x^2 + x', 'x')) // 2 * x + 1
-console.log()
-
-// expressions
-console.log('expressions')
-print(math.evaluate('1.2 * (2 + 4.5)')) // 7.8
-print(math.evaluate('12.7 cm to inch')) // 5 inch
-print(math.evaluate('sin(45 deg) ^ 2')) // 0.5
-print(math.evaluate('9 / 3 + 2i')) // 3 + 2i
-print(math.evaluate('det([-1, 2; 3, 1])')) // -7
-console.log()
-
-// chained operations
-console.log('chained operations')
-const a = math.chain(3)
-  .add(4)
-  .multiply(2)
-  .done()
-print(a) // 14
-console.log()
-
-// mixed use of different data types in functions
-console.log('mixed use of data types')
-print(math.add(4, [5, 6])) // number + Array, [9, 10]
-print(math.multiply(math.unit('5 mm'), 3)) // Unit * number,  15 mm
-print(math.subtract([2, 3, 4], 5)) // Array - number, [-3, -2, -1]
-print(math.add(math.matrix([2, 3]), [4, 5])) // Matrix + Array, [6, 8]
-console.log()
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
-  const precision = 14
-  console.log(math.format(value, precision))
-}

package/examples/bignumbers.js

@@ -1,52 +0,0 @@
-/* eslint-disable no-loss-of-precision */
-
-// BigNumbers
-
-const { create, all } = require('..')
-
-// configure the default type of numbers as BigNumbers
-const config = {
-  // Default type of number
-  // Available options: 'number' (default), 'BigNumber', or 'Fraction'
-  number: 'BigNumber',
-
-  // Number of significant digits for BigNumbers
-  precision: 20
-}
-const math = create(all, config)
-
-console.log('round-off errors with numbers')
-print(math.add(0.1, 0.2)) // number, 0.30000000000000004
-print(math.divide(0.3, 0.2)) // number, 1.4999999999999998
-console.log()
-
-console.log('no round-off errors with BigNumbers')
-print(math.add(math.bignumber(0.1), math.bignumber(0.2))) // BigNumber, 0.3
-print(math.divide(math.bignumber(0.3), math.bignumber(0.2))) // BigNumber, 1.5
-console.log()
-
-console.log('create BigNumbers from strings when exceeding the range of a number')
-print(math.bignumber(1.2e+500)) // BigNumber, Infinity      WRONG
-print(math.bignumber('1.2e+500')) // BigNumber, 1.2e+500
-console.log()
-
-console.log('BigNumbers still have a limited precision and are no silve bullet')
-const third = math.divide(math.bignumber(1), math.bignumber(3))
-const total = math.add(third, third, third)
-print(total) // BigNumber, 0.99999999999999999999
-console.log()
-
-// one can work conveniently with BigNumbers using the expression parser.
-// note though that BigNumbers are only supported in arithmetic functions
-console.log('use BigNumbers in the expression parser')
-print(math.evaluate('0.1 + 0.2')) // BigNumber, 0.3
-print(math.evaluate('0.3 / 0.2')) // BigNumber, 1.5
-console.log()
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
-  console.log(math.format(value))
-}