mathjs 8.1.0 → 12.2.1

package/docs/custom_bundling.md

@@ -1,116 +0,0 @@
-# Custom bundling
-
-Math.js is a large library containing many data types and functions.
-It is well possible that you only need a small portion of the library.
-Math.js allows for picking just the functions and data types you need.
-This gives faster load times and smaller browser bundles. Math.js uses
-ES modules, and creating small bundles using tree-shaking works out of
-the box when using Webpack for example.
-
-This page describes:
-
-- How to use just a few functions for faster load times and smaller bundles.
-- How to use light-weight, number only implementations of functions.
-- What to expect from bundle sizes when using tree-shaking.
-
-## Using just a few functions
-
-Using the function `create`, a mathjs instance can be created.
-The `all` object contains all functionality available in mathjs,
-and a mathjs instance containing everything can be created like:
-
-```js
-import { create, all } from 'mathjs'
-
-const math = create(all)
-```
-
-To create an instance with just a few functions, you have to pass the
-factory functions of the functions you need, and all their dependencies.
-For example the function `add` depends on the functions `addScalar`,
-`equalScalar`, classes `DenseMatrix` and `SparseMatrix`, and more.
-Because it is hard to figure out what the dependencies of a function are,
-and the dependencies of the dependencies, mathjs provides ready made
-collections of all dependencies for every function. For example all
-factory functions of function `add` and its dependencies are available
-as `addDependencies`.
-
-Here is a full example of loading just a few functions in a mathjs instance:
-
-```js
-// file: custom_loading.js
-
-import {
-  create,
-  fractionDependencies,
-  addDependencies,
-  divideDependencies,
-  formatDependencies
-} from 'mathjs'
-
-const config = {
-  // optionally, you can specify configuration
-}
-
-// Create just the functions we need
-const { fraction, add, divide, format } = create({
-  fractionDependencies,
-  addDependencies,
-  divideDependencies,
-  formatDependencies
-}, config)
-
-// Use the created functions
-const a = fraction(1, 3)
-const b = fraction(3, 7)
-const c = add(a, b)
-const d = divide(a, b)
-console.log('c =', format(c)) // outputs "c = 16/21"
-console.log('d =', format(d)) // outputs "d = 7/9"
-```
-
-This example can be bundled using for example Webpack:
-
-```
-npx webpack custom_loading.js -o custom_loading.bundle.js --mode=production
-```
-
-Only the used parts of mathjs will be bundled thanks to tree-shaking.
-
-
-## Numbers only
-
-The functions of mathjs support multiple data types out of the box, like
-numbers, bignumbers, complex numbers, units, and matrices. Quite commonly however,
-only support for numbers is needed and the other data-types are overkill.
-
-To accomodate for this use case of only numbers only, mathjs offers light-weight,
-number only implementations of all relevant functions. These are available by
-importing from `'mathjs/number'` instead of `'mathjs'`:
-
-```js
-// use light-weight, numbers only implementations of functions
-import { create, all } from 'mathjs/number'
-
-const math = create(all)
-console.log(add(2, 3)) // 5
-```
-
-## Bundle size
-
-When using just a few functions of mathjs instead of the whole library,
-you may expect the size of the bundle to be just a small fraction of the
-complete library. However, to create the function `add` supporting all data
-types, all these data types must be included: Unit, BigNumber, Complex,
-DenseMatrix, SparseMatrix, etc. A rough idea of the size of different parts of
-mathjs:
-
-- About 5% is coming from core functionality like `create`, `import`, `factory`,
-  `typed-function`, etc.
-- About 30% of the bundle size comes from the data classes `Complex`, `BigNumber`, `Fraction`, `Unit`, `SparseMatrix`, `DenseMatrix`.
-- About 25%  of the bundle size comes from the expression parser.
-  Half of this comes from the embedded docs.
-- About 40% comes from the about 200 built-in functions and some constants.
-
-To get a better insight in what is in your JavaScript bundle, you can use
-a tool like [source-map-explorer](https://github.com/danvk/source-map-explorer).

package/docs/datatypes/bignumbers.md

@@ -1,102 +0,0 @@
-# BigNumbers
-
-For calculations with an arbitrary precision, math.js supports a `BigNumber`
-datatype. BigNumber support is powered by
-[decimal.js](https://github.com/MikeMcl/decimal.js/).
-
-## Usage
-
-A BigNumber can be created using the function `bignumber`:
-
-```js
-math.bignumber('2.3e+500') // BigNumber, 2.3e+500
-```
-
-Most functions can determine the type of output from the type of input:
-a number as input will return a number as output, a BigNumber as input returns
-a BigNumber as output. Functions which cannot determine the type of output
-from the input (for example `math.evaluate`) use the default number type `number`,
-which can be configured when instantiating math.js. To configure the use of
-BigNumbers instead of [numbers](numbers.md) by default, configure math.js like:
-
-```js
-math.config({
-  number: 'BigNumber',      // Default type of number:
-                            // 'number' (default), 'BigNumber', or 'Fraction'
-  precision: 64             // Number of significant digits for BigNumbers
-})
-
-// use math
-math.evaluate('0.1 + 0.2')  // BigNumber, 0.3
-```
-
-The default precision for BigNumber is 64 digits, and can be configured with
-the option `precision`.
-
-
-## Support
-
-Most functions in math.js support BigNumbers, but not all of them.
-For example the function `random` doesn't support BigNumbers.
-
-
-## Round-off errors
-
-Calculations with BigNumber are much slower than calculations with Number,
-but they can be executed with an arbitrary precision. By using a higher
-precision, it is less likely that round-off errors occur:
-
-```js
-// round-off errors with numbers
-math.add(0.1, 0.2)                                     // Number, 0.30000000000000004
-math.divide(0.3, 0.2)                                  // Number, 1.4999999999999998
-
-// no round-off errors with BigNumbers :)
-math.add(math.bignumber(0.1), math.bignumber(0.2))     // BigNumber, 0.3
-math.divide(math.bignumber(0.3), math.bignumber(0.2))  // BigNumber, 1.5
-```
-
-
-## Limitations
-
-It's important to realize that BigNumbers do not solve *all* problems related
-to precision and round-off errors. Numbers with an infinite number of digits
-cannot be represented with a regular number nor a BigNumber. Though a BigNumber
-can store a much larger number of digits, the amount of digits remains limited
-if only to keep calculations fast enough to remain practical.
-
-```js
-const one = math.bignumber(1)
-const three = math.bignumber(3)
-const third = math.divide(one, three)
-console.log(third.toString())
-// outputs 0.3333333333333333333333333333333333333333333333333333333333333333
-
-const ans = math.multiply(third, three)
-console.log(ans.toString())
-// outputs 0.9999999999999999999999999999999999999999999999999999999999999999
-// this should be 1 again, but `third` is rounded to a limited number of digits 3
-```
-
-
-## Conversion
-
-BigNumbers can be converted to numbers and vice versa using the functions
-`number` and `bignumber`. When converting a BigNumber to a number, the high
-precision of the BigNumber will be lost. When a BigNumber is too large to be represented
-as Number, it will be initialized as `Infinity`.
-
-```js
-// converting numbers and BigNumbers
-const a = math.number(0.3)                         // number, 0.3
-const b = math.bignumber(a)                        // BigNumber, 0.3
-const c = math.number(b)                           // number, 0.3
-
-// exceeding the maximum of a number
-const d = math.bignumber('1.2e500')                // BigNumber, 1.2e+500
-const e = math.number(d)                           // number, Infinity
-
-// loosing precision when converting to number
-const f = math.bignumber('0.2222222222222222222')  // BigNumber, 0.2222222222222222222
-const g = math.number(f)                           // number,    0.2222222222222222
-```

package/docs/datatypes/complex_numbers.md

@@ -1,168 +0,0 @@
-# Complex Numbers
-
-Math.js supports the creation, manipulation, and calculations with complex numbers.
-Support of complex numbers is powered by the library [complex.js](https://github.com/infusion/Complex.js).
-
-In mathematics, a complex number is an expression of the form `a + bi`,
-where `a` and `b` are real numbers and `i` represents the imaginary number
-defined as `i^2 = -1`. (In other words, `i` is the square root of `-1`.)
-The real number `a` is called the real part of the complex number,
-and the real number `b` is the imaginary part. For example, `3 + 2i` is a
-complex number, having real part `3` and imaginary part `2`.
-Complex numbers are often used in applied mathematics, control theory,
-signal analysis, fluid dynamics and other fields.
-
-## Usage
-
-A complex number is created using the function `math.complex`. This function
-accepts:
-
-- two numbers representing the real and imaginary part of the value,
-- a single string containing a complex value in the form `a + bi` where `a`
-  and `b` respectively represent the real and imaginary part of the complex number.
-- an object with either properties `re` and `im` for the real and imaginary
-  part of the value, or two properties `r` and `phi` containing the polar
-  coordinates of a complex value.
-The function returns a `Complex` object.
-
-Syntax:
-
-```js
-math.complex(re: number) : Complex
-math.complex(re: number, im: number) : Complex
-math.complex(complex: Complex) : Complex
-math.complex({re: Number, im: Number}) : Complex
-math.complex({r: number, phi: number}) : Complex
-math.complex({abs: number, arg: number}) : Complex
-math.complex(str: string) : Complex
-```
-
-Examples:
-
-```js
-const a = math.complex(2, 3)     // Complex 2 + 3i
-a.re                             // Number 2
-a.im                             // Number 3
-
-const b = math.complex('4 - 2i') // Complex 4 - 2i
-b.re = 5                         // Number 5
-b                                // Complex 5 - 2i
-```
-
-## Calculations
-
-Most functions of math.js support complex numbers. Complex and real numbers
-can be used together.
-
-```js
-const a = math.complex(2, 3)     // Complex 2 + 3i
-const b = math.complex('4 - 2i') // Complex 4 - 2i
-
-math.re(a)                       // Number 2
-math.im(a)                       // Number 3
-math.conj(a)                     // Complex 2 - 3i
-
-math.add(a, b)                   // Complex 6 + i
-math.multiply(a, 2)              // Complex 4 + 6i
-math.sqrt(-4)                    // Complex 2i
-```
-
-## API
-A `Complex` object created by `math.complex` contains the following properties and functions:
-
-### complex.re
-
-A number containing the real part of the complex number. Can be read and replaced.
-
-### complex.im
-
-A number containing the imaginary part of the complex number. Can be read and replaced.
-
-### complex.clone()
-
-Create a clone of the complex number.
-
-### complex.equals(other)
-
-Test whether a complex number equals another complex value.
-
-  Two complex numbers are equal when both their real and imaginary parts are
-  equal.
-
-### complex.neg()
-
-Returns a complex number with a real part and an imaginary part equal in magnitude but opposite in sign to the current complex number.
-
-### complex.conjugate()
-
-Returns a complex number with an equal real part and an imaginary part equal in magnitude but opposite in sign to the current complex number.
-
-### complex.inverse()
-
-Returns a complex number that is inverse of the current complex number.
-
-### complex.toVector()
-
-Get the vector representation of the current complex number. Returns an array of size 2.
-
-### complex.toJSON()
-
-Returns a JSON representation of the complex number, with signature
-  `{mathjs: 'Complex', re: number, im: number}`.
-  Used when serializing a complex number, see [Serialization](../core/serialization.md).
-
-### complex.toPolar()
-
-Get the polar coordinates of the complex number, returns
-  an object with properties `r` and `phi`.
-
-### complex.toString()
-
-Returns a string representation of the complex number, formatted
-  as `a + bi` where `a` is the real part and `b` the imaginary part.
-
-
-### complex.format([precision: number])
-
-Get a string representation of the complex number,
-  formatted as `a + bi` where `a` is the real part and `b` the imaginary part.
-  If precision is defined, the units value will be rounded to the provided
-  number of digits.
-
-## Static methods
-The following static methods can be accessed using `math.Complex`
-
-
-### Complex.fromJSON(json)
-
-Revive a complex number from a JSON object. Accepts
-  An object `{mathjs: 'Complex', re: number, im: number}`, where the property
-  `mathjs` is optional.
-  Used when deserializing a complex number, see [Serialization](../core/serialization.md).
-
-### Complex.fromPolar(r: number, phi: number)
-
-Create a complex number from polar coordinates.
-
-
-### Complex.compare(a: Complex, b: Complex)
-
-Returns the comparision result of two complex number:
-
-- Returns 1 when the real part of `a` is larger than the real part of `b`
-- Returns -1 when the real part of `a` is smaller than the real part of `b`
-- Returns 1 when the real parts are equal
-  and the imaginary part of `a` is larger than the imaginary part of `b`
-- Returns -1 when the real parts are equal
-  and the imaginary part of `a` is smaller than the imaginary part of `b`
-- Returns 0 when both real and imaginary parts are equal.
-
-Example:
-```js
-const a = math.complex(2, 3)   // Complex 2 + 3i
-const b = math.complex(2, 1)   // Complex 2 + 1i
-math.Complex.compare(a,b) // returns 1
-
-//create from json 
-const c = math.Complex.fromJSON({mathjs: 'Complex', re: 4, im: 3})  // Complex 4 + 3i
-```

package/docs/datatypes/fractions.md

@@ -1,75 +0,0 @@
-# Fractions
-
-For calculations with fractions, math.js supports a `Fraction` data type. 
-Fraction support is powered by [fraction.js](https://github.com/infusion/Fraction.js).
-Unlike [numbers](numbers.md) and [BigNumbers](./bignumbers.md), fractions can 
-store numbers with infinitely repeating decimals, for example `1/3 = 0.3333333...`, 
-which can be represented as `0.(3)`, or `2/7` which can be represented as `0.(285714)`.
-
-
-## Usage
-
-A Fraction can be created using the function `fraction`:
-
-```js
-math.fraction('1/3')   // Fraction, 1/3
-math.fraction(2, 3)    // Fraction, 2/3
-math.fraction('0.(3)') // Fraction, 1/3
-```
-
-And can be used in functions like `add` and `multiply` like:
-
-```js
-math.add(math.fraction('1/3'), math.fraction('1/6'))      // Fraction, 1/2
-math.multiply(math.fraction('1/4'), math.fraction('1/2')) // Fraction, 1/8
-```
-
-Note that not all functions support fractions. For example trigonometric 
-functions doesn't support fractions. When not supported, the functions
-will convert the input to numbers and return a number as result.
-
-Most functions will determine the type of output from the type of input:
-a number as input will return a number as output, a Fraction as input returns
-a Fraction as output. Functions which cannot determine the type of output
-from the input (for example `math.evaluate`) use the default number type `number`,
-which can be configured when instantiating math.js. To configure the use of
-fractions instead of [numbers](numbers.md) by default, configure math.js like:
-
-```js
-// Configure the default type of number: 'number' (default), 'BigNumber', or 'Fraction'
-math.config({
-  number: 'Fraction'
-})
-
-// use the expression parser
-math.evaluate('0.32 + 0.08') // Fraction, 2/5
-```
-
-## Support
-
-The following functions support fractions:
-
-- Arithmetic functions: `abs`, `add`, `ceil`, `cube`, `divide`, `dotDivide`, `dotMultiply`, `fix`, `floor`, `gcd`, `mod`, `multiply`, `round`, `sign`, `square`, `subtract`, `unaryMinus`, `unaryPlus`.
-- Construction functions: `fraction`.
-- Relational functions: `compare`, `deepEqual`, `equal`, `larger`, `largerEq`, `smaller`, `smallerEq`, `unequal`.
-- Utils functions: `format`.
-
-
-## Conversion
-
-Fractions can be converted to numbers and vice versa using the functions
-`number` and `fraction`. When converting a Fraction to a number, precision
-may be lost when the value cannot represented in 16 digits. 
-
-```js
-// converting numbers and fractions
-const a = math.number(0.3)                       // number, 0.3
-const b = math.fraction(a)                       // Fraction, 3/10
-const c = math.number(b)                         // number, 0.3
-
-// loosing precision when converting to number: a fraction can represent
-// a number with an infinite number of repeating decimals, a number just
-// stores about 16 digits and cuts consecutive digits.
-const d = math.fraction('2/5')                   // Fraction, 2/5
-const e = math.number(d)                         // number, 0.4
-```

package/docs/datatypes/index.md

@@ -1,67 +0,0 @@
-# Data Types
-
-The functions of math.js support multiple data types, both native JavaScript
-types as well as more advanced types implemented in math.js. The data types can
-be mixed together in calculations, for example by adding a Number to a
-Complex number or Array.
-
-The supported data types are:
-
-- Boolean
-- [Number](numbers.md)
-- [BigNumber](bignumbers.md)
-- [Complex](complex_numbers.md)
-- [Fraction](fractions.md)
-- [Array](matrices.md)
-- [Matrix](matrices.md)
-- [Unit](units.md)
-- String
-
-Function [`math.typeOf(x)`](../reference/functions/typeOf.md) can be used to get
-the type of a variable.
-
-Example usage:
-
-```js
-// use numbers
-math.subtract(7.1, 2.3)          // 4.8
-math.round(math.pi, 3)           // 3.142
-math.sqrt(4.41e2)                // 21
-
-// use BigNumbers
-math.add(math.bignumber(0.1), math.bignumber(0.2)) // BigNumber, 0.3
-
-// use Fractions
-math.add(math.fraction(1), math.fraction(3)) // Fraction, 0.(3)
-
-// use strings
-math.add('hello ', 'world')      // 'hello world'
-math.max('A', 'D', 'C')          // 'D'
-
-// use complex numbers
-const a = math.complex(2, 3)     // 2 + 3i
-a.re                             // 2
-a.im                             // 3
-const b = math.complex('4 - 2i') // 4 - 2i
-math.add(a, b)                   // 6 + i
-math.sqrt(-4)                    // 2i
-
-// use arrays
-const array = [1, 2, 3, 4, 5]
-math.factorial(array)            // Array,  [1, 2, 6, 24, 120]
-math.add(array, 3)               // Array,  [3, 5, 6, 7, 8]
-
-// use matrices
-const matrix = math.matrix([1, 4, 9, 16, 25]) // Matrix, [1, 4, 9, 16, 25]
-math.sqrt(matrix)                             // Matrix, [1, 2, 3, 4, 5]
-
-// use units
-const a = math.unit(55, 'cm')    // 550 mm
-const b = math.unit('0.1m')      // 100 mm
-math.add(a, b)                   // 0.65 m
-
-// check the type of a variable
-math.typeOf(2)                   // 'number'
-math.typeOf(math.unit('2 inch')) // 'Unit'
-math.typeOf(math.sqrt(-4))       // 'Complex'
-```