mathjs 10.5.2 → 10.6.1

package/docs/command_line_interface.md

@@ -1,87 +0,0 @@
-# Command Line Interface (CLI)
-
-When math.js is installed globally using npm, its expression parser can be used
-from the command line. To install math.js globally:
-
-```bash
-$ npm install -g mathjs
-```
-
-Normally, a global installation must be run with admin rights (precede the
-command with `sudo`). After installation, the application `mathjs` is available
-via the command line:
-
-```bash
-$ mathjs
-> 12 / (2.3 + 0.7)
-4
-> 12.7 cm to inch
-5 inch
-> sin(45 deg) ^ 2
-0.5
-> 9 / 3 + 2i
-3 + 2i
-> det([-1, 2; 3, 1])
--7
-```
-
-The command line interface can be used to open a prompt, to execute a script,
-or to pipe input and output streams:
-
-```bash
-$ mathjs                                 # Open a command prompt
-$ mathjs script.txt                      # Run a script file, output to console
-$ mathjs script1.txt script2.txt         # Run two script files
-$ mathjs script.txt > results.txt        # Run a script file, output to file
-$ cat script.txt | mathjs                # Run input stream, output to console
-$ cat script.txt | mathjs > results.txt  # Run input stream, output to file
-```
-
-You can also use it to create LaTeX from or sanitize your expressions using the
-`--tex` and `--string` options:
-
-```bash
-$ mathjs --tex
-> 1/2
-\frac{1}{2}
-```
-
-```bash
-$ mathjs --string
-> (1+1+1)
-(1 + 1 + 1)
-```
-
-To change the parenthesis option use the `--parenthesis=` flag:
-
-```bash
-$ mathjs --string --parenthesis=auto
-> (1+1+1)
-1 + 1 + 1
-```
-
-```bash
-$ mathjs --string --parenthesis=all
-> (1+1+1)
-(1 + 1) + 1
-```
-
-# Command line debugging (REPL)
-
-For debugging purposes, `bin/repl.js` provides a REPL (Read Evaluate Print Loop)
-for interactive testing of mathjs without having to build new build files after every
-little change to the source files. You can either start it directly (`./bin/repl.js`) or
-via node (`node bin/repl.js`).
-
-You can exit using either [ctrl]-[C] or [ctrl]-[D].
-
-```bash
-$ ./bin/repl.js 
-> math.parse('1+1')
-{ op: '+',
-  fn: 'add',
-  args: 
-   [ { value: '1', valueType: 'number' },
-     { value: '1', valueType: 'number' } ] }
-> 
-```

package/docs/core/chaining.md

@@ -1,41 +0,0 @@
-# Chaining
-
-Math.js supports chaining operations by wrapping a value into a `Chain`.
-A chain can be created with the function `math.chain(value)`
-(formerly `math.select(value)`).
-All functions available in the math namespace can be executed via the chain.
-The functions will be executed with the chain's value as the first argument,
-followed by extra arguments provided by the function call itself.
-
-```js
-math.chain(3)
-    .add(4)
-    .subtract(2)
-    .done() // 5
-
-math.chain( [[1, 2], [3, 4]] )
-    .subset(math.index(0, 0), 8)
-    .multiply(3)
-    .done() // [[24, 6], [9, 12]]
-```
-
-### API
-
-A `Chain` is constructed as:
-
-```js
-math.chain()
-math.chain(value)
-```
-
-The `Chain` has all functions available in the `math` namespace, and has
-a number of special functions:
-
- - `done()`
-   Finalize the chain and return the chain's value.
- - `valueOf()`
-   The same as `done()`, returns the chain's value.
- - `toString()`
-   Executes `math.format(value)` onto the chain's value, returning
-   a string representation of the value.
-

package/docs/core/configuration.md

@@ -1,144 +0,0 @@
-# Configuration
-
-Math.js contains a number of configuration options.
-These options can be applied on a created mathjs instance and changed afterwards.
-
-```js
-import { create, all } from 'mathjs'
-
-// create a mathjs instance with configuration
-const config = {
-  epsilon: 1e-12,
-  matrix: 'Matrix',
-  number: 'number',
-  precision: 64,
-  predictable: false,
-  randomSeed: null
-}
-const math = create(all, config)
-
-// read the applied configuration
-console.log(math.config())
-
-// change the configuration
-math.config({
-  number: 'BigNumber'
-})
-```
-
-The following configuration options are available:
-
-- `epsilon`. The minimum relative difference used to test equality between two
-  compared values. This value is used by all relational functions.
-  Default value is `1e-12`.
-
-- `matrix`. The default type of matrix output for functions.
-  Available values are: `'Matrix'` (default) or `'Array'`.
-  Where possible, the type of matrix output from functions is determined from
-  the function input: An array as input will return an Array, a Matrix as input
-  will return a Matrix. In case of no matrix as input, the type of output is
-  determined by the option `matrix`. In case of mixed matrix
-  inputs, a matrix will be returned always.
-
-- `number`. The type of numeric output for functions which cannot
-  determine the numeric type from the inputs. For most functions though,
-  the type of output is determined from the the input:
-  a number as input will return a number as output,
-  a BigNumber as input returns a BigNumber as output.
-
-  For example the functions `math.evaluate('2+3')`, `math.parse('2+3')`,
-  `math.range('1:10')`, and `math.unit('5cm')` use the `number` configuration
-  setting. But `math.sqrt(4)` will always return the number `2`
-  regardless of the `number` configuration, because the input is a number.
-
-  Available values are: `'number'` (default), `'BigNumber'`, or `'Fraction'`.
-  [BigNumbers](../datatypes/bignumbers.js) have higher precision than the default
-  numbers of JavaScript, and [`Fractions`](../datatypes/fractions.js) store
-  values in terms of a numerator and denominator.
-
-- `precision`. The maximum number of significant digits for BigNumbers.
-  This setting only applies to BigNumbers, not to numbers.
-  Default value is `64`.
-
-- `predictable`. Predictable output type of functions. When true, output type
-  depends only on the input types. When false (default), output type can vary
-  depending on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
-  predictable is false, and returns `NaN` when true.
-  Predictable output can be needed when programmatically handling the result of
-  a calculation, but can be inconvenient for users when evaluating dynamic
-  equations.
-
-- `randomSeed`. Set this option to seed pseudo random number generation, making it deterministic. The pseudo random number generator is reset with the seed provided each time this option is set. For example, setting it to `'a'` will cause `math.random()` to return `0.43449421599986604` upon the first call after setting the option every time. Set to `null` to seed the pseudo random number generator with a random seed. Default value is `null`.
-
-
-## Examples
-
-This section shows a number of configuration examples.
-
-### node.js
-
-```js
-import { create, all } from 'mathjs'
-
-const config = {
-  matrix: 'Array' // Choose 'Matrix' (default) or 'Array'
-}
-const math = create(all, config)
-
-// range will output an Array
-math.range(0, 4) // Array [0, 1, 2, 3]
-
-// change the configuration from Arrays to Matrices
-math.config({
-  matrix: 'Matrix' // Choose 'Matrix' (default) or 'Array'
-})
-
-// range will output a Matrix
-math.range(0, 4) // Matrix [0, 1, 2, 3]
-
-// create an instance of math.js with BigNumber configuration
-const bigmath = create(all, {
-  number: 'BigNumber', // Choose 'number' (default), 'BigNumber', or 'Fraction'
-  precision: 32        // 64 by default, only applicable for BigNumbers
-})
-
-// parser will parse numbers as BigNumber now:
-bigmath.evaluate('1 / 3') // BigNumber, 0.33333333333333333333333333333333
-```
-
-### browser
-
-
-```html
-<!DOCTYPE HTML>
-<html>
-<head>
-  <script src="math.js" type="text/javascript"></script>
-</head>
-<body>
-  <script type="text/javascript">
-    // the default instance of math.js is available as 'math'
-
-    // range will output a Matrix
-    math.range(0, 4)          // Matrix [0, 1, 2, 3]
-
-    // change the configuration of math from Matrices to Arrays
-    math.config({
-      matrix: 'Array'         // Choose 'Matrix' (default) or 'Array'
-    })
-
-    // range will output an Array
-    math.range(0, 4)          // Array [0, 1, 2, 3]
-
-    // create a new instance of math.js with bignumber configuration
-    const bigmath = math.create({
-      number: 'BigNumber',    // Choose 'number' (default), 'BigNumber', or 'Fraction'
-      precision: 32           // 64 by default, only applicable for BigNumbers
-    })
-
-    // parser will parse numbers as BigNumber now:
-    bigmath.evaluate('1 / 3') // BigNumber, 0.33333333333333333333333333333333
-  </script>
-</body>
-</html>
-```

package/docs/core/extension.md

@@ -1,263 +0,0 @@
-# Extension
-
-The library can easily be extended with functions and variables using the
-[`import`](../reference/functions/import.md) function. The `import` function is available on a mathjs instance, which can be created using the `create` function.
-
-```js
-import { create, all } from 'mathjs'
-
-const math = create(all)
-
-math.import(/* ... */)
-```
-
-The function `import` accepts an object with functions and variables, or an array with factory functions. It has the following syntax:
-
-```js
-math.import(functions: Object [, options: Object])
-```
-
-Where:
-
-- `functions` is an object or array containing the functions and/or values to be
-  imported. `import` support regular values and functions, typed functions
-  (see section [Typed functions](#typed-functions)), and factory functions
-  (see section [Factory functions](#factory-functions)).
-  An array is only applicable when it contains factory functions.
-
-- `options` is an optional second argument with options.
-  The following options are available:
-
-    - `{boolean} override`
-      If `true`, existing functions will be overwritten. The default value is `false`.
-    - `{boolean} silent`
-      If `true`, the function will not throw errors on duplicates or invalid
-      types. Default value is `false`.
-    - `{boolean} wrap`
-      If `true`, the functions will be wrapped in a wrapper function which
-      converts data types like Matrix to primitive data types like Array.
-      The wrapper is needed when extending math.js with libraries which do not
-      support the math.js data types. The default value is `false`.
-
-The following code example shows how to import a function and a value into math.js:
-
-```js
-// define new functions and variables
-math.import({
-  myvalue: 42,
-  hello: function (name) {
-    return 'hello, ' + name + '!'
-  }
-})
-
-// defined functions can be used in both JavaScript as well as the parser
-math.myvalue * 2                 // 84
-math.hello('user')               // 'hello, user!'
-
-const parser = math.parser()
-parser.evaluate('myvalue + 10')  // 52
-parser.evaluate('hello("user")') // 'hello, user!'
-```
-
-## Import external libraries
-
-External libraries like
-[numbers.js](https://github.com/sjkaliski/numbers.js) and
-[numeric.js](https://github.com/sloisel/numeric) can be imported as follows.
-The libraries must be installed using npm:
-
-    $ npm install numbers
-    $ npm install numeric
-
-The libraries can be easily imported into math.js using `import`.
-In order to convert math.js specific data types like `Matrix` to primitive types
-like `Array`, the imported functions can be wrapped by enabling `{wrap: true}`.
-
-```js
-import { create, all } from 'mathjs'
-import * as numbers from 'numbers'
-import * as numeric from 'numeric'
-
-// create a mathjs instance and import the numbers.js and numeric.js libraries
-const math = create(all)
-math.import(numbers, {wrap: true, silent: true})
-math.import(numeric, {wrap: true, silent: true})
-
-// use functions from numbers.js
-math.fibonacci(7)                           // 13
-math.evaluate('fibonacci(7)')               // 13
-
-// use functions from numeric.js
-math.evaluate('eig([1, 2; 4, 3])').lambda.x // [5, -1]
-```
-
-
-## Typed functions
-
-Typed functions can be created using `math.typed`. A typed function is a function
-which does type checking on the input arguments. It can have multiple signatures.
-And can automatically convert input types where needed.
-
-A typed function can be created like:
-
-```js
-const max = typed('max', {
-  'number, number': function (a, b) {
-    return Math.max(a, b)
-  },
-
-  'BigNumber, BigNumber': function (a, b) {
-    return a.greaterThan(b) ? a : b
-  }
-})
-```
-
-Typed functions can be merged as long as there are no conflicts in the signatures.
-This allows for extending existing functions in math.js with support for new
-data types.
-
-```js
-// create a new data type
-function MyType (value) {
-  this.value = value
-}
-MyType.prototype.isMyType = true
-MyType.prototype.toString = function () {
-  return 'MyType:' + this.value
-}
-
-// define a new datatype
-math.typed.addType({
-  name: 'MyType',
-  test: function (x) {
-    // test whether x is of type MyType
-    return x && x.isMyType
-  }
-})
-
-// use the type in a new typed function
-const add = typed('add', {
-  'MyType, MyType': function (a, b) {
-    return new MyType(a.value + b.value)
-  }
-})
-
-// import in math.js, extend the existing function `add` with support for MyType
-math.import({add: add})
-
-// use the new type
-const ans = math.add(new MyType(2), new MyType(3)) // returns MyType(5)
-console.log(ans)                                 // outputs 'MyType:5'
-```
-
-Detailed information on typed functions is available here:
-[https://github.com/josdejong/typed-function](https://github.com/josdejong/typed-function)
-
-
-
-
-## Factory functions
-
-Regular JavaScript functions can be imported in math.js using `math.import`:
-
-```js
-math.import({
-  myFunction: function (a, b) {
-     // ...
-  }
-})
-```
-
-The function can be stored in a separate file:
-
-```js
-export function myFunction (a, b) {
-  // ...
-}
-```
-
-Which can be imported like:
-
-```js
-import { myFunction } from './myFunction.js'
-
-math.import({
-  myFunction
-})
-```
-
-An issue arises when `myFunction` needs functionality from math.js:
-it doesn't have access to the current instance of math.js when in a separate file.
-Factory functions can be used to solve this issue. A factory function allows to inject dependencies into a function when creating it.
-
-A syntax of factory function is:
-
-```js
-factory(name: string, dependencies: string[], create: function, meta?: Object): function
-```
-
-where:
-
--   `name` is the name of the created function.
--   `dependencies` is an array with names of the dependent functions.
--   `create` is a function which creates the function.
-    An object with the dependencies is passed as first argument.
--   `meta` An optional object which can contain any meta data you want.
-    This will be attached as a property `meta` on the created function.
-    Known meta data properties used by the mathjs instance are:
-    -   `isClass: boolean`  If true, the created function is supposed to be a
-        class, and for example will not be exposed in the expression parser
-        for security reasons.
-    -   `lazy: boolean`.  By default, everything is imported lazily by `import`.
-        only as soon as the imported function or constant is actually used, it
-        will be constructed. A function can be forced to be created immediately
-        by setting `lazy: false` in the meta data.
-    -   `isTransformFunction: boolean`. If true, the created function is imported
-        as a transform function. It will not be imported in `math` itself, only
-        in the internal `mathWithTransform` namespace that is used by the
-        expression parser.
-    -   `recreateOnConfigChange: boolean`. If true, the imported factory will be
-        created again when there is a change in the configuration. This is for
-        example used for the constants like `pi`, which is different depending
-        on the configsetting `number` which can be numbers or BigNumbers.
-
-Here an example of a factory function which depends on `multiply`:
-
-```js
-import { factory, create, all } from 'mathjs'
-
-// create a factory function
-const name = 'negativeSquare'
-const dependencies = ['multiply', 'unaryMinus']
-const createNegativeSquare = factory(name, dependencies, function ({ multiply, unaryMinus }) {
-    return function negativeSquare (x) {
-      return unaryMinus(multiply(x, x))
-    }
-  })
-
-// create an instance of the function yourself:
-const multiply = (a, b) => a * b
-const unaryMinus = (a) => -a
-const negativeSquare = createNegativeSquare({ multiply, unaryMinus })
-console.log(negativeSquare(3)) // -9
-
-// or import the factory in a mathjs instance and use it there
-const math = create(all)
-math.import(createNegativeSquare)
-console.log(math.negativeSquare(4)) // -16
-console.log(math.evaluate('negativeSquare(5)')) // -25
-```
-
-You may wonder why you would inject functions `multiply` and `unaryMinus`
-instead of just doing these calculations inside the function itself. The
-reason is that this makes the factory function `negativeSquare` work for
-different implementations: numbers, BigNumbers, units, etc.
-
-```js
-import { Decimal } from 'decimal.js'
-
-// create an instance of our negativeSquare supporting BigNumbers instead of numbers
-const multiply = (a, b) => a.mul(b)
-const unaryMinus = (a) => new Decimal(0).minus(a)
-const negativeSquare = createNegativeSquare({ multiply, unaryMinus })
-```

package/docs/core/index.md

@@ -1,21 +0,0 @@
-# Core
-
-## Usage
-
-The core of math.js is the `math` namespace containing all functions and constants. There are three ways to do calculations in math.js:
-
-- Doing regular function calls like `math.add(math.sqrt(4), 2)`.
-- Evaluating expressions like `math.evaluate('sqrt(4) + 2')`
-- Chaining operations like `math.chain(4).sqrt().add(2)`.
-
-## Configuration
-
-math.js can be configured using the `math.config()`, see page [Configuration](configuration.md).
-
-## Extension
-
-math.js can be extended with new functions and constants using the function `math.import()`, see page [Extension](extension.md).
-
-## Serialization
-
-To persist or exchange data structures like matrices and units, the data types of math.js can be stringified as JSON. This is explained on the page [Serialization](serialization.md).

package/docs/core/serialization.md

@@ -1,50 +0,0 @@
-# Serialization
-
-Math.js has a number of data types like `Matrix`, `Complex`, and `Unit`. These
-types are instantiated JavaScript objects. To be able to store these data types
-or send them between processes, they must be serialized. The data types of
-math.js can be serialized to JSON. Use cases:
-
-- Store data in a database or on disk.
-- Interchange of data between a server and a client.
-- Interchange of data between a web worker and the browser.
-
-Math.js types can be serialized using JavaScript's built-in `JSON.stringify`
-function:
-
-```js
-const x = math.complex('2 + 3i')
-const str = JSON.stringify(x, math.replacer)
-console.log(str)
-// outputs a string '{"mathjs":"Complex","re":2,"im":3}'
-```
-
-> IMPORTANT: in most cases works, serialization correctly without
-> passing the `math.replacer` function as second argument. This is because
-> in most cases we can rely on the default behavior of JSON.stringify, which 
-> uses the `.toJSON` method on classes like `Unit` and `Complex` to correctly 
-> serialize them. However, there are a few special cases like the 
-> number `Infinity` which does require the replacer function in order to be 
-> serialized without losing information: without it, `Infinity` will be 
-> serialized as `"null"` and cannot be deserialized correctly.
->
-> So, it's best to always pass the `math.replacer` function to prevent 
-> weird edge cases.
-
-In order to deserialize a string, containing math.js data types, `JSON.parse`
-can be used. In order to recognize the data types of math.js, `JSON.parse` must
-be called with the reviver function of math.js:
-
-```js
-const json = '{"mathjs":"Unit","value":5,"unit":"cm","fixPrefix":false}'
-const x = JSON.parse(json, math.reviver)   // Unit 5 cm
-```
-
-Note that if math.js is used in conjunction with other data types, it is
-possible to use multiple reviver functions at the same time by cascading them:
-
-```js
-const reviver = function (key, value) {
-  return reviver1(key, reviver2(key, value))
-}
-```