diff --git a/.gitignore b/.gitignore
index 13fb138245..016b59ea14 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,24 @@
-.idea
-_site
-coverage
-node_modules
+# build output
+dist/
+
+# generated types
+.astro/
+
+# dependencies
+node_modules/
+
+# logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# environment variables
+.env
+.env.production
+
+# macOS-specific files
+.DS_Store
+
+# jetbrains setting folder
+.idea/
diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index ae92fb3ac4..0000000000
--- a/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "mathjs-src"]
- path = mathjs-src
- url = git@github.com:josdejong/mathjs.git
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 0000000000..22a15055d6
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,4 @@
+{
+ "recommendations": ["astro-build.astro-vscode"],
+ "unwantedRecommendations": []
+}
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000000..d642209762
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,11 @@
+{
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "command": "./node_modules/.bin/astro dev",
+ "name": "Development server",
+ "request": "launch",
+ "type": "node-terminal"
+ }
+ ]
+}
diff --git a/CNAME b/CNAME
deleted file mode 100644
index d06970773b..0000000000
--- a/CNAME
+++ /dev/null
@@ -1 +0,0 @@
-mathjs.org
\ No newline at end of file
diff --git a/README.md b/README.md
index 24569b2897..ff19a3e7ec 100644
--- a/README.md
+++ b/README.md
@@ -1,43 +1,48 @@
-# math.js website
+# Astro Starter Kit: Basics
-This project contains the website of math.js, available at https://mathjs.org.
-The website is static, and is hosted on [github pages](https://pages.github.com/).
+```sh
+npm create astro@latest -- --template basics
+```
+[](https://stackblitz.com/github/withastro/astro/tree/latest/examples/basics)
+[](https://codesandbox.io/p/sandbox/github/withastro/astro/tree/latest/examples/basics)
+[](https://codespaces.new/withastro/astro?devcontainer_path=.devcontainer/basics/devcontainer.json)
-# Update
+> 🧑🚀 **Seasoned astronaut?** Delete this file. Have fun!
-To update the website with the latest version of math.js:
+
-- Update the version number of math.js in package.json.
+## 🚀 Project Structure
-- Install the dependencies via npm:
+Inside of your Astro project, you'll see the following folders and files:
- npm install
+```text
+/
+├── public/
+│ └── favicon.svg
+├── src/
+│ ├── layouts/
+│ │ └── Layout.astro
+│ └── pages/
+│ └── index.astro
+└── package.json
+```
-- Update the docs, examples, and version number via the build tool:
+To learn more about the folder structure of an Astro project, refer to [our guide on project structure](https://docs.astro.build/en/basics/project-structure/).
- npm run build
+## 🧞 Commands
- Note that this script will update a git submodule `./mathjs-src` which checks
- out the `master` branch and generates the docs and examples fresh from the
- source code.
+All commands are run from the root of the project, from a terminal:
-- Ensure any new pages are added to git.
+| Command | Action |
+| :------------------------ | :----------------------------------------------- |
+| `npm install` | Installs dependencies |
+| `npm run dev` | Starts local dev server at `localhost:4321` |
+| `npm run build` | Build your production site to `./dist/` |
+| `npm run preview` | Preview your build locally, before deploying |
+| `npm run astro ...` | Run CLI commands like `astro add`, `astro check` |
+| `npm run astro -- --help` | Get help using the Astro CLI |
-- To generate the website locally using [Jekyll](https://jekyllrb.com/):
+## 👀 Want to learn more?
- jekyll
-
- This will generate the static website in the folder `_site`.
-
-- To test the website locally, use Jekyll as server:
-
- jekyll --server 4000
-
- The website is than available in the browser at http://localhost:4000.
-
-
-# Deploy
-
-To deploy the website, all that is needed is to commit the changes via git,
-and push the changes to the `gh-pages` branch of math.js on github.
+Feel free to check [our documentation](https://docs.astro.build) or jump into our [Discord server](https://astro.build/chat).
diff --git a/_config.yml b/_config.yml
deleted file mode 100644
index 5447fa6fde..0000000000
--- a/_config.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-exclude: [node_modules, coverage]
-
-markdown: kramdown
diff --git a/_layouts/default.html b/_layouts/default.html
deleted file mode 100644
index f9dc2426ec..0000000000
--- a/_layouts/default.html
+++ /dev/null
@@ -1,129 +0,0 @@
-
-
-
- math.js | an extensive math library for JavaScript and Node.js
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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
-```
-
-
-
-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]]
-```
-
-
-
-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.
-
-Note that a "rest" or "..." parameter may not be broken across the value
-in the chain and a function call. For example
-
-```js
-math.chain(3).median(4,5).done() // throws error
-```
-
-does not compute the median of 3, 4, and 5.
diff --git a/docs/core/configuration.md b/docs/core/configuration.md
deleted file mode 100644
index 1eb4b8ded8..0000000000
--- a/docs/core/configuration.md
+++ /dev/null
@@ -1,162 +0,0 @@
----
-layout: default
----
-
-
-
-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 = {
- relTol: 1e-12,
- absTol: 1e-15,
- matrix: 'Matrix',
- number: 'number',
- numberFallback: '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:
-
-- `relTol`. 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`.
-
-- `absTol`. The minimum absolute difference used to test equality between two
- compared values. This value is used by all relational functions.
- Default value is `1e-15`.
-
-- `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 used to parse strings into a numeric value or create a new
- numeric value internally.
-
- For most functions, the type of output is determined from the input:
- a number as input will return a number as output, a BigNumber as input
- returns a BigNumber as output. But 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.
-
- Note that `math.sqrt(4)` will always return the number `2` regardless of
- the `number` configuration, because the numeric type can be determined from
- the input value.
-
- Available values are: `'number'` (default), `'BigNumber'`, `'bigint'`, or `'Fraction'`.
- [BigNumbers](../datatypes/bignumbers.html) have higher precision than the default numbers of JavaScript,
- [bigint](../datatypes/bigints.html) can represent large integer numbers,
- and [`Fractions`](../datatypes/fractions.html) store values in terms of a numerator and
- denominator.
-
-- `numberFallback`. When `number` is configured for example with value `'bigint'`,
- and a value cannot be represented as `bigint` like in `math.evaluate('2.3')`,
- the value will be parsed in the type configured with `numberFallback`.
- Available values: `'number'` (default) or `'BigNumber'`.
-
-- `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`.
-
-
-
-
-The library can easily be extended with functions and variables using the
-[`import`](../reference/functions/import.html) 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!'
-```
-
-
-
-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 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)
-
-
-
-
-
-
-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.
- - `formerly: string`. If present, the created function will also be
- accessible on the instance under the name given by the value of
- `formerly` as a (deprecated) synonym for the specified `name`. This
- facility should only be used when a function is renamed, to allow
- temporary use of the previous name, for backward compatibility.
-
-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 })
-```
\ No newline at end of file
diff --git a/docs/core/index.md b/docs/core/index.md
deleted file mode 100644
index b08a5738f9..0000000000
--- a/docs/core/index.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-layout: default
----
-
-
-
-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)`.
-
-
-
-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.html).
diff --git a/docs/core/serialization.md b/docs/core/serialization.md
deleted file mode 100644
index 9b1b7520f9..0000000000
--- a/docs/core/serialization.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-layout: default
----
-
-
-
-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))
-}
-```
diff --git a/docs/custom_bundling.md b/docs/custom_bundling.md
deleted file mode 100644
index d30bb7e33e..0000000000
--- a/docs/custom_bundling.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-layout: default
----
-
-
-
-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 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.
-
-
-
-
-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 where just the JavaScript `number` type
-suffices, 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, number-only implementations of functions
-import { create, all } from 'mathjs/number'
-
-const math = create(all)
-console.log(math.add(2, 3)) // 5
-```
-
-
-
-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).
diff --git a/docs/datatypes/bigints.md b/docs/datatypes/bigints.md
deleted file mode 100644
index 3e9bcf7ca0..0000000000
--- a/docs/datatypes/bigints.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-layout: default
----
-
-
-
-A bigint can be created either by adding the suffix `n` to a `number`, using the `BigInt` constructor function, or using the util function `math.bigint`:
-
-```js
-42n
-BigInt('42')
-math.bigint('42')
-```
-
-Most functions can determine the type of output from the type of input:
-a `number` as input will return a `number` as output, a `bigint` as input returns
-a `bigint` 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
-`bigint` instead of [numbers](numbers.html) by default, configure math.js like:
-
-```js
-math.config({
- number: 'bigint'
-})
-
-// use math
-math.evaluate('70000000000000000123') // bigint 70000000000000000123n
-```
-
-
-
-All basic arithmetic functions in math.js support `bigint`. Since `bigint` can only hold integer values, it is not applicable to for example trigonometric functions. When using a `bigint` in a function that does not support it, like `sqrt`, it will convert the `bigint` into a regular `number` and then execute the function:
-
-```js
-math.sin(2n) // number 0.9092974268256817
-```
-
-
-
-There are utility functions to convert a `bigint` into a `number` or `BigNumber`:
-
-```js
-// convert a number to bigint or BigNumber
-math.bigint(42) // bigint, 42n
-math.bignumber(42) // BigNumber, 42
-
-// convert a bigint to a number or BigNumber
-math.number(42n) // number, 42
-math.bignumber(42n) // BigNumber, 42
-
-// losing digits when converting to number
-math.number(70000000000000000123n) // number, 7000000000000000000
-```
diff --git a/docs/datatypes/bignumbers.md b/docs/datatypes/bignumbers.md
deleted file mode 100644
index 1d97d2f734..0000000000
--- a/docs/datatypes/bignumbers.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-layout: default
----
-
-
-
-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/).
-
-
-
-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.html) 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
- relTol: 1e-60,
- absTol: 1e-63
-})
-
-// 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`.
-
-Note that we also change the configuration of `relTol` and `absTol`
-to be close to the precision limit of our BigNumbers. `relTol` and `absTol` are used for
-example in relational and rounding functions (`equal`, `larger`, `smaller`,
-`round`, `floor`, etc) to determine when a value is nearly equal,
-see [Equality](numbers.html#equality). If we would leave `relTol` and `absTol` unchanged,
-having the default value of `1e-12` and `1e-15` respectively, we could get inaccurate and misleading
-results since we're now working with a higher precision.
-
-
-
-
-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
-```
-
-
-
-
-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
-```
-
-
-
-
-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
-```
diff --git a/docs/datatypes/complex_numbers.md b/docs/datatypes/complex_numbers.md
deleted file mode 100644
index 37d98564bd..0000000000
--- a/docs/datatypes/complex_numbers.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-layout: default
----
-
-
-
-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.
-
-
-
-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
-```
-
-
-
-Test whether a complex number equals another complex value.
-
- Two complex numbers are equal when both their real and imaginary parts are
- equal.
-
-
-
-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.html).
-
-
-
-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.
-
-
-
-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.html).
-
-
-
-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
-```
diff --git a/docs/datatypes/fractions.md b/docs/datatypes/fractions.md
deleted file mode 100644
index 2701a54b37..0000000000
--- a/docs/datatypes/fractions.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-layout: default
----
-
-
-
-For calculations with fractions, math.js supports a `Fraction` data type.
-Fraction support is powered by [fraction.js](https://github.com/rawify/Fraction.js).
-Unlike [numbers](numbers.html) and [BigNumbers](./bignumbers.html), 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)`.
-
-
-
-
-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.html) 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
-```
-
-
-
-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
-```
diff --git a/docs/datatypes/index.md b/docs/datatypes/index.md
deleted file mode 100644
index c2c67e64d8..0000000000
--- a/docs/datatypes/index.md
+++ /dev/null
@@ -1,76 +0,0 @@
----
-layout: default
----
-
-
-
-Math.js supports multi dimensional matrices and arrays. Matrices can be
-created, manipulated, and used in calculations. Both regular JavaScript
-arrays as well as the matrix type implemented by math.js can be used
-interchangeably in all relevant math.js functions. math.js supports both
-dense and sparse matrices.
-
-
-
-
-Math.js supports two types of matrices:
-
-- `Array`, a regular JavaScript array. A multi dimensional array can be created
- by nesting arrays.
-- `Matrix`, a matrix implementation by math.js. A `Matrix` is an object wrapped
- around a regular JavaScript `Array`, providing utility functions for easy
- matrix manipulation such as `subset`, `size`, `resize`, `clone`, and more.
-
-In most cases, the type of matrix output from functions is determined by the
-function input: An `Array` as input will return an `Array`, a `Matrix` as input
-will return a `Matrix`. In case of mixed input, a `Matrix` is returned.
-For functions where the type of output cannot be determined from the
-input, the output is determined by the configuration option `matrix`,
-which can be a string `'Matrix'` (default) or `'Array'`.
-
-```js
-// create an array and a matrix
-const array = [[2, 0], [-1, 3]] // Array
-const matrix = math.matrix([[7, 1], [-2, 3]]) // Matrix
-
-// perform a calculation on an array and matrix
-math.map(array, math.square) // Array, [[4, 0], [1, 9]]
-math.map(matrix, math.square) // Matrix, [[49, 1], [4, 9]]
-
-// perform calculations with mixed array and matrix input
-math.add(array, matrix) // Matrix, [[9, 1], [-3, 6]]
-math.multiply(array, matrix) // Matrix, [[14, 2], [-13, 8]]
-
-// create a matrix. Type of output of function ones is determined by the
-// configuration option `matrix`
-math.ones(2, 3) // Matrix, [[1, 1, 1], [1, 1, 1]]
-```
-
-
-
-
-A matrix can be created from an array using the function `math.matrix`. The
-provided array can contain nested arrays in order to create a multi-dimensional matrix. When called without arguments, an empty matrix will be
-created.
-
-```js
-// create matrices
-math.matrix() // Matrix, size [0]
-math.matrix([0, 1, 2]) // Matrix, size [3]
-math.matrix([[0, 1], [2, 3], [4, 5]]) // Matrix, size [3, 2]
-```
-
-Math.js supports regular Arrays. Multiple dimensions can be created
-by nesting Arrays in each other.
-
-```js
-// create arrays
-[] // Array, size [0]
-[0, 1, 2] // Array, size [3]
-[[0, 1], [2, 3], [4, 5]] // Array, size [3, 2]
-```
-
-Matrices can contain different types of values: numbers, complex numbers,
-units, or strings. Different types can be mixed together in a single matrix.
-
-```js
-// create a matrix with mixed types
-const a = math.matrix([2.3, 'hello', math.complex(3, -4), math.unit('5.2 mm')])
-a.subset(math.index(1)) // 'hello'
-```
-
-
-There are a number of functions to create a matrix with a specific size and
-content: `ones`, `zeros`, `identity`.
-
-```js
-// zeros creates a matrix filled with zeros
-math.zeros(3) // Matrix, size [3], [0, 0, 0]
-math.zeros(3, 2) // Matrix, size [3, 2], [[0, 0], [0, 0], [0, 0]]
-math.zeros(2, 2, 2) // Matrix, size [2, 2, 2],
- // [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
-
-// ones creates a matrix filled with ones
-math.ones(3) // Matrix, size [3], [1, 1, 1]
-math.multiply(math.ones(2, 2), 5) // Matrix, size [2, 2], [[5, 5], [5, 5]]
-
-// identity creates an identity matrix
-math.identity(3) // Matrix, size [3, 3], [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
-math.identity(2, 3) // Matrix, size [2, 3], [[1, 0, 0], [0, 1, 0]]
-```
-
-
-The functions `ones`, `zeros`, and `identity` also accept a single array
-or matrix containing the dimensions for the matrix. When the input is an Array,
-the functions will output an Array. When the input is a Matrix, the output will
-be a Matrix. Note that in case of numbers as arguments, the output is
-determined by the option `matrix` as discussed in section
-[Arrays and matrices](#arrays-and-matrices).
-
-```js
-// Array as input gives Array as output
-math.ones([2, 3]) // Array, size [3, 2], [[1, 1, 1], [1, 1, 1]]
-math.ones(math.matrix([2, 3])) // Matrix, size [3, 2], [[1, 1, 1], [1, 1, 1]]
-```
-
-Ranges can be created using the function `range`. The function `range` is
-called with parameters start and end, and optionally a parameter step.
-The start of the range is included, the end of the range is excluded.
-
-```js
-math.range(0, 4) // [0, 1, 2, 3]
-math.range(0, 8, 2) // [0, 2, 4, 6]
-math.range(3, -1, -1) // [3, 2, 1, 0]
-```
-
-
-
-
-Most functions of math.js support matrices and arrays. Unary functions can be applied element-wise using via `math.map(matrix, function)`.
-
-```js
-// perform an element-wise operation on a matrix using math.map
-const a = math.matrix([1, 4, 9, 16, 25]) // Matrix, [1, 4, 9, 16, 25]
-math.map(a, math.sqrt) // Matrix, [1, 2, 3, 4, 5]
-
-// use a function that has built-in matrix and array support
-const b = [1, 2, 3, 4, 5]
-math.factorial(b) // Array, [1, 2, 6, 24, 120]
-
-// multiply an array with a matrix
-const c = [[2, 0], [-1, 3]] // Array
-const d = math.matrix([[7, 1], [-2, 3]]) // Matrix
-math.multiply(c, d) // Matrix, [[14, 2], [-13, 8]]
-
-// add a number to a matrix (see broadcasting)
-math.add(c, 2) // Array, [[4, 2], [1, 5]]
-
-// calculate the determinant of a matrix
-math.det(c) // 6
-math.det(d) // 23
-```
-
-
-Functions that require two or more matrix like arguments that operate elementwise automatically operate as if the arguments were the same size.
-
-```js
-A = math.matrix([1, 2]) // Matrix, [1, 2]
-math.add(A, 3) // Matrix, [3, 4]
-
-B = math.matrix([[3], [4]]) // Matrix, [[3], [4]]
-math.add(A, B) // Matrix, [[4, 5], [5, 6]]
-```
-Any index that is in one of the arguments, can be found as if it existed on the others when the size on that dimension is one or not existing. This is valid in N dimensions.
-
-It's not possible to broadcast in cases where the size in that dimension is higher than one.
-
-```js
-math.add([1, 2], [3, 4, 5])
-// Error: shape missmatch: missmatch is found in arg with shape (2) not possible to broadcast dimension 0 with size 2 to size 3
-
-math.add([[1], [2], [3]], [[4], [5]])
-// Error: shape missmatch: missmatch is found in arg with shape (2,1) not possible to broadcast dimension 0 with size 2 to size 3
-```
-
-
-
-Math.js uses geometric dimensions:
-
-- A scalar is zero-dimensional.
-- A vector is one-dimensional.
-- A matrix is two or multi-dimensional.
-
-The size of a matrix can be calculated with the function `size`. Function `size`
-returns a `Matrix` or `Array`, depending on the configuration option `matrix`.
-Furthermore, matrices have a function `size` as well, which always returns
-an Array.
-
-```js
-// get the size of a scalar
-math.size(2.4) // Matrix, []
-math.size(math.complex(3, 2)) // Matrix, []
-math.size(math.unit('5.3 mm')) // Matrix, []
-
-// get the size of a one-dimensional matrix (a vector) and a string
-math.size([0, 1, 2, 3]) // Array, [4]
-math.size('hello world') // Matrix, [11]
-
-// get the size of a two-dimensional matrix
-const a = [[0, 1, 2, 3]] // Array
-const b = math.matrix([[0, 1, 2], [3, 4, 5]]) // Matrix
-math.size(a) // Array, [1, 4]
-math.size(b) // Matrix, [2, 3]
-
-// matrices have a function size (always returns an Array)
-b.size() // Array, [2, 3]
-
-// get the size of a multi-dimensional matrix
-const c = [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
-math.size(c) // Array, [2, 2, 3]
-```
-
-Note that the dimensions themselves do not have a meaning attached.
-When creating and printing a two dimensional matrix, the first dimension is
-normally rendered as the _column_, and the second dimension is rendered as
-the _row_. For example:
-
-```js
-console.table(math.zeros([2, 4]))
-// 0 0 0 0
-// 0 0 0 0
-```
-
-If you have a matrix where the first dimension means `x` and the second
-means `y`, this will look confusing since `x` is printed as _column_
-(vertically) and `y` as _row_ (horizontally).
-
-
-
-
-Matrices can be resized using their `resize` function. This function is called
-with an Array with the new size as the first argument, and accepts an optional
-default value. By default, new entries will be set to `0`, but it is possible
-to pass a different default value like `null` to clearly indicate that
-the entries haven't been explicitly set.
-
-```js
-const a = math.matrix() // Matrix, size [0], []
-a.resize([2, 3]) // Matrix, size [2, 3], [[0, 0, 0], [0, 0, 0]]
-a.resize([2, 2, 2]) // Matrix, size [2, 2, 2],
- // [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
-
-const b = math.matrix()
-b.resize([3], 7) // Matrix, size [3], [7, 7, 7]
-b.resize([5], 9) // Matrix, size [5], [7, 7, 7, 9, 9]
-b.resize([2]) // Matrix, size [2], [7, 7]
-```
-
-
-Outer dimensions of a matrix can be squeezed using the function `squeeze`. When
-getting or setting a single value in a matrix using `subset`, the value is automatically squeezed
-or unsqueezed too.
-
-```js
-// squeeze a matrix
-const a = [[[0, 1, 2]]]
-math.squeeze(a) // [0, 1, 2]
-math.squeeze([[3]]) // 3
-
-// when getting/setting a single value in a matrix using subset,
-// it automatically squeeze/unsqueeze the value
-const b = math.matrix([[0, 1], [2, 3]])
-b.subset(math.index(1, 0)) // 2 and not [[2]]
-```
-
-
-
-
-Subsets of a matrix can be retrieved or replaced using the function `subset`.
-Matrices have a `subset` function, which is applied to the matrix itself:
-`Matrix.subset(index [, replacement])`. For both matrices and arrays,
-the static function `subset(matrix, index [, replacement])` can be used.
-When parameter `replacement` is provided, the function will replace a subset
-in the matrix, and if not, a subset of the matrix will be returned.
-
-A subset can be defined using an `Index`. An `Index` contains a single value
-or a set of values for each dimension of a matrix. An `Index` can be
-created using the function `index`. When getting a single value from a matrix,
-`subset` will return the value itself instead of a matrix containing just this
-value.
-
-The function `subset` normally returns a subset, but when getting or setting a
-single value in a matrix, the value itself is returned.
-
-
-Matrix indexes in math.js are zero-based, like most programming languages
-including JavaScript itself. Note that mathematical applications like Matlab
-and Octave work differently, as they use one-based indexes.
-
-```js
-// create some matrices
-const a = [0, 1, 2, 3]
-const b = [[0, 1], [2, 3]]
-const c = math.zeros(2, 2)
-const d = math.matrix([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
-const e = math.matrix()
-
-// get a subset
-math.subset(a, math.index(1)) // 1
-math.subset(a, math.index([2, 3])) // Array, [2, 3]
-math.subset(a, math.index(math.range(0,4))) // Array, [0, 1, 2, 3]
-math.subset(b, math.index(1, 0)) // 2
-math.subset(b, math.index(1, [0, 1])) // Array, [2, 3]
-math.subset(b, math.index([0, 1], 0)) // Matrix, [[0], [2]]
-
-// get a subset
-d.subset(math.index([1, 2], [0, 1])) // Matrix, [[3, 4], [6, 7]]
-d.subset(math.index(1, 2)) // 5
-
-// replace a subset. The subset will be applied to a clone of the matrix
-math.subset(b, math.index(1, 0), 9) // Array, [[0, 1], [9, 3]]
-math.subset(b, math.index(2, [0, 1]), [4, 5]) // Array, [[0, 1], [2, 3], [4, 5]]
-
-// replace a subset. The subset will be applied to the matrix itself
-c.subset(math.index(0, 1),1) // Matrix, [[0, 1], [0, 0]]
-c.subset(math.index(1, [0, 1]), [2, 3]) // Matrix, [[0, 1], [2, 3]]
-e.resize([2, 3], 0) // Matrix, [[0, 0, 0], [0, 0, 0]]
-e.subset(math.index(1, 2), 5) // Matrix, [[0, 0, 0], [0, 0, 5]]
-```
-
-
-
-There are two methods available on matrices that allow to get or set a single
-value inside a matrix. It is important to note that the `set` method will
-mutate the matrix.
-
-```js
-const p = math.matrix([[1, 2], [3, 4]])
-p.set([0, 1], 5)
-// p is now [[1, 5], [3, 4]]
-p.get([1, 0]) // 3
-```
-
-When setting a value at a location outside of the current matrix size using the
-method `.set()`, the matrix will be resized. By default, new items will be
-initialized with zero, but it is possible to specify an alternative value using
-the optional third argument `defaultValue`.
-
-
-
-Boolean array indexing is a technique that allows you to filter, replace, and set values in an array based on logical conditions. This can be done by creating a boolean array that represents the desired conditions, and then using that array as an index to select the elements of the original array that meet those conditions.
-
-For example, a boolean array can be created to represent all the even numbers in an array, and then used to filter the original array to only include the even numbers. Alternatively, a boolean array can be created to represent all the elements of an array that are greater than a certain value, and then used to replace all the elements of the original array that are greater than that value with a new value.
-
-
-```js
-const q = [1, 2, 3, 4]
-math.subset(q, math.index([true, false, true, false])) // Array [1, 3]
-
-// filtering
-math.subset(q, math.index(math.larger(q, 2))) // Array [3, 4]
-
-// filtering with no matches
-math.subset(q, math.index(math.larger(q, 5))) // Array []
-
-// setting specific values, please note that the replacement value is broadcasted
-q = math.subset(q, math.index(math.smaller(q, 3)), 0) // q = [0, 0, 3, 4]
-
-// replacing specific values
-math.subset(q, math.index(math.equal(q, 0)), [1, 2]) // q = [1, 2, 3, 4]
-```
-
-The same can be accomplished in the parser in a much more compact manner. Please note that everything after `#` are comments.
-```js
-math.evaluate(`
-q = [1, 2, 3, 4]
-q[[true, false, true, false]] # Matrix [1, 3]
-q[q>2] # Matrix [3, 4]
-q[q>5] # Matrix []
-q[q <3] = 0 # q = [0, 0, 3, 4]
-q[q==0] = [1, 2] # q = [1, 2, 3, 4]
-`)
-```
-The expression inside the index can be as complex as needed as long it evaluates to an array of booleans of the same size.
-```js
-math.evaluate(`
-q = [1, 2, 3, 4]
-r = [6, 5, 4, 3]
-q[q > 3 and r < 4] # [4]
-`)
-```
-
-
-
-Matrices contain functions `map` and `forEach` to iterate over all elements of
-the (multidimensional) matrix. The callback function of `map` and `forEach` has
-three parameters: `value` (the value of the currently iterated element),
-`index` (an array with the index value for each dimension), and `matrix` (the
-matrix being iterated). This syntax is similar to the `map` and `forEach`
-functions of native JavaScript Arrays, except that the index is no number but
-an Array with numbers for each dimension.
-
-```js
-const a = math.matrix([[0, 1], [2, 3], [4, 5]])
-
-// The iteration below will output the following in the console:
-// value: 0 index: [0, 0]
-// value: 1 index: [0, 1]
-// value: 2 index: [1, 0]
-// value: 3 index: [1, 1]
-// value: 4 index: [2, 0]
-// value: 5 index: [2, 1]
-a.forEach(function (value, index, matrix) {
- console.log('value:', value, 'index:', index)
-})
-
-// Apply a transformation on the matrix
-const b = a.map(function (value, index, matrix) {
- return math.multiply(math.sin(value), math.exp(math.abs(value)))
-})
-console.log(b.format(5)) // [[0, 2.2874], [6.7188, 2.8345], [-41.32, -142.32]]
-
-// Create a matrix with the cumulative of all elements
-let count = 0
-const cum = a.map(function (value, index, matrix) {
- count += value
- return count
-})
-console.log(cum.toString()) // [[0, 1], [3, 6], [10, 15]]
-```
-
-
-
-You can iterate over multiple matrices or arrays by using the `map` function. Mapping allows to perform element-wise operations on matrices by automatically adjusting their sizes to match each other.
-
-To iterate over multiple matrices, you can use the `map` function. The `map` function applies a given function to each element of the matrices and returns a new matrix with the results.
-
-Here's an example of iterating over two matrices and adding their corresponding elements:
-
-```js
-const a = math.matrix([[1, 2], [3, 4]]);
-const b = math.matrix([[5, 6], [7, 8]]);
-
-const result = math.map(a, b, (x, y) => x + y);
-
-console.log(result); // [[6, 8], [10, 12]]
-```
-
-In this example, the `map` function takes matrices as the first two arguments and a callback function `(x, y) => x + y` as the third argument. The callback function is applied to each element of the matrices, where `x` represents the corresponding element from matrix `a` and `y` represents the corresponding element from matrix `b`. The result is a new matrix with the element-wise sum of the two matrices.
-
-By using broadcasting and the `map` function, you can easily iterate over multiple matrices and perform element-wise operations.
-
-```js
-const a = math.matrix([10, 20])
-const b = math.matrix([[3, 4], [5, 6]])
-
-const result = math.map(a, b, (x, y) => x + y)
-console.log(result); // [[13, 24], [15, 26]]
-```
-
-It's also possible to provide a callback with an index and the broadcasted arrays. Like `(valueA, valueB, index)` or even `(valueA, valueB, index, broadcastedMatrixA, broadcastedMatrixB)`. There is no specific limit for the number of matrices `N` that can be mapped. Thus, the callback can have `N` arguments, `N+1` arguments in the case of including the index, or `2N+1` arguments in the case of including the index and the broadcasted matrices in the callback.
-
-At this moment `forEach` doesn't include the same functionality.
-
-
-
-Math.js supports both dense matrices as well as sparse matrices. Sparse matrices are efficient for matrices largely containing zeros. In that case they save a lot of memory, and calculations can be much faster than for dense matrices.
-
-Math.js supports two type of matrices:
-
-- Dense matrix (`'dense'`, `default`) A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
-- Sparse matrix (`'sparse'`): A two dimensional sparse matrix implementation.
-
-The type of matrix can be selected when creating a matrix using the construction functions `matrix`, `diag`, `identity`, `ones`, and `zeros`.
-
-```js
-// create sparse matrices
-const m1 = math.matrix([[0, 1], [0, 0]], 'sparse')
-const m2 = math.identity(1000, 1000, 'sparse')
-```
-
-You can also coerce an array or matrix into sparse storage format with the
-`sparse` function.
-```js
-const md = math.matrix([[0, 1], [0,0]]) // dense
-const ms = math.sparse(md) // sparse
-```
-
-Caution: `sparse` called on a JavaScript array of _n_ plain numbers produces
-a matrix with one column and _n_ rows -- in contrast to `matrix`, which
-produces a 1-dimensional matrix object with _n_ entries, i.e., a vector
-(_not_ a 1 by _n_ "row vector" nor an _n_ by 1 "column vector", but just a plain
-vector of length _n_).
-```js
-const mv = math.matrix([0, 0, 1]) // Has size [3]
-const mc = math.sparse([0, 0, 1]) // A "column vector," has size [3, 1]
-```
-
-
-
-All relevant functions in math.js support Matrices and Arrays. Functions like `math.add` and `math.subtract`, `math.sqrt` handle matrices element wise. There is a set of functions specifically for creating or manipulating matrices, such as:
-
-- Functions like `math.matrix` and `math.sparse`, `math.ones`, `math.zeros`, and `math.identity` to create a matrix.
-- Functions like `math.subset` and `math.index` to get or replace a part of a matrix
-- Functions like `math.transpose` and `math.diag` to manipulate matrices.
-
-A full list of matrix functions is available on the [functions reference page](../reference/functions.html#matrix-functions).
-
-Two types of matrix classes are available in math.js, for storage of dense and sparse matrices. Although they contain public functions documented as follows, using the following API directly is *not* recommended. Prefer using the functions in the "math" namespace wherever possible.
-
-- [DenseMatrix](../reference/classes/densematrix.html)
-- [SparseMatrix](../reference/classes/sparsematrix.html)
diff --git a/docs/datatypes/numbers.md b/docs/datatypes/numbers.md
deleted file mode 100644
index cb583bb4b3..0000000000
--- a/docs/datatypes/numbers.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-layout: default
----
-
-
-
-Math.js supports three types of numbers:
-
-- Number for fast floating point arithmetic, described on this page.
-- BigNumber for arbitrary precision arithmetic, described on the page
- [BigNumbers](bignumbers.html).
-- Fraction, which stores numbers in terms of a numerator and denominators,
- described on the page [Fractions](fractions.html).
-
-
-
-
-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, which
-can be configured when instantiating math.js:
-
-```js
-math.config({
- number: 'number' // Default type of number:
- // 'number' (default), 'BigNumber', or 'Fraction'
-})
-```
-
-
-
-Math.js uses the built-in JavaScript Number type. A Number is a floating point
-number with a limited precision of 64 bits, about 16 digits. The largest integer
-number which can be represented by a JavaScript Number
-is `+/- 9007199254740992` (`+/- 2^53`). Because of the limited precision of
-floating point numbers round-off errors can occur during calculations.
-This can be easily demonstrated:
-
-```js
-// a round-off error
-0.1 + 0.2 // 0.30000000000000004
-math.add(0.1, 0.2) // 0.30000000000000004
-```
-
-In most cases, round-off errors don't matter: they have no significant
-impact on the results. However, it looks ugly when displaying output to a user.
-A solution is to limit the precision just below the actual precision of 16
-digits in the displayed output:
-
-```js
-// prevent round-off errors showing up in output
-const ans = math.add(0.1, 0.2) // 0.30000000000000004
-math.format(ans, {precision: 14}) // '0.3'
-```
-
-Alternatives are to use [Fractions](fractions.html) which store a number as a numerator and denominator, [BigNumbers](bignumbers.html) which store a number with a higher precision, or [bigint](bigints.html) which can store larger integer numbers.
-
-
-
-
-A Number can store values between `5e-324` and `1.7976931348623157e+308`.
-Values smaller than the minimum are stored as `0`, and values larger than the
-maximum are stored as `+/- Infinity`.
-
-```js
-// exceeding the maximum and minimum number
-console.log(1e309) // Infinity
-console.log(1e-324) // 0
-```
-
-
-
-Because of rounding errors in calculations, it is unsafe to compare JavaScript
-Numbers. For example executing `0.1 + 0.2 == 0.3` in JavaScript will return
-false, as the addition `0.1 + 0.2` introduces a round-off error and does not
-return exactly `0.3`.
-
-To solve this problem, the relational functions of math.js check whether the
-relative and absolute differences between the compared values is smaller than the configured
-option `relTol` and `absTol`. In pseudo code (without exceptions for 0, Infinity and NaN):
-
- abs(a-b) <= max(relTol * max(abs(a), abs(b)), absTol)
-
-where:
-
- - `relTol` is the relative tolerance between x and y and `absTol` the absolute tolerance. Relative tolerance and absolute tolerance are configurable and are `1e-12` and `1e-15` respectively by default. See [Configuration](../core/configuration.html).
- - `DBL_EPSILON` is the minimum positive floating point number such that
- `1.0 + DBL_EPSILON !== 1.0`. This is a constant with a value of approximately
- `2.2204460492503130808472633361816e-16`.
-
-Note that the relational functions cannot be used to compare small values
-(`< 2.22e-16`). These values are all considered equal to zero.
-
-Examples:
-
-```js
-// compare values having a round-off error
-console.log(0.1 + 0.2 === 0.3) // false
-console.log(math.equal(0.1 + 0.2, 0.3)) // true
-
-// small values (< 2.22e-16) cannot be compared
-console.log(3e-20 === 3.1e-20) // false
-console.log(math.equal(3e-20, 3.1e-20)) // true
-```
-
-The available relational functions are: `compare`, `equal`, `larger`,
-`largerEq`, `smaller`, `smallerEq`, `unequal`.
diff --git a/docs/datatypes/units.md b/docs/datatypes/units.md
deleted file mode 100644
index f6a8a0b6e1..0000000000
--- a/docs/datatypes/units.md
+++ /dev/null
@@ -1,489 +0,0 @@
----
-layout: default
----
-
-
-
-Units can be created using the function `math.unit`. This function accepts
-either a single string argument containing a value and unit, or two arguments,
-the first being a numeric value and the second a string containing a unit.
-Most units support prefixes like `k` or `kilo`, and many units have both a
-full name and an abbreviation. The returned object is a `Unit`.
-
-Syntax:
-
-```js
-math.unit(value: number, valuelessUnit: string) : Unit
-math.unit(value: number, valuelessUnit: Unit) : Unit
-math.unit(unit: string) : Unit
-math.unit(unit: Unit) : Unit
-```
-
-Example usage:
-
-```js
-const a = math.unit(45, 'cm') // Unit 450 mm
-const b = math.unit('0.1 kilogram') // Unit 100 gram
-const c = math.unit('2 inch') // Unit 2 inch
-const d = math.unit('90 km/h') // Unit 90 km/h
-const e = math.unit('101325 kg/(m s^2)') // Unit 101325 kg / (m s^2)
-
-const f = c.to('cm') // Unit 5.08 cm
-b.toNumber('gram') // Number 100
-math.number(b, 'gram') // Number 100
-
-c.equals(a) // false
-c.equals(f) // true
-c.equalBase(a) // true
-c.equalBase(b) // false
-
-f.toString() // String "5.08 cm"
-
-const kph = math.unit('km/h') // valueless Unit km/h
-const mps = math.unit('m/s') // valueless Unit m/s
-const speed = math.unit(36, kph) // Unit 36 km/h
-speed.toNumber(mps) // Number 10
-```
-
-Use care when creating a unit with multiple terms in the denominator. Implicit multiplication has the same operator precedence as explicit multiplication and division, which means these three expressions are identical:
-
-```js
-// These three are identical
-const correct1 = math.unit('8.314 m^3 Pa / mol / K') // Unit 8.314 (m^3 Pa) / (mol K)
-const correct2 = math.unit('8.314 (m^3 Pa) / (mol K)') // Unit 8.314 (m^3 Pa) / (mol K)
-const correct3 = math.unit('8.314 (m^3 * Pa) / (mol * K)') // Unit 8.314 (m^3 Pa) / (mol K)
-```
-But this expression, which omits the second `/` between `mol` and `K`, results in the wrong value:
-
-```js
-// Missing the second '/' between 'mol' and 'K'
-const incorrect = math.unit('8.314 m^3 Pa / mol K') // Unit 8.314 (m^3 Pa K) / mol
-```
-
-The function `math.unit` has its own small parser. This parser differs a bit from the expression parser `math.evaluate`, and returns the expected result in this case:
-
-```js
-// using math.evaluate instead of math.unit
-const correct4 = math.evaluate('8.314 (m^3 * Pa) / (mol * K)') // Unit 8.314 (m^3 Pa) / (mol K)
-```
-
-In summary: be careful with implicit multiplication. In case of doubt, always use an explicit `*` and parenthesis.
-
-
-
-
-The operations that support units are `add`, `subtract`, `multiply`, `divide`, `pow`, `abs`, `sqrt`, `square`, `cube`, and `sign`.
-Trigonometric functions like `cos` are also supported when the argument is an angle.
-
-```js
-const a = math.unit(45, 'cm') // Unit 450 mm
-const b = math.unit('0.1m') // Unit 100 mm
-math.add(a, b) // Unit 0.55 m
-math.multiply(b, 2) // Unit 200 mm
-
-const c = math.unit(45, 'deg') // Unit 45 deg
-math.cos(c) // Number 0.7071067811865476
-
-// Kinetic energy of average sedan on highway
-const d = math.unit('80 mi/h') // Unit 80 mi/h
-const e = math.unit('2 tonne') // Unit 2 tonne
-const f = math.multiply(0.5, math.multipy(math.pow(d, 2), e))
- // 1.2790064742399996 MJ
-```
-
-Operations with arrays are supported too:
-
-```js
-// Force on a charged particle moving through a magnetic field
-const B = math.evaluate('[1, 0, 0] T') // [1 T, 0 T, 0 T]
-const v = math.evaluate('[0, 1, 0] m/s') // [0 m / s, 1 m / s, 0 m / s]
-const q = math.evaluate('1 C') // 1 C
-
-const F = math.multiply(q, math.cross(v, B)) // [0 N, 0 N, -1 N]
-```
-
-All arithmetic operators act on the value of the unit as it is represented in SI units.
-This may lead to surprising behavior when working with temperature scales like `celsius` (or `degC`) and `fahrenheit` (or `degF`).
-In general, you should avoid calculations using `celsius` and `fahrenheit`. Rather, use `kelvin` (or `K`) and `rankine` (or `degR`) instead.
-This example highlights some problems when using `celsius` and `fahrenheit` in calculations:
-
-```js
-const T_14F = math.unit('14 degF') // Unit 14 degF (263.15 K)
-const T_28F = math.multiply(T_14F, 2) // Unit 28 degF (270.93 K), not 526.3 K
-
-const Tnegative = math.unit(-13, 'degF') // Unit -13 degF (248.15 K)
-const Tpositive = math.abs(Tnegative) // Unit -13 degF (248.15 K), not 13 degF
-```
-
-The expression parser supports units too. This is described in the section about
-units on the page [Syntax](../expressions/syntax.html#units).
-
-
-
-You can add your own units to Math.js using the `math.createUnit` function. The following example defines a new unit `furlong`, then uses the user-defined unit in a calculation:
-
-```js
-math.createUnit('furlong', '220 yards')
-math.evaluate('1 mile to furlong') // 8 furlong
-```
-
-If you cannot express the new unit in terms of any existing unit, then the second argument can be omitted. In this case, a new *base unit* is created:
-
-```js
-// A 'foo' cannot be expressed in terms of any other unit.
-math.createUnit('foo')
-math.evaluate('8 foo * 4 feet') // 32 foo feet
-```
-
-The second argument to `createUnit` can also be a configuration object consisting of the following properties:
-
-* **definition** A `string` or `Unit` which defines the user-defined unit in terms of existing built-in or user-defined units. If omitted, a new base unit is created.
-* **prefixes** A `string` indicating which prefixes math.js should use with the new unit. Possible values are `'none'`, `'short'`, `'long'`, `'binary_short'`, or `'binary_long'`. Default is `'none'`.
-* **offset** A value applied when converting to the unit. This is very helpful for temperature scales that do not share a zero with the absolute temperature scale. For example, if we were defining fahrenheit for the first time, we would use: `math.createUnit('fahrenheit', {definition: '0.555556 kelvin', offset: 459.67})`
-* **aliases** An array of strings to alias the new unit. Example: `math.createUnit('knot', {definition: '0.514444 m/s', aliases: ['knots', 'kt', 'kts']})`
-* **baseName** A `string` that specifies the name of the new dimension in case one needs to be created. Every unit in math.js has a dimension: length, time, velocity, etc. If the unit's `definition` doesn't match any existing dimension, or it is a new base unit, then `createUnit` will create a new dimension with the name `baseName` and assign it to the new unit. The default is to append `'_STUFF'` to the unit's name. If the unit already matches an existing dimension, this option has no effect.
-
-An optional `options` object can also be supplied as the last argument to `createUnits`. Currently only the `override` option is supported:
-
-```js
-// Redefine the mile (would not be the first time in history)
-math.createUnit('mile', '1609.347218694 m', {override: true})
-```
-Base units created without specifying a definition cannot be overridden.
-
-
-Multiple units can defined using a single call to `createUnit` by passing an object map as the first argument, where each key in the object is the name of a new unit and the value is either a string defining the unit, or an object with the configuration properties listed above. If the value is an empty string or an object lacking a definition property, a new base unit is created.
-
-For example:
-
-```js
-math.createUnit( {
- foo: {
- prefixes: 'long',
- baseName: 'essence-of-foo'
- },
- bar: '40 foo',
- baz: {
- definition: '1 bar/hour',
- prefixes: 'long'
- }
-},
-{
- override: true
-})
-math.evaluate('50000 kilofoo/s') // 4.5 gigabaz
-```
-
-
-`createUnit` returns the created unit, or, when multiple units are created, the last unit created. Since `createUnit` is also compatible with the expression parser, this allows you to do things like this:
-
-```js
-math.evaluate('45 mile/hour to createUnit("knot", "0.514444m/s")')
-// 39.103964668651976 knot
-```
-
-
-Per default, the name of a new unit:
-- should start by a latin (A-Z or a-z) character
-- should contain only numeric (0-9) or latin characters
-
-It is possible to allow the usage of special characters (such as Greek alphabet, cyrillic alphabet, any Unicode symbols, etc.) by overriding the `Unit.isValidAlpha` static method. For example:
-```js
-const isAlphaOriginal = math.Unit.isValidAlpha
-const isGreekLowercaseChar = function (c) {
- const charCode = c.charCodeAt(0)
- return charCode > 944 && charCode < 970
-}
-math.Unit.isValidAlpha = function (c) {
- return isAlphaOriginal(c) || isGreekLowercaseChar(c)
-}
-
-math.createUnit('θ', '1 rad')
-math.evaluate('1θ + 3 deg').toNumber('deg') // 60.29577951308232
-```
-
-
-
-The built-in units are always created with a value being a `number`. To turn the value into for example a `BigNumber` or `Fraction`, you can convert the value using the function `math.fraction` and `math.bignumber`:
-
-```js
-math.unit(math.fraction(10), 'inch').toNumeric('cm') // Fraction 127/5
-math.fraction(math.unit(10, 'inch')).toNumeric('cm') // Fraction 127/5
-
-math.bignumber(math.unit(10, 'inch')).toNumeric('cm') // BigNumber 25.4
-math.unit(math.bignumber(10), 'inch').toNumeric('cm') // BigNumber 25.4
-```
-
-When using the expression parser, it is possible to configure numeric values to be parsed as `Fraction` or `BigNumber`:
-
-```js
-math.config({ number: 'Fraction' })
-math.evaluate('10 inch').toNumeric('cm') // Fraction 127/5
-```
-
-
-
-Get a string representation of the unit. The function
-will determine the best fitting prefix for the unit. See the [Format](../reference/functions/format.html)
-page for available options.
-
-
-Revive a unit from a JSON object. Accepts
-An object `{mathjs: 'Unit', value: number, unit: string, fixPrefix: boolean}`,
-where the property `mathjs` and `fixPrefix` are optional.
-Used when deserializing a unit, see [Serialization](../core/serialization.html).
-
-
-Split a unit into the specified parts. For example:
-
-```js
-const u = math.unit(1, 'm')
-u.splitUnit(['ft', 'in']) // 3 feet,3.3700787401574765 inch
-```
-
-
-Returns a JSON representation of the unit, with signature
-`{mathjs: 'Unit', value: number, unit: string, fixPrefix: boolean}`.
-Used when serializing a unit, see [Serialization](../core/serialization.html).
-
-
-Get the value of a unit when converted to the
-specified unit (a unit with optional prefix but without value).
-The type of the returned value is always `number`.
-
-
-Get the value of a unit when converted to the
-specified unit (a unit with optional prefix but without value).
-The type of the returned value depends on how the unit was created and
-can be `number`, `Fraction`, or `BigNumber`.
-
-
-
-Math.js comes with the following built-in units.
-
-Base | Unit
-------------------- | ---
-Length | meter (m), inch (in), foot (ft), yard (yd), mile (mi), link (li), rod (rd), chain (ch), angstrom, mil
-Surface area | m2, sqin, sqft, sqyd, sqmi, sqrd, sqch, sqmil, acre, hectare
-Volume | m3, litre (l, L, lt, liter), cc, cuin, cuft, cuyd, teaspoon, tablespoon
-Liquid volume | minim, fluiddram (fldr), fluidounce (floz), gill (gi), cup (cp), pint (pt), quart (qt), gallon (gal), beerbarrel (bbl), oilbarrel (obl), hogshead, drop (gtt)
-Angles | rad (radian), deg (degree), grad (gradian), cycle, arcsec (arcsecond), arcmin (arcminute)
-Time | second (s, secs, seconds), minute (min, mins, minutes), hour (h, hr, hrs, hours), day (days), week (weeks), month (months), year (years), decade (decades), century (centuries), millennium (millennia)
-Frequency | hertz (Hz)
-Mass | gram(g), tonne, ton, grain (gr), dram (dr), ounce (oz), poundmass (lbm, lb, lbs), hundredweight (cwt), stick, stone
-Electric current | ampere (A)
-Temperature | kelvin (K), celsius (degC), fahrenheit (degF), rankine (degR)
-Amount of substance | mole (mol)
-Luminous intensity | candela (cd)
-Force | newton (N), dyne (dyn), poundforce (lbf), kip
-Energy | joule (J), erg, Wh, BTU, electronvolt (eV)
-Power | watt (W), hp
-Pressure | Pa, psi, atm, torr, bar, mmHg, mmH2O, cmH2O
-Electricity and magnetism | ampere (A), coulomb (C), watt (W), volt (V), ohm, farad (F), weber (Wb), tesla (T), henry (H), siemens (S), electronvolt (eV)
-Binary | bits (b), bytes (B)
-
-Note: all time units are based on the Julian year, with one month being 1/12th of a Julian year, a year being one Julian year, a decade being 10 Julian years, a century being 100, and a millennium being 1000.
-
-Note that all relevant units can also be written in plural form, for example `5 meters` instead of `5 meter` or `10 seconds` instead of `10 second`.
-
-Surface and volume units can alternatively be expressed in terms of length units raised to a power, for example `100 in^2` instead of `100 sqin`.
-
-
-
-Name | Symbol | Value | Unit
-----------------------|--------------------------------------------------------|-------------------|-------------------------------------------------------
-speedOfLight | c | 299792458 | m · s-1
-gravitationConstant | G | 6.6738480e-11 | m3 · kg-1 · s-2
-planckConstant | h | 6.626069311e-34 | J · s
-reducedPlanckConstant | h | 1.05457172647e-34 | J · s
-
-
-
-
-math.js has built-in support for symbolic computation ([CAS](https://www.wikiwand.com/en/Computer_algebra_system)). It can parse expressions into an expression tree and do algebraic operations like simplification and derivation on the tree.
-
-> It's worth mentioning an excellent extension on math.js here: [mathsteps](https://github.com/socraticorg/mathsteps), a step-by-step math solver library that is focused on pedagogy (how best to teach). The math problems it focuses on are pre-algebra and algebra problems involving simplifying expressions.
-
-
-
-
-The function [`math.simplify`](../reference/functions/simplify.html) simplifies an expression tree:
-
-```js
-// simplify an expression
-console.log(math.simplify('3 + 2 / 4').toString()) // '7 / 2'
-console.log(math.simplify('2x + 3x').toString()) // '5 * x'
-console.log(math.simplify('x^2 + x + 3 + x^2').toString()) // '2 * x ^ 2 + x + 3'
-console.log(math.simplify('x * y * -x / (x ^ 2)').toString()) // '-y'
-```
-
-The function accepts either a string or an expression tree (`Node`) as input, and outputs a simplified expression tree (`Node`). This node tree can be transformed and evaluated as described in detail on the page [Expression trees](expression_trees.html).
-
-```js
-// work with an expression tree, evaluate results
-const f = math.parse('2x + x')
-const simplified = math.simplify(f)
-console.log(simplified.toString()) // '3 * x'
-console.log(simplified.evaluate({x: 4})) // 12
-```
-
-Among its other actions, calling `simplify()` on an expression will convert
-any functions that have operator equivalents to their operator form:
-```js
-console.log(math.simplify('multiply(x,3)').toString) // '3 * x'
-```
-
-Note that `simplify` has an optional argument `scope` that allows the definitions of variables in the expression (as numeric values, or as further expressions) to be specified and used in the simplification, e.g. continuing the previous example,
-
-```js
-console.log(math.simplify(f, {x: 4}).toString()) // 12
-console.log(math.simplify(f, {x: math.parse('y+z')}).toString()) // '3*(y+z)'
-```
-
-In general, simplification is an inherently dfficult problem; in fact, for certain classes of expressions and algebraic equivalences, it is undecidable whether a given expression is equivalent to zero. Moreover, simplification generally depends on the properties of the operations involved; since multiplication (for example) may have different properties (e.g., it might or might not be commutative) depending on the domain under consideration, different simplifications might be appropriate.
-
-As a result, `simplify()` has an additional optional argument, `options`, which controls its behavior. This argument is an object specifying any of various properties concerning the simplification process. See the [detailed documentation](../reference/functions/simplify.html) for a complete list, but currently the two most important properties are as follows. Note that the `options` argument may only be specified if the `scope` is as well.
-
-- `exactFractions` - a boolean which specifies whether non-integer numerical constants should be simplified to rational numbers when possible (true), or always converted to decimal notation (false).
-- `context` - an object whose keys are the names of operations ('add', 'multiply', etc.) and whose values specify algebraic properties of the corresponding operation (currently any of 'total', 'trivial', 'commutative', and 'associative'). Simplifications will only be performed if the properties they rely on are true in the given context. For example,
-```js
-const expr = math.parse('x*y-y*x')
-console.log(math.simplify(expr).toString()) // 0; * is commutative by default
-console.log(math.simplify(expr, {}, {context: {multiply: {commutative: false}}}))
- // 'x*y-y*x'; the order of the right multiplication can't be reversed.
-```
-
-Note that the default context is very permissive (allows a lot of simplifications) but that there is also a `math.simplify.realContext` that only allows simplifications that are guaranteed to preserve the value of the expression on all real numbers:
-```js
-const rational = math.parse('(x-1)*x/(x-1)')
-console.log(math.simplify(expr, {}, {context: math.simplify.realContext})
- // '(x-1)*x/(x-1)'; canceling the 'x-1' makes the expression defined at 1
-```
-
-For more details on the theory of expression simplification, see:
-
-- [Strategies for simplifying math expressions (Stackoverflow)](https://stackoverflow.com/questions/7540227/strategies-for-simplifying-math-expressions)
-- [Symbolic computation - Simplification (Wikipedia)](https://en.wikipedia.org/wiki/Symbolic_computation#Simplification)
-
-
-
-
-The function [`math.derivative`](../reference/functions/derivative.html) finds the symbolic derivative of an expression:
-
-```js
-// calculate a derivative
-console.log(math.derivative('2x^2 + 3x + 4', 'x').toString()) // '4 * x + 3'
-console.log(math.derivative('sin(2x)', 'x').toString()) // '2 * cos(2 * x)'
-```
-
-Similar to the function `math.simplify`, `math.derivative` accepts either a string or an expression tree (`Node`) as input, and outputs a simplified expression tree (`Node`).
-
-```js
-// work with an expression tree, evaluate results
-const h = math.parse('x^2 + x')
-const x = math.parse('x')
-const dh = math.derivative(h, x)
-console.log(dh.toString()) // '2 * x + 1'
-console.log(dh.evaluate({x: 3})) // '7'
-```
-
-The rules used by `math.derivative` can be found on Wikipedia:
-
-- [Differentiation rules (Wikipedia)](https://en.wikipedia.org/wiki/Differentiation_rules)
-
-
-
-
-Besides parsing and evaluating expressions, the expression parser supports
-a number of features to customize processing and evaluation of expressions
-and outputting expressions.
-
-On this page:
-
-- [Function transforms](#function-transforms)
-- [Custom argument parsing](#custom-argument-parsing)
-- [Custom LaTeX handlers](#custom-latex-handlers)
-- [Custom HTML, LaTeX and string output](#custom-html-latex-and-string-output)
-- [Customize supported characters](#customize-supported-characters)
-
-
-
-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.
-
-For example, the functions for math.js use zero-based matrix indices (as is
-common in programing languages), but the expression parser uses one-based
-indices. To enable this, all functions dealing with indices have a transform,
-which changes input from one-based to zero-based, and transforms output (and
-error message) from zero-based to one-based.
-
-```js
-// using plain JavaScript, indices are zero-based:
-const a = [[1, 2], [3, 4]] // a 2x2 matrix
-math.subset(a, math.index(0, 1)) // returns 2
-
-// using the expression parser, indices are transformed to one-based:
-const a = [[1, 2], [3, 4]] // a 2x2 matrix
-let scope = {
- a: a
-}
-math.evaluate('subset(a, index(1, 2))', scope) // returns 2
-```
-
-To create a transform for a function, the transform function must be attached
-to the function as property `transform`:
-
-```js
-import { create, all } from 'mathjs'
-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 input here before executing addIt
-
- const res = addIt(a, b)
-
- console.log('result: ' + res)
- // we can manipulate 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
-```
-
-Functions with a transform must be imported in the `math` namespace, as they
-need to be processed at compile time. They are not supported when passed via a
-scope at evaluation time.
-
-
-
-
-The expression parser of math.js has support for letting functions
-parse and evaluate arguments themselves, instead of calling them with
-evaluated arguments. This is useful for example when creating a function
-like `plot(f(x), x)` or `integrate(f(x), x, start, end)`, where some of the
-arguments need to be processed in a special way. In these cases, the expression
-`f(x)` will be evaluated repeatedly by the function, and `x` is not evaluated
-but used to specify the variable looping over the function `f(x)`.
-
-Functions having a property `rawArgs` with value `true` are treated in a special
-way by the expression parser: they will be invoked with unevaluated arguments,
-allowing the function to process the arguments in a customized way. Raw
-functions are called as:
-
-```
-rawFunction(args: Node[], math: Object, scope: Map)
-```
-
-Where :
-
-- `args` is an Array with nodes of the parsed arguments.
-- `math` is the math namespace against which the expression was compiled.
-- `scope` is a [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
- interface containing the variables defined in the scope
- passed via `evaluate(scope)`. The passed scope is always a `Map` interface,
- and normally a `PartitionedMap` is used to separate local function variables
- like `x` in a custom defined function `f(x) = rawFunction(x) ^ 2` from the
- scope variables. Note that a `PartitionedMap` can recursively link to another
- `PartitionedMap`.
-
-Raw functions must be imported in the `math` namespace, as they need to be
-processed at compile time. They are not supported when passed via a scope
-at evaluation time.
-
-A simple example:
-
-```js
-function myFunction(args, math, scope) {
- // get string representation of the arguments
- const str = args.map(function (arg) {
- return arg.toString()
- })
-
- // evaluate the arguments
- const res = args.map(function (arg) {
- return arg.compile().evaluate(scope)
- })
-
- return 'arguments: ' + str.join(',') + ', evaluated: ' + res.join(',')
-}
-
-// mark the function as "rawArgs", so it will be called with unevaluated arguments
-myFunction.rawArgs = true
-
-// import the new function in the math namespace
-math.import({
- myFunction: myFunction
-})
-
-// use the function
-math.evaluate('myFunction(2 + 3, sqrt(4))')
-// returns 'arguments: 2 + 3, sqrt(4), evaluated: 5, 2'
-```
-
-
-
-You can attach a `toTex` property to your custom functions before importing them to define their LaTeX output. This
-`toTex` property can be a handler in the format described in the next section 'Custom LaTeX and String conversion'
-or a template string similar to ES6 templates.
-
-
-
-- `${name}`: Gets replaced by the name of the function
-- `${args}`: Gets replaced by a comma separated list of the arguments of the function.
-- `${args[0]}`: Gets replaced by the first argument of a function
-- `$$`: Gets replaced by `$`
-
-
-
-All expression nodes have a method `toTex` and `toString` to output an expression respectively in HTML or LaTex format or as regular text .
-The functions `toHTML`, `toTex` and `toString` accept an `options` argument to customise output. This object is of the following form:
-
-```js
-{
- parenthesis: 'keep', // parenthesis option
- handler: someHandler, // handler to change the output
- implicit: 'hide' // how to treat implicit multiplication
-}
-```
-
-
-
-The `parenthesis` option changes the way parentheses are used in the output. There are three options available:
-
-- `keep` Keep the parentheses from the input and display them as is. This is the default.
-- `auto` Only display parentheses that are necessary. Mathjs tries to get rid of as much parentheses as possible.
-- `all` Display all parentheses that are given by the structure of the node tree. This makes the output precedence unambiguous.
-
-There's two ways of passing callbacks:
-
-1. Pass an object that maps function names to callbacks. Those callbacks will be used for FunctionNodes with
-functions of that name.
-2. Pass a function to `toTex`. This function will then be used for every node.
-
-```js
-const expression = math.parse('(1+1+1)')
-
-expression.toString() // (1 + 1 + 1)
-expression.toString({parenthesis: 'keep'}) // (1 + 1 + 1)
-expression.toString({parenthesis: 'auto'}) // 1 + 1 + 1
-expression.toString({parenthesis: 'all'}) // (1 + 1) + 1
-```
-
-
-
-You can provide the `toTex` and `toString` functions of an expression with your own custom handlers that override the internal behaviour. This is especially useful to provide LaTeX/string output for your own custom functions. This can be done in two ways:
-
-1. Pass an object that maps function names to callbacks. Those callbacks will be used for FunctionNodes that contain functions with that name.
-2. Pass a callback directly. This callback will run for every node, so you can replace the output of anything you like.
-
-A callback function has the following form:
-
-```js
-function callback (node, options) {
- ...
-}
-```
-Where `options` is the object passed to `toHTML`/`toTex`/`toString`. Don't forget to pass this on to the child nodes, and `node` is a reference to the current node.
-
-If a callback returns nothing, the standard output will be used. If your callback returns a string, this string will be used.
-
-**Although the following examples use `toTex`, it works for `toString` and `toHTML` in the same way**
-
-
-
-You can change the way that implicit multiplication is converted to a string or LaTeX. The two options are `hide`, to not show a multiplication operator for implicit multiplication and `show` to show it.
-
-Example:
-
-```js
-const node = math.parse('2a')
-
-node.toString() // '2 a'
-node.toString({implicit: 'hide'}) // '2 a'
-node.toString({implicit: 'show'}) // '2 * a'
-
-node.toTex() // '2~ a'
-node.toTex({implicit: 'hide'}) // '2~ a'
-node.toTex({implicit: 'show'}) // '2\\cdot a'
-```
-
-
-
-
-It is possible to customize the characters allowed in symbols and digits.
-The `parse` function exposes the following test functions:
-
-- `math.parse.isAlpha(c, cPrev, cNext)`
-- `math.parse.isWhitespace(c, nestingLevel)`
-- `math.parse.isDecimalMark(c, cNext)`
-- `math.parse.isDigitDot(c)`
-- `math.parse.isDigit(c)`
-
-The exact signature and implementation of these functions can be looked up in
-the [source code of the parser](https://github.com/josdejong/mathjs/blob/master/src/expression/parse.js). The allowed alpha characters are described here: [Constants and variables](syntax.html#constants-and-variables).
-
-For example, the phone character ☎ is not supported by default. It can be enabled
-by replacing the `isAlpha` function:
-
-```js
-const isAlphaOriginal = math.parse.isAlpha
-math.parse.isAlpha = function (c, cPrev, cNext) {
- return isAlphaOriginal(c, cPrev, cNext) || (c === '\u260E')
-}
-
-// now we can use the \u260E (phone) character in expressions
-const result = math.evaluate('\u260Efoo', {'\u260Efoo': 42}) // returns 42
-console.log(result)
-```
diff --git a/docs/expressions/expression_trees.md b/docs/expressions/expression_trees.md
deleted file mode 100644
index c322e8a983..0000000000
--- a/docs/expressions/expression_trees.md
+++ /dev/null
@@ -1,715 +0,0 @@
----
-layout: default
----
-
-
-
-When parsing an expression via `math.parse(expr)`, math.js generates an
-expression tree and returns the root node of the tree. An expression tree can
-be used to analyze, manipulate, and evaluate expressions.
-
-Example:
-
-```js
-const node = math.parse('sqrt(2 + x)')
-```
-
-In this case, the expression `sqrt(2 + x)` is parsed as:
-
-```
- FunctionNode sqrt
- |
- OperatorNode +
- / \
- ConstantNode 2 x SymbolNode
-```
-
-Alternatively, this expression tree can be built by manually creating nodes:
-
-```js
-const node1 = new math.ConstantNode(2)
-const node2 = new math.SymbolNode('x')
-const node3 = new math.OperatorNode('+', 'add', [node1, node2])
-const node4 = new math.FunctionNode('sqrt', [node3])
-```
-
-The resulting expression tree with root node `node4` is equal to the expression
-tree generated by `math.parse('sqrt(2 + x)')`.
-
-
-
-
-All nodes have the following methods:
-
-- `clone() : Node`
-
- Create a shallow clone of the node.
- The node itself is cloned, its childs are not cloned.
-
-- `cloneDeep() : Node`
-
- Create a deep clone of the node.
- Both the node as well as all its childs are cloned recursively.
-
-- `compile() : Object`
-
- Compile an expression into optimized JavaScript code. `compile` returns an
- object with a function `evaluate([scope])` to evaluate. Example:
-
- ```js
- const node = math.parse('2 + x') // returns the root Node of an expression tree
- const code = node.compile() // returns {evaluate: function (scope) {...}}
- const evaluate = code.evaluate({x: 3}) // returns 5
- ```
-
-- `evaluate([scope]) : Object`
-
- Compile and evaluate an expression, this is the equivalent of doing
- `node.compile().evaluate(scope)`. Example:
-
- ```js
- const node = math.parse('2 + x') // returns the root Node of an expression tree
- const evaluate = node.evaluate({x: 3}) // returns 5
- ```
-
-- `equals(other: Node) : boolean`
-
- Test whether this node equals an other node. Does a deep comparison of the
- values of both nodes.
-
-- `filter(callback: function) : Node[]`
-
- Recursively filter nodes in an expression tree. The `callback` function is
- called as `callback(node: Node, path: string, parent: Node) : boolean` for
- every node in the tree, and must return a boolean. The function `filter`
- returns an array with nodes for which the test returned true.
- Parameter `path` is a string containing a relative JSON Path.
-
- Example:
-
- ```js
- const node = math.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'
- ```
-
-- `forEach(callback: function) : void`
-
- Execute a callback for each of the child nodes of this node. The `callback`
- function is called as `callback(child: Node, path: string, parent: Node): void`.
- Parameter `path` is a string containing a relative JSON Path.
-
- See also `traverse`, which is a recursive version of `forEach`.
-
- Example:
-
- ```js
- const node = math.parse('3 * x + 2')
- node.forEach(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 *
- // ConstantNode 2
- ```
-
-- `map(callback: function) : Node[]`
-
- Transform a node. Creates a new Node having it's childs be the results of
- calling the provided callback function for each of the childs of the original
- node. The `callback` function is called as `callback(child: Node, path: string,
- parent: Node)` and must return a Node. Parameter `path` is a string containing
- a relative JSON Path.
-
- See also `transform`, which is a recursive version of `map`.
-
-- `toHTML(options: object): string`
-
- Get a HTML representation of the parsed expression. Example:
-
- ```js
- const node = math.parse('sqrt(2/3)')
- node.toHTML()
- // returns
- // sqrt
- // (
- // 2
- // /
- // 3
- // )
- ```
-
- Information about the available HTML classes in [HTML Classes](html_classes.html).
- Information about the options in [Customization](customization.html#custom-html-latex-and-string-output).
-
-- `toString(options: object) : string`
-
- Get a string representation of the parsed expression. This is not exactly
- the same as the original input. Example:
-
- ```js
- const node = math.parse('3+4*2')
- node.toString() // returns '3 + (4 * 2)'
- ```
-
- Information about the options in [Customization](customization.html#custom-html-latex-and-string-output).
-
-- `toTex(options: object): string`
-
- Get a [LaTeX](https://en.wikipedia.org/wiki/LaTeX) representation of the
- expression. Example:
-
- ```js
- const node = math.parse('sqrt(2/3)')
- node.toTex() // returns '\sqrt{\frac{2}{3}}'
- ```
-
- Information about the options in [Customization](customization.html#custom-html-latex-and-string-output).
-
-- `transform(callback: function)`
-
- Recursively transform an expression tree via a transform function. Similar
- to `Array.map`, but recursively executed on all nodes in the expression tree.
- The callback function is a mapping function accepting a node, and returning
- a replacement for the node or the original node. Function `callback` is
- called as `callback(node: Node, path: string, parent: Node)` for every node
- in the tree, and must return a `Node`. Parameter `path` is a string containing
- a relative JSON Path.
-
- The transform function will stop iterating when a node is replaced by the
- callback function, it will not iterate over replaced nodes.
-
- For example, to replace all nodes of type `SymbolNode` having name 'x' with a
- ConstantNode with value `3`:
-
- ```js
- const node = math.parse('x^2 + 5*x')
- const transformed = node.transform(function (node, path, parent) {
- if (node.isSymbolNode && node.name === 'x') {
- return new math.ConstantNode(3)
- }
- else {
- return node
- }
- })
- transformed.toString() // returns '3 ^ 2 + 5 * 3'
- ```
-
-- `traverse(callback: function): void`
-
- Recursively traverse all nodes in a node tree. Executes given callback for
- this node and each of its child nodes. Similar to `Array.forEach`, except
- recursive.
- The callback function is a mapping function accepting a node, and returning
- nothing. Function `callback` is
- called as `callback(node: Node, path: string, parent: Node)` for every node
- in the tree. Parameter `path` is a string containing a relative JSON Path.
- Example:
-
- ```js
- const node = math.parse('3 * x + 2')
- node.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
- ```
-
-
-
-
-Each `Node` has the following properties:
-
-- `comment: string`
-
- A string holding a comment if there was any in the expression, or else the
- string will be empty string. A comment can be attached to the root node of
- an expression or to each of the childs nodes of a `BlockNode`.
-
-- `isNode: true`
-
- Is defined with value `true` on Nodes. Additionally, each type of node
- adds it's own flag, for example a `SymbolNode` as has a property
- `isSymbolNode: true`.
-
-- `type: string`
-
- The type of the node, for example `'SymbolNode'` in case of a `SymbolNode`.
-
-
-
-
-A `BlockNode` is created when parsing a multi line expression like `a=2;b=3` or
-`a=2\nb=3`. Evaluating a `BlockNode` returns a `ResultSet`. The results can be
-retrieved via `ResultSet.entries` or `ResultSet.valueOf()`, which contains
-an `Array` with the results of the visible lines (i.e. lines not ending with
-a semicolon).
-
-Construction:
-
-```
-block = new BlockNode(Array.<{node: Node} | {node: Node, visible: boolean}>)
-```
-
-Properties:
-
-- `blocks: Array.<{node: Node, visible: boolean}>`
-
-Examples:
-
-```js
-const block1 = math.parse('a=1; b=2; c=3')
-
-const a = new math.SymbolNode('a')
-const one = new math.ConstantNode(1)
-const ass1 = new math.AssignmentNode(a, one)
-
-const b = new math.SymbolNode('b')
-const two = new math.ConstantNode(2)
-const ass2 = new math.AssignmentNode(b, two)
-
-const c = new math.SymbolNode('c')
-const three = new math.ConstantNode(3)
-const ass3 = new math.AssignmentNode(c, three)
-
-const block2 = new BlockNode([
- {node: ass1, visible: false},
- {node: ass2, visible: false},
- {node: ass3, visible: true}
-])
-```
-
-
-
-
-Construction:
-
-```
-new FunctionNode(fn: Node | string, args: Node[])
-```
-
-Properties:
-
-- `fn: Node | string` (read-only) The object or function name which to invoke.
-- `args: Node[]`
-
-Static functions:
-
-- `FunctionNode.onUndefinedFunction(name: string)`. This function is invoked when an undefined function is evaluated. By default, the function throws an exception "Undefined function x". The function can be overwritten to customize this behavior. See also `SymbolNode.onUndefinedSymbol`.
-
-
-Examples:
-
-```js
-const node1 = math.parse('sqrt(4)')
-
-const four = new math.ConstantNode(4)
-const node3 = new math.FunctionNode(new SymbolNode('sqrt'), [four])
-```
-
-
-
-
-Construction:
-
-```
-new IndexNode(dimensions: Node[])
-new IndexNode(dimensions: Node[], dotNotation: boolean)
-```
-
-Each dimension can be a single value, a range, or a property. The values of
-indices are one-based, including range end.
-
-An optional property `dotNotation` can be provided describing whether this index
-was written using dot notation like `a.b`, or using bracket notation
-like `a["b"]`. Default value is `false`. This information is used when
-stringifying the IndexNode.
-
-Properties:
-
-- `dimensions: Node[]`
-- `dotNotation: boolean`
-
-Examples:
-
-```js
-const node1 = math.parse('A[1:3, 2]')
-
-const A = new math.SymbolNode('A')
-const one = new math.ConstantNode(1)
-const two = new math.ConstantNode(2)
-const three = new math.ConstantNode(3)
-
-const range = new math.RangeNode(one, three)
-const index = new math.IndexNode([range, two])
-const node2 = new math.AccessorNode(A, index)
-```
-
-
-
-Construction:
-
-```
-new RelationalNode(conditionals: string[], params: Node[])
-```
-
-`conditionals` is an array of strings, each of which may be 'smaller', 'larger', 'smallerEq', 'largerEq', 'equal', or 'unequal'. The `conditionals` array must contain exactly one fewer item than `params`.
-
-Properties:
-
-- `conditionals: string[]`
-- `params: Node[]`
-
-A `RelationalNode` efficiently represents a chained conditional expression with two or more comparison operators, such as `10 < x <= 50`. The expression is equivalent to `10 < x and x <= 50`, except that `x` is evaluated only once, and evaluation stops (is "short-circuited") once any condition tests false. Operators that are subject to chaining are `<`, `>`, `<=`, `>=`, `==`, and `!=`. For backward compatibility, `math.parse` will return an `OperatorNode` if only a single conditional is present (such as `x > 2`).
-
-Examples:
-
-```js
-
-const ten = new math.ConstantNode(10)
-const x = new math.SymbolNode('x')
-const fifty = new math.ConstantNode(50)
-
-const node1 = new math.RelationalNode(['smaller', 'smallerEq'], [ten, x, fifty])
-const node2 = math.parse('10 < x <= 50')
-```
-
-
-
-
-Construction:
-
-```
-new SymbolNode(name: string)
-```
-
-Properties:
-
-- `name: string`
-
-Static functions:
-
-- `SymbolNode.onUndefinedSymbol(name: string)`. This function is invoked when an undefined symbol is evaluated. By default, the function throws an exception "Undefined symbol x". The function can be overwritten to customize this behavior. See also `FunctionNode.onUndefinedFunction`.
-
-
-Examples:
-
-```js
-const node = math.parse('x')
-
-const x = new math.SymbolNode('x')
-```
diff --git a/docs/expressions/html_classes.md b/docs/expressions/html_classes.md
deleted file mode 100644
index 8a269c806c..0000000000
--- a/docs/expressions/html_classes.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-layout: default
----
-
-
-
-The expression parser can output a HTML string, where every `Node` is
-transformed into a `` element with semantic class names. Each class
-name begins with the `math-` prefix. These class names can be used in CSS to
-highlight the syntax or change the default layout (e.g. spaces around operators).
-
-
-
-Math.js contains a flexible and easy to use expression parser.
-The parser supports all data types, functions and constants available in math.js.
-
-Whilst the math.js library is aimed at JavaScript developers, the expression
-parser is aimed at end users: mathematicians, engineers, students, pupils.
-The syntax of the expression parser differs from JavaScript and the low-level
-math.js library.
-
-This section is divided in the following pages:
-
-- [Parsing and evaluation](parsing.html) describes how to parse and
- evaluate expressions with math.js.
-- [Syntax](syntax.html) describes how to write expressions.
-- [Expression trees](expression_trees.html) explains how to parse an expression into an
- expression tree, and use this to analyse and manipulate the expression.
-- [Algebra](algebra.html) describing symbolic computation in math.js.
-- [Customization](customization.html) describes how to customize processing and
- evaluation of expressions.
-- [Security](security.html) about security risks of executing arbitrary expressions.
diff --git a/docs/expressions/parsing.md b/docs/expressions/parsing.md
deleted file mode 100644
index 752601cd97..0000000000
--- a/docs/expressions/parsing.md
+++ /dev/null
@@ -1,240 +0,0 @@
----
-layout: default
----
-
-
-
-Expressions can be parsed and evaluated in various ways:
-
-- Using the function [`math.evaluate(expr [,scope])`](#evaluate).
-- Using the function [`math.compile(expr)`](#compile).
-- Using the function [`math.parse(expr)`](#parse).
-- By creating a [parser](#parser), `math.parser()`, which contains a method
- `evaluate` and keeps a scope with assigned variables in memory.
-
-
-
-
-Math.js comes with a function `math.evaluate` to evaluate expressions. Syntax:
-
-```js
-math.evaluate(expr)
-math.evaluate(expr, scope)
-math.evaluate([expr1, expr2, expr3, ...])
-math.evaluate([expr1, expr2, expr3, ...], scope)
-```
-
-Function `evaluate` accepts a single expression or an array with
-expressions as the first argument and has an optional second argument
-containing a `scope` with variables and functions. The scope can be a regular
-JavaScript `Map` (recommended), a plain JavaScript `object`, or any custom
-class that implements the `Map` interface with methods `get`, `set`, `keys`
-and `has`. The scope will be used to resolve symbols, and to write assigned
-variables and functions.
-
-When an `Object` is used as scope, mathjs will internally wrap it in an
-`ObjectWrappingMap` interface since the internal functions can only use a `Map`
-interface. In case of custom defined functions like `f(x) = x^2`, the scope
-will be wrapped in a `PartitionedMap`, which reads and writes the function
-variables (like `x` in this example) from a temporary map, and reads and writes
-other variables from the original scope. The original scope is never copied, it
-is only wrapped around when needed.
-
-The following code demonstrates how to evaluate expressions.
-
-```js
-// evaluate expressions
-math.evaluate('sqrt(3^2 + 4^2)') // 5
-math.evaluate('sqrt(-4)') // 2i
-math.evaluate('2 inch to cm') // 5.08 cm
-math.evaluate('cos(45 deg)') // 0.7071067811865476
-
-// provide a scope
-let scope = {
- a: 3,
- b: 4
-}
-math.evaluate('a * b', scope) // 12
-math.evaluate('c = 2.3 + 4.5', scope) // 6.8
-scope.c // 6.8
-```
-
-
-
-
-Math.js contains a function `math.compile` which compiles expressions
-into JavaScript code. This is a shortcut for first [parsing](#parse) and then
-compiling an expression. The syntax is:
-
-```js
-math.compile(expr)
-math.compile([expr1, expr2, expr3, ...])
-```
-
-Function `compile` accepts a single expression or an array with
-expressions as the argument. Function `compile` returns an object with a function
-`evaluate([scope])`, which can be executed to evaluate the expression against an
-(optional) scope:
-
-```js
-const code = math.compile(expr) // compile an expression
-const result = code.evaluate([scope]) // evaluate the code with an optional scope
-```
-
-An expression needs to be compiled only once, after which the
-expression can be evaluated repeatedly and against different scopes.
-The optional scope is used to resolve symbols and to write assigned
-variables or functions. Parameter [`scope`](#scope) can be a regular Object, or Map.
-
-Example usage:
-
-```js
-// parse an expression into a node, and evaluate the node
-const code1 = math.compile('sqrt(3^2 + 4^2)')
-code1.evaluate() // 5
-```
-
-
-
-
-Math.js contains a function `math.parse` to parse expressions into an
-[expression tree](expression_trees.html). The syntax is:
-
-```js
-math.parse(expr)
-math.parse([expr1, expr2, expr3, ...])
-```
-
-Function `parse` accepts a single expression or an array with
-expressions as the argument. Function `parse` returns the root node of the tree,
-which can be successively compiled and evaluated:
-
-```js
-const node = math.parse(expr) // parse expression into a node tree
-const code = node.compile() // compile the node tree
-const result = code.evaluate([scope]) // evaluate the code with an optional scope
-```
-
-The API of nodes is described in detail on the page
-[Expression trees](expression_trees.html).
-
-An expression needs to be parsed and compiled only once, after which the
-expression can be evaluated repeatedly. On evaluation, an optional scope
-can be provided, which is used to resolve symbols and to write assigned
-variables or functions. Parameter [`scope`](#scope) is a regular Object or Map.
-
-Example usage:
-
-```js
-// parse an expression into a node, and evaluate the node
-const node1 = math.parse('sqrt(3^2 + 4^2)')
-const code1 = node1.compile()
-code1.evaluate() // 5
-
-// provide a scope
-const node2 = math.parse('x^a')
-const code2 = node2.compile()
-let scope = {
- x: 3,
- a: 2
-}
-code2.evaluate(scope) // 9
-
-// change a value in the scope and re-evaluate the node
-scope.a = 3
-code2.evaluate(scope) // 27
-```
-
-Parsed expressions can be exported to text using `node.toString()`, and can
-be exported to LaTeX using `node.toTex()`. The LaTeX export can be used to
-pretty print an expression in the browser with a library like
-[MathJax](https://www.mathjax.org/). Example usage:
-
-```js
-// parse an expression
-const node = math.parse('sqrt(x/x+1)')
-node.toString() // returns 'sqrt((x / x) + 1)'
-node.toTex() // returns '\sqrt{ {\frac{x}{x} }+{1} }'
-```
-
-
-
-
-In addition to the static functions [`math.evaluate`](#evaluate) and
-[`math.parse`](#parse), math.js contains a parser with functions `evaluate` and
-`parse`, which automatically keeps a scope with assigned variables in memory.
-The parser also contains some convenience functions to get, set, and remove
-variables from memory.
-
-A parser can be created by:
-
-```js
-const parser = math.parser()
-```
-
-The parser contains the following functions:
-
-- `clear()`
- Completely clear the parser's scope.
-- `evaluate(expr)`
- Evaluate an expression. Returns the result of the expression.
-- `get(name)`
- Retrieve a variable or function from the parser's scope.
-- `getAll()`
- Retrieve an object with all defined variables in the parser's scope.
-- `getAllAsMap()`
- Retrieve a map with all defined variables in the parser's scope.
-- `remove(name)`
- Remove a variable or function from the parser's scope.
-- `set(name, value)`
- Set a variable or function in the parser's scope.
-
-The following code shows how to create and use a parser.
-
-```js
-// create a parser
-const parser = math.parser()
-
-// evaluate expressions
-parser.evaluate('sqrt(3^2 + 4^2)') // 5
-parser.evaluate('sqrt(-4)') // 2i
-parser.evaluate('2 inch to cm') // 5.08 cm
-parser.evaluate('cos(45 deg)') // 0.7071067811865476
-
-// define variables and functions
-parser.evaluate('x = 7 / 2') // 3.5
-parser.evaluate('x + 3') // 6.5
-parser.evaluate('f(x, y) = x^y') // f(x, y)
-parser.evaluate('f(2, 3)') // 8
-
-// get and set variables and functions
-const x = parser.get('x') // x = 3.5
-const f = parser.get('f') // function
-const g = f(3, 3) // g = 27
-parser.set('h', 500)
-parser.evaluate('h / 2') // 250
-parser.set('hello', function (name) {
- return 'hello, ' + name + '!'
-})
-parser.evaluate('hello("user")') // "hello, user!"
-
-// clear defined functions and variables
-parser.clear()
-```
-
-
-
-The scope is a data-structure used to store and lookup variables and functions defined and used by expressions.
-
-It is passed to mathjs via calls to [`math.evaluate`](#evaluate) or `simplify`.
-
-For ease of use, it can be a Plain Javascript Object; for safety it can be a plain `Map` and for flexibility, any object that has
-the methods `get`/`set`/`has`/`keys`, seen on `Map`.
-
-Some care is taken to mutate the same object that is passed into mathjs, so they can collect the definitions from mathjs scripts and expressions.
-
-`evaluate` will fail if the expression uses a blacklisted symbol, preventing mathjs expressions to escape into Javascript. This is enforced by access to the scope.
-
-For less reliance on this blacklist, scope can also be a `Map`, which allows mathjs expressions to define variables and functions of any name.
-
-For more, see [examples of custom scopes](../../examples/advanced/custom_scope_objects.js).
diff --git a/docs/expressions/security.md b/docs/expressions/security.md
deleted file mode 100644
index 5c8468b057..0000000000
--- a/docs/expressions/security.md
+++ /dev/null
@@ -1,99 +0,0 @@
----
-layout: default
----
-
-
-
-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.
-
-
-
-A user could try to inject malicious JavaScript code via the expression
-parser. The expression parser of mathjs offers a sandboxed environment
-to execute expressions which should make this impossible. It's possible
-though that there are unknown security vulnerabilities, so it's important
-to be careful, especially when allowing server side execution of
-arbitrary expressions.
-
-The expression parser of mathjs parses the input in a controlled
-way into an expression tree or abstract syntax tree (AST).
-In a "compile" step, it does as much as possible preprocessing on the
-static parts of the expression, and creates a fast performing function
-which can be used to evaluate the expression repeatedly using a
-dynamically passed scope.
-
-The parser actively prevents access to JavaScripts internal `eval` and
-`new Function` which are the main cause of security attacks. Mathjs
-versions 4 and newer does not use JavaScript's `eval` under the hood.
-Version 3 and older did use `eval` for the compile step. This is not
-directly a security issue but results in a larger possible attack surface.
-
-When running a node.js server, it's good to be aware of the different
-types of security risks. The risk when running inside a browser may be
-limited, though it's good to be aware of [Cross side scripting (XSS)](https://www.wikiwand.com/en/Cross-site_scripting) vulnerabilities. A nice overview of
-the security risks of node.js servers is listed in the article [Node.js security checklist](https://blog.risingstack.com/node-js-security-checklist/) by Gergely Nemeth.
-
-
-
-There is a small number of functions which yield the biggest security
-risk in the expression parser:
-
-- `import` and `createUnit` which alter the built-in functionality and
- allow overriding existing functions and units, and `reviver` which parses
- values into class instances.
-- `evaluate`, `parse`, `simplify`, `derivative`, and `resolve` 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:
-
-```js
-import { create, all } from 'mathjs'
-
-const math = create(all)
-const limitedEvaluate = math.evaluate
-
-math.import({
- // most important (hardly any functional impact)
- 'import': function () { throw new Error('Function import is disabled') },
- 'createUnit': function () { throw new Error('Function createUnit is disabled') },
- 'reviver': function () { throw new Error('Function reviver is disabled') },
-
- // extra (has functional impact)
- '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') },
- 'resolve': function () { throw new Error('Function resolve is disabled') },
-}, { override: true })
-
-console.log(limitedEvaluate('sqrt(16)')) // Ok, 4
-console.log(limitedEvaluate('parse("2+3")')) // Error: Function parse is disabled
-```
-
-
-
Found a security vulnerability? Please report in private! #
-
-You found a security vulnerability? Awesome! We hope you don't have bad
-intentions and want to help fix the issue. Please report the
-vulnerability in a private way by contacting one of the maintainers
-via mail or another private channel. That way we can work together
-on a fix before sharing the issue with everybody including the bad guys.
-
-
-
-A user could accidentally or on purpose execute a
-heavy expression like creating a huge matrix. That can let the
-JavaScript engine run out of memory or freeze it when the CPU goes
-to 100% for a long time.
-
-To protect against this sort of issue, one can run the expression parser
-in a separate Web Worker or child_process, so it can't affect the
-main process. The workers can be killed when it runs for too
-long or consumes too much memory. A useful library in this regard
-is [workerpool](https://github.com/josdejong/workerpool), which makes
-it easy to manage a pool of workers in both browser and node.js.
diff --git a/docs/expressions/syntax.md b/docs/expressions/syntax.md
deleted file mode 100644
index 6962d93913..0000000000
--- a/docs/expressions/syntax.md
+++ /dev/null
@@ -1,830 +0,0 @@
----
-layout: default
----
-
-
-
-This page describes the syntax of the expression parser of math.js. It describes
-how to work with the available data types, functions, operators, variables,
-and more.
-
-
-
-The expression parser of math.js is aimed at a mathematical audience,
-not a programming audience. The syntax is similar to most calculators and
-mathematical applications. This is close to JavaScript as well, though there
-are a few important differences between the syntax of the expression parser and
-the lower level syntax of math.js. Differences are:
-
-- No need to prefix functions and constants with the `math.*` namespace,
- you can just enter `sin(pi / 4)`.
-- Matrix indexes are one-based instead of zero-based.
-- There are index and range operators which allow more conveniently getting
- and setting matrix indexes, like `A[2:4, 1]`.
-- Both indexes and ranges and have the upper-bound included.
-- There is a differing syntax for defining functions. Example: `f(x) = x^2`.
-- There are custom operators like `x + y` instead of `add(x, y)`.
-- Some operators are different. For example `^` is used for exponentiation,
- not bitwise xor.
-- Implicit multiplication, like `2 pi`, is supported and has special rules.
-- Relational operators (`<`, `>`, `<=`, `>=`, `==`, and `!=`) are chained, so the expression `5 < x < 10` is equivalent to `5 < x and x < 10`.
-- Multi-expression constructs like `a = 1; b = 2; a + b` or
- `"a = 1;\n cos(a)\n sin(a)"` (where `\n` denotes newline)
- produce a collection ("ResultSet") of values. Those expressions
- terminated by `;` are evaluated for side effect only and their values
- are suppressed from the result.
-
-
-
-The expression parser has operators for all common arithmetic operations such
-as addition and multiplication. The expression parser uses conventional infix
-notation for operators: an operator is placed between its arguments.
-Round parentheses can be used to override the default precedence of operators.
-
-```js
-// use operators
-math.evaluate('2 + 3') // 5
-math.evaluate('2 * 3') // 6
-
-// use parentheses to override the default precedence
-math.evaluate('2 + 3 * 4') // 14
-math.evaluate('(2 + 3) * 4') // 20
-```
-
-The following operators are available. Note that almost every operator listed
-also has a function form with identical meaning that can be used
-interchangeably. For example, `x+y` will always evaluate identically to
-`add(x,y)`. For a full list of the equivalences, see the section on
-Functions below.
-
-Operator | Name | Syntax | Associativity | Example | Result
------------ | -------------------------- | ---------- | ------------- | --------------------- | ---------------
-`(`, `)` | Grouping | `(x)` | None | `2 * (3 + 4)` | `14`
-`[`, `]` | Matrix, Index | `[...]` | None | `[[1,2],[3,4]]` | `[[1,2],[3,4]]`
-`{`, `}` | Object | `{...}` | None | `{a: 1, b: 2}` | `{a: 1, b: 2}`
-`,` | Parameter separator | `x, y` | Left to right | `max(2, 1, 5)` | `5`
-`.` | Property accessor | `obj.prop` | Left to right | `obj={a: 12}; obj.a` | `12`
-`;` | Statement separator | `x; y` | Left to right | `a=2; b=3; a*b` | `[6]`
-`;` | Row separator | `[x; y]` | Left to right | `[1,2;3,4]` | `[[1,2],[3,4]]`
-`\n` | Statement separator | `x \n y` | Left to right | `a=2 \n b=3 \n a*b` | `[2,3,6]`
-`+` | Add | `x + y` | Left to right | `4 + 5` | `9`
-`+` | Unary plus | `+y` | Right to left | `+4` | `4`
-`-` | Subtract | `x - y` | Left to right | `7 - 3` | `4`
-`-` | Unary minus | `-y` | Right to left | `-4` | `-4`
-`*` | Multiply | `x * y` | Left to right | `2 * 3` | `6`
-`.*` | Element-wise multiply | `x .* y` | Left to right | `[1,2,3] .* [1,2,3]` | `[1,4,9]`
-`/` | Divide | `x / y` | Left to right | `6 / 2` | `3`
-`./` | Element-wise divide | `x ./ y` | Left to right | `[9,6,4] ./ [3,2,2]` | `[3,3,2]`
-`%` | Percentage | `x%` | None | `8%` | `0.08`
-`%` | Addition with Percentage | `x + y%` | Left to right | `100 + 3%` | `103`
-`%` | Subtraction with Percentage| `x - y%` | Left to right | `100 - 3%` | `97`
-`%` `mod` | Modulus | `x % y` | Left to right | `8 % 3` | `2`
-`^` | Power | `x ^ y` | Right to left | `2 ^ 3` | `8`
-`.^` | Element-wise power | `x .^ y` | Right to left | `[2,3] .^ [3,3]` | `[8,27]`
-`'` | Transpose | `y'` | Left to right | `[[1,2],[3,4]]'` | `[[1,3],[2,4]]`
-`!` | Factorial | `y!` | Left to right | `5!` | `120`
-`&` | Bitwise and | `x & y` | Left to right | `5 & 3` | `1`
-`~` | Bitwise not | `~x` | Right to left | `~2` | `-3`
-| | Bitwise or | x | y | Left to right | 5 | 3 | `7`
-^| | Bitwise xor | x ^| y | Left to right | 5 ^| 2 | `7`
-`<<` | Left shift | `x << y` | Left to right | `4 << 1` | `8`
-`>>` | Right arithmetic shift | `x >> y` | Left to right | `8 >> 1` | `4`
-`>>>` | Right logical shift | `x >>> y` | Left to right | `-8 >>> 1` | `2147483644`
-`and` | Logical and | `x and y` | Left to right | `true and false` | `false`
-`not` | Logical not | `not y` | Right to left | `not true` | `false`
-`or` | Logical or | `x or y` | Left to right | `true or false` | `true`
-`xor` | Logical xor | `x xor y` | Left to right | `true xor true` | `false`
-`=` | Assignment | `x = y` | Right to left | `a = 5` | `5`
-`?` `:` | Conditional expression | `x ? y : z` | Right to left | `15 > 100 ? 1 : -1` | `-1`
-`:` | Range | `x : y` | Right to left | `1:4` | `[1,2,3,4]`
-`to`, `in` | Unit conversion | `x to y` | Left to right | `2 inch to cm` | `5.08 cm`
-`==` | Equal | `x == y` | Left to right | `2 == 4 - 2` | `true`
-`!=` | Unequal | `x != y` | Left to right | `2 != 3` | `true`
-`<` | Smaller | `x < y` | Left to right | `2 < 3` | `true`
-`>` | Larger | `x > y` | Left to right | `2 > 3` | `false`
-`<=` | Smallereq | `x <= y` | Left to right | `4 <= 3` | `false`
-`>=` | Largereq | `x >= y` | Left to right | `2 + 4 >= 6` | `true`
-
-
-
-
-Functions are called by entering their name, followed by zero or more
-arguments enclosed by parentheses. All available functions are listed on the
-page [Functions](../reference/functions.html).
-
-```js
-math.evaluate('sqrt(25)') // 5
-math.evaluate('log(10000, 3 + 7)') // 4
-math.evaluate('sin(pi / 4)') // 0.7071067811865475
-```
-
-New functions can be defined by "assigning" an expression to a function call
-with one or more variables. Such function assignments are limited: they can
-only be defined on a single line.
-
-```js
-const parser = math.parser()
-
-parser.evaluate('f(x) = x ^ 2 - 5')
-parser.evaluate('f(2)') // -1
-parser.evaluate('f(3)') // 4
-
-parser.evaluate('g(x, y) = x ^ y')
-parser.evaluate('g(2, 3)') // 8
-```
-
-Note that these function assignments do _not_ create closures; put another way,
-all free variables in mathjs are dynamic:
-
-```js
-const parser = math.parser()
-
-parser.evaluate('x = 7')
-parser.evaluate('h(y) = x + y')
-parser.evaluate('h(3)') // 10
-parser.evaluate('x = 3')
-parser.evaluate('h(3)') // 6, *not* 10
-```
-
-It is however possible to pass functions as parameters:
-
-```js
-const parser = math.parser()
-
-parser.evaluate('twice(func, x) = func(func(x))')
-parser.evaluate('twice(square, 2)') // 16
-parser.evaluate('f(x) = 3*x')
-parser.evaluate('twice(f, 2)') // 18
-
-// a simplistic "numerical derivative":
-parser.evaluate('eps = 1e-10')
-parser.evaluate('nd(f, x) = (f(x+eps) - func(x-eps))/(2*eps)')
-parser.evaluate('nd(square,2)') // 4.000000330961484
-```
-
-Math.js itself heavily uses typed functions, which ensure correct inputs and
-throws meaningful errors when the input arguments are invalid. One can create
-a [typed-function](https://github.com/josdejong/typed-function) in the
-expression parser like:
-
-```js
-const parser = math.parser()
-
-parser.evaluate('f = typed({"number": f(x) = x ^ 2 - 5})')
-```
-
-Finally, as mentioned above, there is a function form for nearly every one of
-the mathematical operator symbols. Moreover, for some associative operators,
-the corresponding function allows arbitrarily many arguments. The table below
-gives the full correspondence.
-
-Operator Expression | Equivalent Function Expression
----------------------|-------------------------------
-`a or b` |`or(a,b)`
-`a xor b` |`xor(a,b)`
-`a and b` |`and(a,b)`
-`a \| b` |`bitOr(a,b)`
-`a ^\| b` |`bitXor(a,b)`
-`a & b` |`bitAnd(a,b)`
-`a == b` |`equal(a,b)`
-`a != b` |`unequal(a,b)`
-`a < b` |`smaller(a,b)`
-`a > b` |`larger(a,b)`
-`a <= b` |`smallerEq(a,b)`
-`a << 3` |`leftShift(a,3)`
-`a >> 3` |`rightArithShift(a,3)`
-`a >>> 3` |`rightLogShift(a,3)`
-`u to cm` |`to(u, cm)`
-`a + b + c + ...` |`add(a,b,c,...)`
-`a - b` |`subtract(a,b)`
-`a * b * c * ...` |`multiply(a,b,c,...)`
-`A .* B` |`dotMultiply(A,B)`
-`A ./ B` |`dotDivide(A,B)`
-`a mod b` |`mod(a,b)`
-`+a` |`unaryPlus(a)`
-`-a` |`unaryMinus(a)`
-`~a` |`bitNot(a)`
-`not a` |`not(a)`
-`a^b` |`pow(a,b)`
-`A .^ B` |`dotPow(A,B)`
-`a!` |`factorial(a)`
-`A'` |`ctranspose(A)`
-
-Note that math.js embodies a preference for the operator forms, in that calling
-`simplify` (see [Algebra](./algebra.html)) converts any instances of the function
-form into the corresponding operator.
-
-
-
-Some data types have methods which can be used in the parser using the dot notation, for example:
-
-```js
-const parser = math.parser()
-
-parser.evaluate('a = 1 m') // Unit 1 m
-parser.evaluate('a.toNumber("mm")') // 1000
-```
-
-Or a method on a Matrix or Array:
-
-```js
-const parser = math.parser()
-
-parser.evaluate('M = [4, 9, 25]') // Matrix [4, 9, 25]
-parser.evaluate('M.map(sqrt)') // Matrix [2, 3, 5]
-```
-
-
-
-The `map` and `forEach` functions can be used to apply a callback function to each element of an array or matrix.
-
-The callback functions can be functions, typed functions, inline functions (only in the parser) or compiled inline functions (only in the parser).
-
-The callback can have the following inputs:
-- **value**: the current value in the array or matrix.
-- **index**: the index of the current value expressed as an array of numbers.
-- **array**: the array or matrix being iterated.
-
-Below is the syntax for both functions:
-
-
-
-The `map` function applies a function to each element of an array and returns a new array with the results.
-
-```js
-const parser = math.parser()
-
-// Define a square function
-parser.evaluate('square(x) = x ^ 2')
-
-// Apply the square function to each element of the array
-parser.evaluate('result = map([1, 2, 3, 4], square)')
-// result: [1, 4, 9, 16]
-
-// Apply an inline function to each element of the array
-parser.evaluate('result = map([1, 2, 3, 4], f(x) = x ^ 2)')
-// result: [1, 4, 9, 16]
-
-// Apply a compiled inline function to each element of the array
-parser.evaluate('result = map([1, 2, 3, 4], x ^ 2)')
-// result: [1, 4, 9, 16]
-```
-
-
-The `forEach` function applies a function to each element of an array or matrix but does not return a new array. It is useful for executing side effects.
-
-```js
-// Define a function that prints each element
-math.import({consoleLog: x => console.log(x)})
-const parser = math.parser()
-
-// Define a squareConsleLog function
-parser.evaluate('squareConsoleLog(x) = consoleLog(x ^ 2)')
-
-// Apply the squareConsleLog function to each element of the array
-parser.evaluate('forEach([1, 2, 3, 4], squareConsleLog)')
-// Prints: 1, 4, 9, 16
-
-// Apply an inline function to each element of the array
-parser.evaluate('forEach([1, 2, 3, 4], f(x) = consoleLog(x ^ 2))')
-// Prints: 1, 4, 9, 16
-
-// Apply a compiled inline function to each element of the array
-parser.evaluate('forEach([1, 2, 3, 4], consoleLog(x ^ 2))')
-// Prints: 1, 4, 9, 16
-```
-
-These functions are useful for performing element-wise operations on arrays or matrices.
-
-
-
-Math.js has a number of built-in constants such as `pi` and `e`.
-All available constants are listed on he page
-[Constants](../reference/constants.html).
-
-```js
-// use constants
-math.evaluate('pi') // 3.141592653589793
-math.evaluate('e ^ 2') // 7.3890560989306495
-math.evaluate('log(e)') // 1
-math.evaluate('e ^ (pi * i) + 1') // ~0 (Euler)
-```
-
-Variables can be defined using the assignment operator `=`, and can be used
-like constants.
-
-```js
-const parser = math.parser()
-
-// define variables
-parser.evaluate('a = 3.4') // 3.4
-parser.evaluate('b = 5 / 2') // 2.5
-
-// use variables
-parser.evaluate('a * b') // 8.5
-```
-
-Variable names must:
-
-- Begin with an "alpha character", which is:
- - A latin letter (upper or lower case). Ascii: `a-z`, `A-Z`
- - An underscore. Ascii: `_`
- - A dollar sign. Ascii: `$`
- - A latin letter with accents. Unicode: `\u00C0` - `\u02AF`
- - A greek letter. Unicode: `\u0370` - `\u03FF`
- - A letter-like character. Unicode: `\u2100` - `\u214F`
- - A mathematical alphanumeric symbol. Unicode: `\u{1D400}` - `\u{1D7FF}` excluding invalid code points
-- Contain only alpha characters (above) and digits `0-9`
-- Not be any of the following: `mod`, `to`, `in`, `and`, `xor`, `or`, `not`, `end`. It is possible to assign to some of these, but that's not recommended.
-
-It is possible to customize the allowed alpha characters, see [Customize supported characters](customization.html#customize-supported-characters) for more information.
-
-
-
-
-Booleans `true` and `false` can be used in expressions.
-
-```js
-// use booleans
-math.evaluate('true') // true
-math.evaluate('false') // false
-math.evaluate('(2 == 3) == false') // true
-```
-
-Booleans can be converted to numbers and strings and vice versa using the
-functions `number` and `boolean`, and `string`.
-
-```js
-// convert booleans
-math.evaluate('number(true)') // 1
-math.evaluate('string(false)') // "false"
-math.evaluate('boolean(1)') // true
-math.evaluate('boolean("false")') // false
-```
-
-
-
-
-The most important and basic data type in math.js are numbers. Numbers use a
-point as decimal mark. Numbers can be entered with exponential notation.
-Examples:
-
-```js
-// numbers in math.js
-math.evaluate('2') // 2
-math.evaluate('3.14') // 3.14
-math.evaluate('1.4e3') // 1400
-math.evaluate('22e-3') // 0.022
-```
-
-A number can be converted to a string and vice versa using the functions
-`number` and `string`.
-
-```js
-// convert a string into a number
-math.evaluate('number("2.3")') // 2.3
-math.evaluate('string(2.3)') // "2.3"
-```
-
-Math.js uses regular JavaScript numbers, which are floating points with a
-limited precision and limited range. The limitations are described in detail
-on the page [Numbers](../datatypes/numbers.html).
-
-```js
-math.evaluate('1e-325') // 0
-math.evaluate('1e309') // Infinity
-math.evaluate('-1e309') // -Infinity
-```
-
-When doing calculations with floats, one can very easily get round-off errors:
-
-```js
-// round-off error due to limited floating point precision
-math.evaluate('0.1 + 0.2') // 0.30000000000000004
-```
-
-When outputting results, the function `math.format` can be used to hide
-these round-off errors when outputting results for the user:
-
-```js
-const ans = math.evaluate('0.1 + 0.2') // 0.30000000000000004
-math.format(ans, {precision: 14}) // "0.3"
-```
-
-Numbers can be expressed as binary, octal, and hexadecimal literals:
-
-```js
-math.evaluate('0b11') // 3
-math.evaluate('0o77') // 63
-math.evaluate('0xff') // 255
-```
-
-A word size suffix can be used to change the behavior of non decimal literal evaluation:
-
-```js
-math.evaluate('0xffi8') // -1
-math.evaluate('0xffffffffi32') // -1
-math.evaluate('0xfffffffffi32') // SyntaxError: String "0xfffffffff" is out of range
-```
-
-Non decimal numbers can include a radix point:
-```js
-math.evaluate('0b1.1') // 1.5
-math.evaluate('0o1.4') // 1.5
-math.evaluate('0x1.8') // 1.5
-```
-
-Numbers can be formatted as binary, octal, and hex strings using the `notation` option of the `format` function:
-
-```js
-math.evaluate('format(3, {notation: "bin"})') // '0b11'
-math.evaluate('format(63, {notation: "oct"})') // '0o77'
-math.evaluate('format(255, {notation: "hex"})') // '0xff'
-math.evaluate('format(-1, {notation: "hex"})') // '-0x1'
-math.evaluate('format(2.3, {notation: "hex"})') // '0x2.4cccccccccccc'
-```
-
-The `format` function accepts a `wordSize` option to use in conjunction with the non binary notations:
-
-```js
-math.evaluate('format(-1, {notation: "hex", wordSize: 8})') // '0xffi8'
-```
-
-The functions `bin`, `oct`, and `hex` are shorthand for the `format` function with `notation` set accordingly:
-
-```js
-math.evaluate('bin(-1)') // '-0b1'
-math.evaluate('bin(-1, 8)') // '0b11111111i8'
-```
-
-
-
-Math.js supports BigNumbers for calculations with an arbitrary precision.
-The pros and cons of Number and BigNumber are explained in detail on the page
-[Numbers](../datatypes/numbers.html).
-
-BigNumbers are slower but have a higher precision. Calculations with big
-numbers are supported only by arithmetic functions.
-
-BigNumbers can be created using the `bignumber` function:
-
-```js
-math.evaluate('bignumber(0.1) + bignumber(0.2)') // BigNumber, 0.3
-```
-
-The default number type of the expression parser can be changed at instantiation
-of math.js. The expression parser parses numbers as BigNumber by default:
-
-```js
-// Configure the type of number: 'number' (default), 'BigNumber', or 'Fraction'
-math.config({number: 'BigNumber'})
-
-// all numbers are parsed as BigNumber
-math.evaluate('0.1 + 0.2') // BigNumber, 0.3
-```
-
-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`.
-
-
-
-
-Complex numbers can be created using the imaginary unit `i`, which is defined
-as `i^2 = -1`. Complex numbers have a real and complex part, which can be
-retrieved using the functions `re` and `im`.
-
-```js
-const parser = math.parser()
-
-// create complex numbers
-parser.evaluate('a = 2 + 3i') // Complex, 2 + 3i
-parser.evaluate('b = 4 - i') // Complex, 4 - i
-
-// get real and imaginary part of a complex number
-parser.evaluate('re(a)') // Number, 2
-parser.evaluate('im(a)') // Number, 3
-
-// calculations with complex numbers
-parser.evaluate('a + b') // Complex, 6 + 2i
-parser.evaluate('a * b') // Complex, 11 + 10i
-parser.evaluate('i * i') // Number, -1
-parser.evaluate('sqrt(-4)') // Complex, 2i
-```
-
-
-
-
-math.js supports units. Units can be used in the arithmetic operations
-add, subtract, multiply, divide, and exponentiation.
-Units can also be converted from one to another.
-An overview of all available units can be found on the page
-[Units](../datatypes/units.html).
-
-Units can be converted using the operator `to` or `in`.
-
-```js
-// create a unit
-math.evaluate('5.4 kg') // Unit, 5.4 kg
-
-// convert a unit
-math.evaluate('2 inch to cm') // Unit, 5.08 cm
-math.evaluate('20 celsius in fahrenheit') // Unit, ~68 fahrenheit
-math.evaluate('90 km/h to m/s') // Unit, 25 m / s
-
-// convert a unit to a number
-// A second parameter with the unit for the exported number must be provided
-math.evaluate('number(5 cm, mm)') // Number, 50
-
-// calculations with units
-math.evaluate('0.5kg + 33g') // Unit, 0.533 kg
-math.evaluate('3 inch + 2 cm') // Unit, 3.7874 inch
-math.evaluate('3 inch + 2 cm') // Unit, 3.7874 inch
-math.evaluate('12 seconds * 2') // Unit, 24 seconds
-math.evaluate('sin(45 deg)') // Number, 0.7071067811865475
-math.evaluate('9.81 m/s^2 * 5 s to mi/h') // Unit, 109.72172512527 mi / h
-```
-
-
-
-
-Strings are enclosed by double quotes " or single quotes '. Strings can be concatenated using the
-function `concat` (not by adding them using `+` like in JavaScript). Parts of
-a string can be retrieved or replaced by using indexes. Strings can be converted
-to a number using function `number`, and numbers can be converted to a string
-using function `string`.
-
-When setting the value of a character in a string, the character that has been
-set is returned. Likewise, when a range of characters is set, that range of
-characters is returned.
-
-
-```js
-const parser = math.parser()
-
-// create a string
-parser.evaluate('"hello"') // String, "hello"
-
-// string manipulation
-parser.evaluate('a = concat("hello", " world")') // String, "hello world"
-parser.evaluate('size(a)') // Matrix [11]
-parser.evaluate('a[1:5]') // String, "hello"
-parser.evaluate('a[1] = "H"') // String, "H"
-parser.evaluate('a[7:12] = "there!"') // String, "there!"
-parser.evaluate('a') // String, "Hello there!"
-
-// string conversion
-parser.evaluate('number("300")') // Number, 300
-parser.evaluate('string(300)') // String, "300"
-```
-
-Strings can be used in the `evaluate` function, to parse expressions inside
-the expression parser:
-
-```js
-math.evaluate('evaluate("2 + 3")') // 5
-```
-
-
-
-
-Matrices can be created by entering a series of values between square brackets,
-elements are separated by a comma `,`.
-A matrix like `[1, 2, 3]` will create a vector, a 1-dimensional matrix with
-size `[3]`. To create a multi-dimensional matrix, matrices can be nested into
-each other. For easier creation of two-dimensional matrices, a semicolon `;`
-can be used to separate rows in a matrix.
-
-```js
-// create a matrix
-math.evaluate('[1, 2, 3]') // Matrix, size [3]
-math.evaluate('[[1, 2, 3], [4, 5, 6]]') // Matrix, size [2, 3]
-math.evaluate('[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]') // Matrix, size [2, 2, 2]
-
-// create a two dimensional matrix
-math.evaluate('[1, 2, 3; 4, 5, 6]') // Matrix, size [2, 3]
-```
-
-Another way to create filled matrices is using the functions `zeros`, `ones`,
-`identity`, and `range`.
-
-```js
-// initialize a matrix with ones or zeros
-math.evaluate('zeros(3, 2)') // Matrix, [[0, 0], [0, 0], [0, 0]], size [3, 2]
-math.evaluate('ones(3)') // Matrix, [1, 1, 1], size [3]
-math.evaluate('5 * ones(2, 2)') // Matrix, [[5, 5], [5, 5]], size [2, 2]
-
-// create an identity matrix
-math.evaluate('identity(2)') // Matrix, [[1, 0], [0, 1]], size [2, 2]
-
-// create a range
-math.evaluate('1:4') // Matrix, [1, 2, 3, 4], size [4]
-math.evaluate('0:2:10') // Matrix, [0, 2, 4, 6, 8, 10], size [6]
-```
-
-A subset can be retrieved from a matrix using indexes and a subset of a matrix
-can be replaced by using indexes. Indexes are enclosed in square brackets, and
-contain a number or a range for each of the matrix dimensions. A range can have
-its start and/or end undefined. When the start is undefined, the range will start
-at 1, when the end is undefined, the range will end at the end of the matrix.
-
-There is a context variable `end` available as well to denote the end of the
-matrix. This variable cannot be used in multiple nested indices. In that case,
-`end` will be resolved as the end of the innermost matrix. To solve this,
-resolving of the nested index needs to be split in two separate operations.
-
-*IMPORTANT: matrix indexes and ranges work differently from the math.js indexes
-in JavaScript: They are one-based with an included upper-bound, similar to most
-math applications.*
-
-```js
-parser = math.parser()
-
-// create matrices
-parser.evaluate('a = [1, 2; 3, 4]') // Matrix, [[1, 2], [3, 4]]
-parser.evaluate('b = zeros(2, 2)') // Matrix, [[0, 0], [0, 0]]
-parser.evaluate('c = 5:9') // Matrix, [5, 6, 7, 8, 9]
-
-// replace a subset in a matrix
-parser.evaluate('b[1, 1:2] = [5, 6]') // Matrix, [[5, 6], [0, 0]]
-parser.evaluate('b[2, :] = [7, 8]') // Matrix, [[5, 6], [7, 8]]
-
-// perform a matrix calculation
-parser.evaluate('d = a * b') // Matrix, [[19, 22], [43, 50]]
-
-// retrieve a subset of a matrix
-parser.evaluate('d[2, 1]') // 43
-parser.evaluate('d[2, 1:end]') // Matrix, [[43, 50]]
-parser.evaluate('c[end - 1 : -1 : 2]') // Matrix, [8, 7, 6]
-```
-
-
-
-Objects in math.js work the same as in languages like JavaScript and Python.
-An object is enclosed by curly brackets `{`, `}`, and contains a set of
-comma separated key/value pairs. Keys and values are separated by a colon `:`.
-Keys can be a symbol like `prop` or a string like `"prop"`.
-
-```js
-math.evaluate('{a: 2 + 1, b: 4}') // {a: 3, b: 4}
-math.evaluate('{"a": 2 + 1, "b": 4}') // {a: 3, b: 4}
-```
-
-Objects can contain objects:
-
-```js
-math.evaluate('{a: 2, b: {c: 3, d: 4}}') // {a: 2, b: {c: 3, d: 4}}
-```
-
-Object properties can be retrieved or replaced using dot notation or bracket
-notation. Unlike JavaScript, when setting a property value, the whole object
-is returned, not the property value
-
-```js
-let scope = {
- obj: {
- prop: 42
- }
-}
-
-// retrieve properties
-math.evaluate('obj.prop', scope) // 42
-math.evaluate('obj["prop"]', scope) // 42
-
-// set properties (returns the whole object, not the property value!)
-math.evaluate('obj.prop = 43', scope) // {prop: 43}
-math.evaluate('obj["prop"] = 43', scope) // {prop: 43}
-scope.obj // {prop: 43}
-```
-
-
-
-
-An expression can contain multiple lines, and expressions can be spread over
-multiple lines. Lines can be separated by a newline character `\n` or by a
-semicolon `;`. Output of statements followed by a semicolon will be hidden from
-the output, and empty lines are ignored. The output is returned as a `ResultSet`,
-with an entry for every visible statement.
-
-```js
-// a multi-line expression
-math.evaluate('1 * 3 \n 2 * 3 \n 3 * 3') // ResultSet, [3, 6, 9]
-
-// semicolon statements are hidden from the output
-math.evaluate('a=3; b=4; a + b \n a * b') // ResultSet, [7, 12]
-
-// single expression spread over multiple lines
-math.evaluate('a = 2 +\n 3') // 5
-math.evaluate('[\n 1, 2;\n 3, 4\n]') // Matrix, [[1, 2], [3, 4]]
-```
-
-The results can be read from a `ResultSet` via the property `ResultSet.entries`
-which is an `Array`, or by calling `ResultSet.valueOf()`, which returns the
-array with results.
-
-
-
-
-*Implicit multiplication* means the multiplication of two symbols, numbers, or a grouped expression inside parentheses without using the `*` operator. This type of syntax allows a more natural way to enter expressions. For example:
-
-```js
-math.evaluate('2 pi') // 6.283185307179586
-math.evaluate('(1+2)(3+4)') // 21
-```
-
-Parentheses are parsed as a function call when there is a symbol or accessor on
-the left hand side, like `sqrt(4)` or `obj.method(4)`. In other cases the
-parentheses are interpreted as an implicit multiplication.
-
-Math.js will always evaluate implicit multiplication before explicit multiplication `*`, so that the expression `x * y z` is parsed as `x * (y * z)`. Math.js also gives implicit multiplication higher precedence than division, *except* when the division matches the pattern `[unaryPrefixOp]?[number] / [number] [symbol]` or `[unaryPrefixOp]?[number] / [number] [left paren]`. In that special case, the division is evaluated first:
-
-```js
-math.evaluate('20 kg / 4 kg') // 5 Evaluated as (20 kg) / (4 kg)
-math.evaluate('20 / 4 kg') // 5 kg Evaluated as (20 / 4) kg
-```
-
-The behavior of implicit multiplication can be summarized by these operator precedence rules, listed from highest to lowest precedence:
-
-- Function calls: `[symbol] [left paren]`
-- Explicit division `/` when the division matches this pattern: `[+-~]?[number] / [+-~]?[number] [symbol]` or `[number] / [number] [left paren]`
-- Implicit multiplication
-- All other division `/` and multiplication `*`
-
-Implicit multiplication is tricky as there can appear to be ambiguity in how an expression will be evaluated. Experience has shown that the above rules most closely match user intent when entering expressions that could be interpreted different ways. It's also possible that these rules could be tweaked in future major releases. Use implicit multiplication carefully. If you don't like the uncertainty introduced by implicit multiplication, use explicit `*` operators and parentheses to ensure your expression is evaluated the way you intend.
-
-Here are some more examples using implicit multiplication:
-
-Expression | Evaluated as | Result
---------------- | ------------------- | ------------------
-(1 + 3) pi | (1 + 3) * pi | 12.566370614359172
-(4 - 1) 2 | (4 - 1) * 2 | 6
-3 / 4 mm | (3 / 4) * mm | 0.75 mm
-2 + 3 i | 2 + (3 * i) | 2 + 3i
-(1 + 2) (4 - 2) | (1 + 2) * (4 - 2) | 6
-sqrt(4) (1 + 2) | sqrt(4) * (1 + 2) | 6
-8 pi / 2 pi | (8 * pi) / (2 * pi) | 4
-pi / 2 pi | pi / (2 * pi) | 0.5
-1 / 2i | (1 / 2) * i | 0.5 i
-8.314 J / mol K | 8.314 J / (mol * K) | 8.314 J / (mol * K)
-
-
-
-
-Comments can be added to explain or describe calculations in the text. A comment
-starts with a sharp sign character `#`, and ends at the end of the line. A line
-can contain a comment only, or can contain an expression followed by a comment.
-
-```js
-const parser = math.parser()
-
-parser.evaluate('# define some variables')
-parser.evaluate('width = 3') // 3
-parser.evaluate('height = 4') // 4
-parser.evaluate('width * height # calculate the area') // 12
-```
diff --git a/docs/getting_started.md b/docs/getting_started.md
deleted file mode 100644
index e12c510578..0000000000
--- a/docs/getting_started.md
+++ /dev/null
@@ -1,128 +0,0 @@
----
-layout: default
----
-
-
-
-Math.js can be installed using various package managers like [npm](https://npmjs.org/), or by just downloading the library from the website: [https://mathjs.org/download.html](https://mathjs.org/download.html).
-
-To install via npm, run:
-
- npm install mathjs
-
-Other ways to install math.js are described on the [website](https://mathjs.org/download.html).
-
-
-
-
-Math.js can be used in node.js and in the browser. The library must be loaded
-and instantiated. When creating an instance, one can optionally provide
-configuration options as described in
-[Configuration](core/configuration.html).
-
-
-
-Load the functions you need and use them:
-
-```js
-import { sqrt } from 'mathjs'
-
-console.log(sqrt(-4).toString()) // 2i
-```
-
-To use lightweight, number only implementations of all functions:
-
-```js
-import { sqrt } from 'mathjs/number'
-
-console.log(sqrt(4).toString()) // 2
-console.log(sqrt(-4).toString()) // NaN
-```
-
-You can create a mathjs instance allowing [configuration](core/configuration.html) and importing of external functions as follows:
-
-```js
-import { create, all } from 'mathjs'
-
-const config = { }
-const math = create(all, config)
-
-console.log(math.sqrt(-4).toString()) // 2i
-```
-
-How to optimize your bundle size using tree-shaking is described on the page
-[Custom bundling](custom_bundling.html).
-
-
-
-
-Math.js can be loaded as a regular JavaScript file in the browser, use the global
-variable `math` to access the libary once loaded:
-
-```html
-
-
-
-
-
-
-
-
-
-```
-
-
-
-[Math.js](https://mathjs.org) 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.
-
-Math.js can be used in the browser, in node.js and in any JavaScript engine. Installation and download instructions are available on the [Download page](https://mathjs.org/download.html) of the website.
-
-
-
-This page lists all the various class types in Math.js. Every top-level function is listed here and links to its detailed reference to other parts of the documentation.
-
-
-
-The "math" namespace contains the entire math.js functionality. All of the mathematical functions are available in the "math" namespace, and allow for inputs of various types.
-
-- [Function reference](functions.html)
-- [Constant reference](constants.html)
-
-
-
-
-Stores values for a scalar unit and its postfix. (eg `100 mm` or `100 kg`). Although the `Unit` class contains public functions documented as follows, using the following API directly is *not* recommended. Prefer using the functions in the "math" namespace wherever possible.
-
-- [Overview](../datatypes/units.html)
-- [Class API](classes/unit.html)
-
-
-
-
-Two types of matrix classes are available in math.js, for storage of dense and sparse matrices. Although they contain public functions documented as follows, using the following API directly is *not* recommended. Prefer using the functions in the "math" namespace wherever possible.
-
-- [Overview](../datatypes/matrices.html)
-- [DenseMatrix](classes/densematrix.html)
-- [SparseMatrix](classes/sparsematrix.html)
-
-Classes used internally that may be of use to developers:
-
-- [Index](classes/matrixindex.html)
-- [Range](classes/matrixrange.html)
-- [ResultSet](classes/resultset.html)
-- [FibonacciHeap](classes/fibonacciheap.html)
-
-
-
-A node in an expression-tree, which can be used to analyze, manipulate, and evaluate expressions.
-
-- [Overview](../expressions/expression_trees.html)
-
-`Node` is the base class of all other node classes:
-
-- [AccessorNode](../expressions/expression_trees.html#accessornode)
-- [ArrayNode](../expressions/expression_trees.html#arraynode)
-- [AssignmentNode](../expressions/expression_trees.html#assignmentnode)
-- [BlockNode](../expressions/expression_trees.html#blocknode)
-- [ConditionalNode](../expressions/expression_trees.html#conditionalnode)
-- [ConstantNode](../expressions/expression_trees.html#constantnode)
-- [FunctionAssignmentNode](../expressions/expression_trees.html#functionassignmentnode)
-- [FunctionNode](../expressions/expression_trees.html#functionnode)
-- [IndexNode](../expressions/expression_trees.html#indexnode)
-- [ObjectNode](../expressions/expression_trees.html#objectnode)
-- [OperatorNode](../expressions/expression_trees.html#operatornode)
-- [ParenthesisNode](../expressions/expression_trees.html#parenthesisnode)
-- [RangeNode](../expressions/expression_trees.html#rangenode)
-- [SymbolNode](../expressions/expression_trees.html#symbolnode)
diff --git a/docs/reference/classes/densematrix.md b/docs/reference/classes/densematrix.md
deleted file mode 100644
index 2342745fc9..0000000000
--- a/docs/reference/classes/densematrix.md
+++ /dev/null
@@ -1,251 +0,0 @@
----
-layout: default
----
-
-
-
-Get the storage format used by the matrix.
-
-Usage:
-
-```js
-const format = matrix.storage() // retrieve storage format
-```
-
-**Kind**: instance method of DenseMatrix
-**Returns**: string - The storage format.
-
-
-Get the datatype of the data stored in the matrix.
-
-Usage:
-
-```js
-const format = matrix.datatype() // retrieve matrix datatype
-```
-
-**Kind**: instance method of DenseMatrix
-**Returns**: string - The datatype.
-
-
-Get a subset of the matrix, or replace a subset of the matrix.
-
-Usage:
-
-```js
-const subset = matrix.subset(index) // retrieve subset
-const value = matrix.subset(index, replacement) // replace subset
-```
-
-**Kind**: instance method of DenseMatrix
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| index | Index | | |
-| [replacement] | Array | DenseMatrix| \* | | |
-| [defaultValue] | \* | 0 | Default value, filled in on new entries when the matrix is resized. If not provided, new matrix elements will be filled with zeros. |
-
-
-
-Get a single element from the matrix.
-
-**Kind**: instance method of DenseMatrix
-**Returns**: \* - value
-
-| Param | Type | Description |
-| --- | --- | --- |
-| index | Array.<number> | Zero-based index |
-
-
-
-Replace a single element in the matrix.
-
-**Kind**: instance method of DenseMatrix
-**Returns**: DenseMatrix- self
-
-| Param | Type | Description |
-| --- | --- | --- |
-| index | Array.<number> | Zero-based index |
-| value | \* | |
-| [defaultValue] | \* | Default value, filled in on new entries when the matrix is resized. If not provided, new matrix elements will be left undefined. |
-
-
-
-Resize the matrix to the given size. Returns a copy of the matrix when
-`copy=true`, otherwise return the matrix itself (resize in place).
-
-**Kind**: instance method of DenseMatrix
-**Returns**: Matrix - The resized matrix
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| size | Array.<number> | | The new size the matrix should have. |
-| [defaultValue] | \* | 0 | Default value, filled in on new entries. If not provided, the matrix elements will be filled with zeros. |
-| [copy] | boolean | | Return a resized copy of the matrix |
-
-
-
-Create a new matrix with the results of the callback function executed on
-each entry of the matrix.
-
-**Kind**: instance method of DenseMatrix
-**Returns**: DenseMatrix- matrix
-
-| Param | Type | Description |
-| --- | --- | --- |
-| callback | function | The callback function is invoked with three parameters: the value of the element, the index of the element, and the Matrix being traversed. |
-
-
-
-Execute a callback function on each entry of the matrix.
-
-**Kind**: instance method of DenseMatrix
-
-| Param | Type | Description |
-| --- | --- | --- |
-| callback | function | The callback function is invoked with three parameters: the value of the element, the index of the element, and the Matrix being traversed. |
-
-
-
-Get a string representation of the matrix, with optional formatting options.
-
-**Kind**: instance method of DenseMatrix
-**Returns**: string - str
-
-| Param | Type | Description |
-| --- | --- | --- |
-| [options] | Object | number | function | Formatting options. See lib/utils/number:format for a description of the available options. |
-
-
-
-Create a diagonal matrix.
-
-**Kind**: static method of DenseMatrix
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| size | Array | | The matrix size. |
-| value | number | Array | | The values for the diagonal. |
-| [k] | number | BigNumber | 0 | The kth diagonal where the vector will be filled in. |
-| [defaultValue] | number | | The default value for non-diagonal |
-
-
-
-Inserts a new data element into the heap. No heap consolidation is
performed at this time, the new node is simply inserted into the root
list of this heap. Running time: O(1) actual.
-
-**Kind**: instance method of [FibonacciHeap](#FibonacciHeap)
-
-
-Removes a node from the heap given the reference to the node. The trees
in the heap will be consolidated, if necessary. This operation may fail
to remove the correct element if there are nodes with key value -Infinity.
Running time: O(log n) amortized.
-
-**Kind**: instance method of [FibonacciHeap](#FibonacciHeap)
-
-
-Decreases the key value for a heap node, given the new value to take on.
The structure of the heap may be changed and will not be consolidated.
Running time: O(1) amortized.
-
-**Kind**: static method of [FibonacciHeap](#FibonacciHeap)
-
-
-The reverse of the link operation: removes node from the child list of parent.
This method assumes that min is non-null. Running time: O(1).
-
-**Kind**: static method of [FibonacciHeap](#FibonacciHeap)
-
-
-Performs a cascading cut operation. This cuts node from its parent and then
does the same for its parent, and so on up the tree.
Running time: O(log n); O(1) excluding the recursion.
-
-**Kind**: static method of [FibonacciHeap](#FibonacciHeap)
-
-
-Create an index. An Index can store ranges and sets for multiple dimensions.
-Matrix.get, Matrix.set, and math.subset accept an Index as input.
-
-Usage:
-```js
-const index = new Index(range1, range2, matrix1, array1, ...)
-```
-
-Where each parameter can be any of:
-
-- A number
-- An instance of Range
-- An Array with the Set values
-- A Matrix with the Set values
-
-The parameters start, end, and step must be integer numbers.
-
-
-| Param | Type |
-| --- | --- |
-| ...ranges | \* |
-
-
-
-Get the primitive value of the Index, a two dimensional array.
-Equivalent to Index.toArray().
-
-**Kind**: instance property of [Index](#Index)
-**Returns**: Array - array
-
-
-Retrieve the size of the index, the number of elements for each dimension.
-
-**Kind**: instance method of [Index](#Index)
-**Returns**: Array.<number> - size
-
-
-Loop over each of the ranges of the index
-
-**Kind**: instance method of [Index](#Index)
-
-| Param | Type | Description |
-| --- | --- | --- |
-| callback | function | Called for each range with a Range as first argument, the dimension as second, and the index object as third. |
-
-
-
-Retrieve the dimension for the given index
-
-**Kind**: instance method of [Index](#Index)
-**Returns**: Range | null - range
-
-| Param | Type | Description |
-| --- | --- | --- |
-| dim | Number | Number of the dimension |
-
-
-
-Test whether this index contains only a single value.
-
-This is the case when the index is created with only scalar values as ranges,
-not for ranges resolving into a single value.
-
-**Kind**: instance method of [Index](#Index)
-**Returns**: boolean - isScalar
-
-
-Expand the Index into an array.
-For example new Index([0,3], [2,7]) returns [[0,1,2], [2,3,4,5,6]]
-
-**Kind**: instance method of [Index](#Index)
-**Returns**: Array - array
-
-
-Get the string representation of the index, for example '[2:6]' or '[0:2:10, 4:7, [1,2,3]]'
-
-**Kind**: instance method of [Index](#Index)
-**Returns**: String - str
-
-
-Create a range. A range has a start, step, and end, and contains functions
-to iterate over the range.
-
-A range can be constructed as:
-
-```js
-const range = new Range(start, end)
-const range = new Range(start, end, step)
-```
-
-To get the result of the range:
-
-```js
-range.forEach(function (x) {
- console.log(x)
-})
-range.map(function (x) {
- return math.sin(x)
-})
-range.toArray()
-```
-
-Example usage:
-
-```js
-const c = new Range(2, 6) // 2:1:5
-c.toArray() // [2, 3, 4, 5]
-const d = new Range(2, -3, -1) // 2:-1:-2
-d.toArray() // [2, 1, 0, -1, -2]
-```
-
-| Param | Type | Description |
-| --- | --- | --- |
-| start | number | included lower bound |
-| end | number | excluded upper bound |
-| [step] | number | step size, default value is 1 |
-
-
-
-Retrieve the size of the range.
-Returns an array containing one number, the number of elements in the range.
-
-**Kind**: instance method of [Range](#Range)
-**Returns**: Array.<number> - size
-
-
-Execute a callback function for each value in the range.
-
-**Kind**: instance method of [Range](#Range)
-
-| Param | Type | Description |
-| --- | --- | --- |
-| callback | function | The callback method is invoked with three parameters: the value of the element, the index of the element, and the Range being traversed. |
-
-
-
-Execute a callback function for each value in the Range, and return the
-results as an array
-
-**Kind**: instance method of [Range](#Range)
-**Returns**: Array - array
-
-| Param | Type | Description |
-| --- | --- | --- |
-| callback | function | The callback method is invoked with three parameters: the value of the element, the index of the element, and the Matrix being traversed. |
-
-
-
-Get a string representation of the range, with optional formatting options.
-Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
-
-**Kind**: instance method of [Range](#Range)
-**Returns**: string - str
-
-| Param | Type | Description |
-| --- | --- | --- |
-| [options] | Object | number | function | Formatting options. See lib/utils/number:format for a description of the available options. |
-
-
-
-Parse a string into a range,
-The string contains the start, optional step, and end, separated by a colon.
-If the string does not contain a valid range, null is returned.
-For example str='0:2:11'.
-
-**Kind**: static method of [Range](#Range)
-**Returns**: [Range](#Range) | null - range
-
-| Param | Type |
-| --- | --- |
-| str | string |
-
-
-
-Get the storage format used by the matrix.
-
-Usage:
-```js
-const format = matrix.storage() // retrieve storage format
-```
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: string - The storage format.
-
-
-Get the datatype of the data stored in the matrix.
-
-Usage:
-```js
-const format = matrix.datatype() // retrieve matrix datatype
-```
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: string - The datatype.
-
-
-Get the matrix density.
-
-Usage:
-```js
-const density = matrix.density() // retrieve matrix density
-```
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: number - The matrix density.
-
-
-Get a subset of the matrix, or replace a subset of the matrix.
-
-Usage:
-```js
-const subset = matrix.subset(index) // retrieve subset
-const value = matrix.subset(index, replacement) // replace subset
-```
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| index | Index | | |
-| [replacement] | Array | Maytrix | \* | | |
-| [defaultValue] | \* | 0 | Default value, filled in on new entries when the matrix is resized. If not provided, new matrix elements will be filled with zeros. |
-
-
-
-Get a single element from the matrix.
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: \* - value
-
-| Param | Type | Description |
-| --- | --- | --- |
-| index | Array.<number> | Zero-based index |
-
-
-
-Replace a single element in the matrix.
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: [SparseMatrix](#SparseMatrix) - self
-
-| Param | Type | Description |
-| --- | --- | --- |
-| index | Array.<number> | Zero-based index |
-| value | \* | |
-| [defaultValue] | \* | Default value, filled in on new entries when the matrix is resized. If not provided, new matrix elements will be set to zero. |
-
-
-
-Resize the matrix to the given size. Returns a copy of the matrix when
-`copy=true`, otherwise return the matrix itself (resize in place).
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: Matrix - The resized matrix
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| size | Array.<number> | | The new size the matrix should have. |
-| [defaultValue] | \* | 0 | Default value, filled in on new entries. If not provided, the matrix elements will be filled with zeros. |
-| [copy] | boolean | | Return a resized copy of the matrix |
-
-
-
-Create a new matrix with the results of the callback function executed on
-each entry of the matrix.
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: [SparseMatrix](#SparseMatrix) - matrix
-
-| Param | Type | Description |
-| --- | --- | --- |
-| callback | function | The callback function is invoked with three parameters: the value of the element, the index of the element, and the Matrix being traversed. |
-| [skipZeros] | boolean | Invoke callback function for non-zero values only. |
-
-
-
-Execute a callback function on each entry of the matrix.
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-
-| Param | Type | Description |
-| --- | --- | --- |
-| callback | function | The callback function is invoked with three parameters: the value of the element, the index of the element, and the Matrix being traversed. |
-| [skipZeros] | boolean | Invoke callback function for non-zero values only. |
-
-
-
-Create an Array with a copy of the data of the SparseMatrix
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: Array - array
-
-
-Get the primitive value of the SparseMatrix: a two dimensions array
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: Array - array
-
-
-Get a string representation of the matrix, with optional formatting options.
-
-**Kind**: instance method of [SparseMatrix](#SparseMatrix)
-**Returns**: string - str
-
-| Param | Type | Description |
-| --- | --- | --- |
-| [options] | Object | number | function | Formatting options. See lib/utils/number:format for a description of the available options. |
-
-
-
-A unit can be constructed in the following ways:
-
-```js
-const a = new Unit(value, name)
-const b = new Unit(null, name)
-const c = Unit.parse(str)
-```
-
-Example usage:
-
-```js
-const a = new Unit(5, 'cm') // 50 mm
-const b = Unit.parse('23 kg') // 23 kg
-const c = math.in(a, new Unit(null, 'm') // 0.05 m
-const d = new Unit(9.81, "m/s^2") // 9.81 m/s^2
-```
-
-| Param | Type | Description |
-| --- | --- | --- |
-| [value] | number | BigNumber | Fraction | Complex | boolean | A value like 5.2 |
-| [name] | string | A unit name like "cm" or "inch", or a derived unit of the form: "u1[^ex1] [u2[^ex2] ...] [/ u3[^ex3] [u4[^ex4]]]", such as "kg m^2/s^2", where each unit appearing after the forward slash is taken to be in the denominator. "kg m^2 s^-2" is a synonym and is also acceptable. Any of the units can include a prefix. |
-
-
-
-Return whether the unit is derived (such as m/s, or cm^2, but not N)
-
-**Kind**: instance method of Unit
-**Returns**: boolean - True if the unit is derived
-
-
-check if this unit has given base unit
-If this unit is a derived unit, this will ALWAYS return false, since by definition base units are not derived.
-
-**Kind**: instance method of Unit
-
-| Param | Type |
-| --- | --- |
-| base | BASE_UNITS | STRING | undefined |
-
-
-
-Check if this unit has a base or bases equal to another base or bases
-For derived units, the exponent on each base also must match
-
-**Kind**: instance method of Unit
-**Returns**: boolean - true if equal base
-
-| Param | Type |
-| --- | --- |
-| other | Unit |
-
-
-
-Check if this unit equals another unit
-
-**Kind**: instance method of Unit
-**Returns**: boolean - true if both units are equal
-
-| Param | Type |
-| --- | --- |
-| other | Unit |
-
-
-
-Multiply this unit with another one
-
-**Kind**: instance method of Unit
-**Returns**: Unit - product of this unit and the other unit
-
-| Param | Type |
-| --- | --- |
-| other | Unit |
-
-
-
-Divide this unit by another one
-
-**Kind**: instance method of Unit
-**Returns**: Unit - result of dividing this unit by the other unit
-
-| Param | Type |
-| --- | --- |
-| other | Unit |
-
-
-
-Calculate the power of a unit
-
-**Kind**: instance method of Unit
-**Returns**: Unit - The result: this^p
-
-| Param | Type |
-| --- | --- |
-| p | number | Fraction | BigNumber |
-
-
-
-Calculate the absolute value of a unit
-
-**Kind**: instance method of Unit
-**Returns**: Unit - The result: |x|, absolute value of x
-
-| Param | Type |
-| --- | --- |
-| x | number | Fraction | BigNumber |
-
-
-
-Convert the unit to a specific unit name.
-
-**Kind**: instance method of Unit
-**Returns**: Unit - Returns a clone of the unit with a fixed prefix and unit.
-
-| Param | Type | Description |
-| --- | --- | --- |
-| valuelessUnit | string | Unit | A unit without value. Can have prefix, like "cm" |
-
-
-
-Return the value of the unit when represented with given valueless unit
-
-**Kind**: instance method of Unit
-**Returns**: number - Returns the unit value as number.
-
-| Param | Type | Description |
-| --- | --- | --- |
-| valuelessUnit | string | Unit | For example 'cm' or 'inch' |
-
-
-
unit.toNumeric(valuelessUnit) ⇒ number | BigNumber | Fraction#
-Return the value of the unit in the original numeric type
-
-**Kind**: instance method of Unit
-**Returns**: number | BigNumber | Fraction - Returns the unit value
-
-| Param | Type | Description |
-| --- | --- | --- |
-| valuelessUnit | string | Unit | For example 'cm' or 'inch' |
-
-
-
-Get a JSON representation of the unit
-
-**Kind**: instance method of Unit
-**Returns**: Object - Returns a JSON object structured as:
- `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
-
-
-Get a string representation of the Unit, with optional formatting options.
-
-**Kind**: instance method of Unit
-
-| Param | Type | Description |
-| --- | --- | --- |
-| [options] | Object | number | function | Formatting options. See lib/utils/number:format for a description of the available options. |
-
-
-
-Parse a string into a unit. The value of the unit is parsed as number,
-BigNumber, or Fraction depending on the math.js config setting `number`.
-
-Throws an exception if the provided string does not contain a valid unit or
-cannot be parsed.
-
-**Kind**: static method of Unit
-**Returns**: Unit - unit
-
-| Param | Type | Description |
-| --- | --- | --- |
-| str | string | A string like "5.2 inch", "4e2 cm/s^2" |
-
-
-
-Test if the given expression is a unit.
-The unit can have a prefix but cannot have a value.
-
-**Kind**: static method of Unit
-**Returns**: boolean - true if the given string is a unit
-
-| Param | Type | Description |
-| --- | --- | --- |
-| name | string | A string to be tested whether it is a value less unit. The unit can have prefix, like "cm" |
-
-
-
-
-Math.js contains the following constants.
-
-Constant | Description | Value
---------------- | ----------- | -----
-`e`, `E` | Euler's number, the base of the natural logarithm. | 2.718281828459045
-`i` | Imaginary unit, defined as `i * i = -1`. A complex number is described as `a + b * i`, where a is the real part, and b is the imaginary part. | `sqrt(-1)`
-`Infinity` | Infinity, a number which is larger than the maximum number that can be handled by a floating point number. | `Infinity`
-`LN2` | Returns the natural logarithm of 2. | `0.6931471805599453`
-`LN10` | Returns the natural logarithm of 10. | `2.302585092994046`
-`LOG2E` | Returns the base-2 logarithm of E. | `1.4426950408889634`
-`LOG10E` | Returns the base-10 logarithm of E. | `0.4342944819032518`
-`NaN` | Not a number. | `NaN`
-`null` | Value null. | `null`
-`phi` | Phi is the golden ratio. Two quantities are in the golden ratio if their ratio is the same as the ratio of their sum to the larger of the two quantities. Phi is defined as `(1 + sqrt(5)) / 2` | `1.618033988749895`
-`pi`, `PI` | The number pi is a mathematical constant that is the ratio of a circle\'s circumference to its diameter. | `3.141592653589793`
-`SQRT1_2` | Returns the square root of 1/2. | `0.7071067811865476`
-`SQRT2` | Returns the square root of 2. | `1.4142135623730951`
-`tau` | Tau is the ratio constant of a circle\'s circumference to radius, equal to `2 * pi`. | `6.283185307179586`
-`undefined` | An undefined value. Preferably, use `null` to indicate undefined values. | `undefined`
-`version` | Returns the version number of math.js. | For example `0.24.1`
-
-Example usage:
-
-```js
-math.sin(math.pi / 4) // 0.70711
-math.multiply(math.i, math.i) // -1
-```
diff --git a/docs/reference/functions.md b/docs/reference/functions.md
deleted file mode 100644
index e8131920c8..0000000000
--- a/docs/reference/functions.md
+++ /dev/null
@@ -1,323 +0,0 @@
----
-layout: default
----
-
-
-
-Function | Description
----- | -----------
-[math.compile(expr)](functions/compile.html) | Parse and compile an expression.
-[math.evaluate(expr [, scope])](functions/evaluate.html) | Evaluate an expression.
-[math.help(search)](functions/help.html) | Retrieve help on a function or data type.
-[math.parser()](functions/parser.html) | Create a `math.
-
-
-
-Function | Description
----- | -----------
-[math.derivative(expr, variable)](functions/derivative.html) | Takes the derivative of an expression expressed in parser Nodes.
-[math.leafCount(expr)](functions/leafCount.html) | Gives the number of "leaf nodes" in the parse tree of the given expression A leaf node is one that has no subexpressions, essentially either a symbol or a constant.
-[math.lsolve(L, b)](functions/lsolve.html) | Finds one solution of a linear equation system by forwards substitution.
-[math.lsolveAll(L, b)](functions/lsolveAll.html) | Finds all solutions of a linear equation system by forwards substitution.
-[math.lup(A)](functions/lup.html) | Calculate the Matrix LU decomposition with partial pivoting.
-[math.lusolve(A, b)](functions/lusolve.html) | Solves the linear system `A * x = b` where `A` is an [n x n] matrix and `b` is a [n] column vector.
-[math.lyap(A, Q)](functions/lyap.html) | Solves the Continuous-time Lyapunov equation AP+PA'+Q=0 for P, where Q is an input matrix.
-[math.polynomialRoot(constant, linearCoeff, quadraticCoeff, cubicCoeff)](functions/polynomialRoot.html) | Finds the numerical values of the distinct roots of a polynomial with real or complex coefficients.
-[math.qr(A)](functions/qr.html) | Calculate the Matrix QR decomposition.
-[math.rationalize(expr)](functions/rationalize.html) | Transform a rationalizable expression in a rational fraction.
-[math.resolve(expr, scope)](functions/resolve.html) | resolve(expr, scope) replaces variable nodes with their scoped values.
-[math.schur(A)](functions/schur.html) | Performs a real Schur decomposition of the real matrix A = UTU' where U is orthogonal and T is upper quasi-triangular.
-[math.simplify(expr)](functions/simplify.html) | Simplify an expression tree.
-[math.simplifyConstant(expr)](functions/simplifyConstant.html) | simplifyConstant() takes a mathjs expression (either a Node representing a parse tree or a string which it parses to produce a node), and replaces any subexpression of it consisting entirely of constants with the computed value of that subexpression.
-[math.simplifyCore(expr)](functions/simplifyCore.html) | simplifyCore() performs single pass simplification suitable for applications requiring ultimate performance.
-[math.slu(A, order, threshold)](functions/slu.html) | Calculate the Sparse Matrix LU decomposition with full pivoting.
-[math.sylvester(A, B, C)](functions/sylvester.html) | Solves the real-valued Sylvester equation AX+XB=C for X, where A, B and C are matrices of appropriate dimensions, being A and B squared.
-[math.symbolicEqual(expr1, expr2)](functions/symbolicEqual.html) | Attempts to determine if two expressions are symbolically equal, i.
-[math.usolve(U, b)](functions/usolve.html) | Finds one solution of a linear equation system by backward substitution.
-[math.usolveAll(U, b)](functions/usolveAll.html) | Finds all solutions of a linear equation system by backward substitution.
-
-
-
-Function | Description
----- | -----------
-[math.abs(x)](functions/abs.html) | Calculate the absolute value of a number.
-[math.add(x, y)](functions/add.html) | Add two or more values, `x + y`.
-[math.cbrt(x [, allRoots])](functions/cbrt.html) | Calculate the cubic root of a value.
-[math.ceil(x)](functions/ceil.html) | Round a value towards plus infinity If `x` is complex, both real and imaginary part are rounded towards plus infinity.
-[math.cube(x)](functions/cube.html) | Compute the cube of a value, `x * x * x`.
-[math.divide(x, y)](functions/divide.html) | Divide two values, `x / y`.
-[math.dotDivide(x, y)](functions/dotDivide.html) | Divide two matrices element wise.
-[math.dotMultiply(x, y)](functions/dotMultiply.html) | Multiply two matrices element wise.
-[math.dotPow(x, y)](functions/dotPow.html) | Calculates the power of x to y element wise.
-[math.exp(x)](functions/exp.html) | Calculate the exponential of a value.
-[math.expm1(x)](functions/expm1.html) | Calculate the value of subtracting 1 from the exponential value.
-[math.fix(x)](functions/fix.html) | Round a value towards zero.
-[math.floor(x)](functions/floor.html) | Round a value towards minus infinity.
-[math.gcd(a, b)](functions/gcd.html) | Calculate the greatest common divisor for two or more values or arrays.
-[math.hypot(a, b, ...)](functions/hypot.html) | Calculate the hypotenuse of a list with values.
-[math.invmod(a, b)](functions/invmod.html) | Calculate the (modular) multiplicative inverse of a modulo b.
-[math.lcm(a, b)](functions/lcm.html) | Calculate the least common multiple for two or more values or arrays.
-[math.log(x [, base])](functions/log.html) | Calculate the logarithm of a value.
-[math.log10(x)](functions/log10.html) | Calculate the 10-base logarithm of a value.
-[math.log1p(x)](functions/log1p.html) | Calculate the logarithm of a `value+1`.
-[math.log2(x)](functions/log2.html) | Calculate the 2-base of a value.
-[math.mod(x, y)](functions/mod.html) | Calculates the modulus, the remainder of an integer division.
-[math.multiply(x, y)](functions/multiply.html) | Multiply two or more values, `x * y`.
-[math.norm(x [, p])](functions/norm.html) | Calculate the norm of a number, vector or matrix.
-[math.nthRoot(a)](functions/nthRoot.html) | Calculate the nth root of a value.
-[math.nthRoots(x)](functions/nthRoots.html) | Calculate the nth roots of a value.
-[math.pow(x, y)](functions/pow.html) | Calculates the power of x to y, `x ^ y`.
-[math.round(x [, n])](functions/round.html) | Round a value towards the nearest rounded value.
-[math.sign(x)](functions/sign.html) | Compute the sign of a value.
-[math.sqrt(x)](functions/sqrt.html) | Calculate the square root of a value.
-[math.square(x)](functions/square.html) | Compute the square of a value, `x * x`.
-[math.subtract(x, y)](functions/subtract.html) | Subtract two values, `x - y`.
-[math.unaryMinus(x)](functions/unaryMinus.html) | Inverse the sign of a value, apply a unary minus operation.
-[math.unaryPlus(x)](functions/unaryPlus.html) | Unary plus operation.
-[math.xgcd(a, b)](functions/xgcd.html) | Calculate the extended greatest common divisor for two values.
-
-
-
-Function | Description
----- | -----------
-[math.bitAnd(x, y)](functions/bitAnd.html) | Bitwise AND two values, `x & y`.
-[math.bitNot(x)](functions/bitNot.html) | Bitwise NOT value, `~x`.
-[math.bitOr(x, y)](functions/bitOr.html) | Bitwise OR two values, `x | y`.
-[math.bitXor(x, y)](functions/bitXor.html) | Bitwise XOR two values, `x ^ y`.
-[math.leftShift(x, y)](functions/leftShift.html) | Bitwise left logical shift of a value x by y number of bits, `x << y`.
-[math.rightArithShift(x, y)](functions/rightArithShift.html) | Bitwise right arithmetic shift of a value x by y number of bits, `x >> y`.
-[math.rightLogShift(x, y)](functions/rightLogShift.html) | Bitwise right logical shift of value x by y number of bits, `x >>> y`.
-
-
-
-Function | Description
----- | -----------
-[math.bellNumbers(n)](functions/bellNumbers.html) | The Bell Numbers count the number of partitions of a set.
-[math.catalan(n)](functions/catalan.html) | The Catalan Numbers enumerate combinatorial structures of many different types.
-[math.composition(n, k)](functions/composition.html) | The composition counts of n into k parts.
-[math.stirlingS2(n, k)](functions/stirlingS2.html) | The Stirling numbers of the second kind, counts the number of ways to partition a set of n labelled objects into k nonempty unlabelled subsets.
-
-
-
-Function | Description
----- | -----------
-[math.arg(x)](functions/arg.html) | Compute the argument of a complex value.
-[math.conj(x)](functions/conj.html) | Compute the complex conjugate of a complex value.
-[math.im(x)](functions/im.html) | Get the imaginary part of a complex number.
-[math.re(x)](functions/re.html) | Get the real part of a complex number.
-
-
-
-Function | Description
----- | -----------
-[math.distance([x1,y1], [x2,y2])](functions/distance.html) | Calculates: The eucledian distance between two points in N-dimensional spaces.
-[math.intersect(endPoint1Line1, endPoint2Line1, endPoint1Line2, endPoint2Line2)](functions/intersect.html) | Calculates the point of intersection of two lines in two or three dimensions and of a line and a plane in three dimensions.
-
-
-
-Function | Description
----- | -----------
-[math.column(value, index)](functions/column.html) | Return a column from a Matrix.
-[math.concat(a, b, c, ... [, dim])](functions/concat.html) | Concatenate two or more matrices.
-[math.count(x)](functions/count.html) | Count the number of elements of a matrix, array or string.
-[math.cross(x, y)](functions/cross.html) | Calculate the cross product for two vectors in three dimensional space.
-[math.ctranspose(x)](functions/ctranspose.html) | Transpose and complex conjugate a matrix.
-[math.det(x)](functions/det.html) | Calculate the determinant of a matrix.
-[math.diag(X)](functions/diag.html) | Create a diagonal matrix or retrieve the diagonal of a matrix When `x` is a vector, a matrix with vector `x` on the diagonal will be returned.
-[math.diff(arr)](functions/diff.html) | Create a new matrix or array of the difference between elements of the given array The optional dim parameter lets you specify the dimension to evaluate the difference of If no dimension parameter is passed it is assumed as dimension 0 Dimension is zero-based in javascript and one-based in the parser and can be a number or bignumber Arrays must be 'rectangular' meaning arrays like [1, 2] If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays.
-[math.dot(x, y)](functions/dot.html) | Calculate the dot product of two vectors.
-[math.eigs(x, [prec])](functions/eigs.html) | Compute eigenvalues and optionally eigenvectors of a square matrix.
-[math.expm(x)](functions/expm.html) | Compute the matrix exponential, expm(A) = e^A.
-[math.fft(arr)](functions/fft.html) | Calculate N-dimensional Fourier transform.
-[math.filter(x, test)](functions/filter.html) | Filter the items in an array or one dimensional matrix.
-[math.flatten(x)](functions/flatten.html) | Flatten a multidimensional matrix into a single dimensional matrix.
-[math.forEach(x, callback)](functions/forEach.html) | Iterate over all elements of a matrix/array, and executes the given callback function.
-[math.getMatrixDataType(x)](functions/getMatrixDataType.html) | Find the data type of all elements in a matrix or array, for example 'number' if all items are a number and 'Complex' if all values are complex numbers.
-[math.identity(n)](functions/identity.html) | Create a 2-dimensional identity matrix with size m x n or n x n.
-[math.ifft(arr)](functions/ifft.html) | Calculate N-dimensional inverse Fourier transform.
-[math.inv(x)](functions/inv.html) | Calculate the inverse of a square matrix.
-[math.kron(x, y)](functions/kron.html) | Calculates the Kronecker product of 2 matrices or vectors.
-[math.map(x, callback)](functions/map.html) | Create a new matrix or array with the results of a callback function executed on each entry of a given matrix/array.
-[math.mapSlices(A, dim, callback)](functions/mapSlices.html) | Apply a function that maps an array to a scalar along a given axis of a matrix or array.
-[math.matrixFromColumns(...arr)](functions/matrixFromColumns.html) | Create a dense matrix from vectors as individual columns.
-[math.matrixFromFunction(size, fn)](functions/matrixFromFunction.html) | Create a matrix by evaluating a generating function at each index.
-[math.matrixFromRows(...arr)](functions/matrixFromRows.html) | Create a dense matrix from vectors as individual rows.
-[math.ones(m, n, p, ...)](functions/ones.html) | Create a matrix filled with ones.
-[math.partitionSelect(x, k)](functions/partitionSelect.html) | Partition-based selection of an array or 1D matrix.
-[math.pinv(x)](functions/pinv.html) | Calculate the Moore–Penrose inverse of a matrix.
-[math.range(start, end [, step])](functions/range.html) | Create an array from a range.
-[math.reshape(x, sizes)](functions/reshape.html) | Reshape a multi dimensional array to fit the specified dimensions.
-[math.resize(x, size [, defaultValue])](functions/resize.html) | Resize a matrix.
-[math.rotate(w, theta)](functions/rotate.html) | 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.
-[math.rotationMatrix(theta)](functions/rotationMatrix.html) | Create a 2-dimensional counter-clockwise rotation matrix (2x2) for a given angle (expressed in radians).
-[math.row(value, index)](functions/row.html) | Return a row from a Matrix.
-[math.size(x)](functions/size.html) | Calculate the size of a matrix or scalar.
-[math.sort(x)](functions/sort.html) | Sort the items in a matrix.
-[math.sqrtm(A)](functions/sqrtm.html) | Calculate the principal square root of a square matrix.
-[math.squeeze(x)](functions/squeeze.html) | Squeeze a matrix, remove inner and outer singleton dimensions from a matrix.
-[math.subset(x, index [, replacement])](functions/subset.html) | Get or set a subset of a matrix or string.
-[math.trace(x)](functions/trace.html) | Calculate the trace of a matrix: the sum of the elements on the main diagonal of a square matrix.
-[math.transpose(x)](functions/transpose.html) | Transpose a matrix.
-[math.zeros(m, n, p, ...)](functions/zeros.html) | Create a matrix filled with zeros.
-
-
-
-Function | Description
----- | -----------
-[math.combinations(n, k)](functions/combinations.html) | Compute the number of ways of picking `k` unordered outcomes from `n` possibilities.
-[math.combinationsWithRep(n, k)](functions/combinationsWithRep.html) | Compute the number of ways of picking `k` unordered outcomes from `n` possibilities, allowing individual outcomes to be repeated more than once.
-[math.factorial(n)](functions/factorial.html) | Compute the factorial of a value Factorial only supports an integer value as argument.
-[math.gamma(n)](functions/gamma.html) | Compute the gamma function of a value using Lanczos approximation for small values, and an extended Stirling approximation for large values.
-[math.kldivergence(x, y)](functions/kldivergence.html) | Calculate the Kullback-Leibler (KL) divergence between two distributions.
-[math.lgamma(n)](functions/lgamma.html) | Logarithm of the gamma function for real, positive numbers and complex numbers, using Lanczos approximation for numbers and Stirling series for complex numbers.
-[math.multinomial(a)](functions/multinomial.html) | Multinomial Coefficients compute the number of ways of picking a1, a2, .
-[math.permutations(n [, k])](functions/permutations.html) | Compute the number of ways of obtaining an ordered subset of `k` elements from a set of `n` elements.
-[math.pickRandom(array)](functions/pickRandom.html) | Random pick one or more values from a one dimensional array.
-[math.random([min, max])](functions/random.html) | Return a random number larger or equal to `min` and smaller than `max` using a uniform distribution.
-[math.randomInt([min, max])](functions/randomInt.html) | Return a random integer number larger or equal to `min` and smaller than `max` using a uniform distribution.
-
-
-
-Function | Description
----- | -----------
-[math.compare(x, y)](functions/compare.html) | Compare two values.
-[math.compareNatural(x, y)](functions/compareNatural.html) | Compare two values of any type in a deterministic, natural way.
-[math.compareText(x, y)](functions/compareText.html) | Compare two strings lexically.
-[math.deepEqual(x, y)](functions/deepEqual.html) | Test element wise whether two matrices are equal.
-[math.equal(x, y)](functions/equal.html) | Test whether two values are equal.
-[math.equalText(x, y)](functions/equalText.html) | Check equality of two strings.
-[math.larger(x, y)](functions/larger.html) | Test whether value x is larger than y.
-[math.largerEq(x, y)](functions/largerEq.html) | Test whether value x is larger or equal to y.
-[math.smaller(x, y)](functions/smaller.html) | Test whether value x is smaller than y.
-[math.smallerEq(x, y)](functions/smallerEq.html) | Test whether value x is smaller or equal to y.
-[math.unequal(x, y)](functions/unequal.html) | Test whether two values are unequal.
-
-
-
-Function | Description
----- | -----------
-[math.setCartesian(set1, set2)](functions/setCartesian.html) | Create the cartesian product of two (multi)sets.
-[math.setDifference(set1, set2)](functions/setDifference.html) | Create the difference of two (multi)sets: every element of set1, that is not the element of set2.
-[math.setDistinct(set)](functions/setDistinct.html) | Collect the distinct elements of a multiset.
-[math.setIntersect(set1, set2)](functions/setIntersect.html) | Create the intersection of two (multi)sets.
-[math.setIsSubset(set1, set2)](functions/setIsSubset.html) | Check whether a (multi)set is a subset of another (multi)set.
-[math.setMultiplicity(element, set)](functions/setMultiplicity.html) | Count the multiplicity of an element in a multiset.
-[math.setPowerset(set)](functions/setPowerset.html) | Create the powerset of a (multi)set.
-[math.setSize(set)](functions/setSize.html) | Count the number of elements of a (multi)set.
-[math.setSymDifference(set1, set2)](functions/setSymDifference.html) | Create the symmetric difference of two (multi)sets.
-[math.setUnion(set1, set2)](functions/setUnion.html) | Create the union of two (multi)sets.
-
-
-
-Function | Description
----- | -----------
-[math.freqz(b, a)](functions/freqz.html) | Calculates the frequency response of a filter given its numerator and denominator coefficients.
-[math.zpk2tf(z, p, k)](functions/zpk2tf.html) | Compute the transfer function of a zero-pole-gain model.
-
-
-
-Function | Description
----- | -----------
-[math.erf(x)](functions/erf.html) | Compute the erf function of a value using a rational Chebyshev approximations for different intervals of x.
-[math.zeta(n)](functions/zeta.html) | Compute the Riemann Zeta function of a value using an infinite series for all of the complex plane using Riemann's Functional equation.
-
-
-
-Function | Description
----- | -----------
-[math.corr(A, B)](functions/corr.html) | Compute the correlation coefficient of a two list with values, For matrices, the matrix correlation coefficient is calculated.
-[math.cumsum(a, b, c, ...)](functions/cumsum.html) | Compute the cumulative sum of a matrix or a list with values.
-[math.mad(a, b, c, ...)](functions/mad.html) | Compute the median absolute deviation of a matrix or a list with values.
-[math.max(a, b, c, ...)](functions/max.html) | Compute the maximum value of a matrix or a list with values.
-[math.mean(a, b, c, ...)](functions/mean.html) | Compute the mean value of matrix or a list with values.
-[math.median(a, b, c, ...)](functions/median.html) | Compute the median of a matrix or a list with values.
-[math.min(a, b, c, ...)](functions/min.html) | Compute the minimum value of a matrix or a list of values.
-[math.mode(a, b, c, ...)](functions/mode.html) | Computes the mode of a set of numbers or a list with values(numbers or characters).
-[math.prod(a, b, c, ...)](functions/prod.html) | Compute the product of a matrix or a list with values.
-[math.quantileSeq(A, prob[, sorted])](functions/quantileSeq.html) | Compute the prob order quantile of a matrix or a list with values.
-[math.std(a, b, c, ...)](functions/std.html) | Compute the standard deviation of a matrix or a list with values.
-[math.sum(a, b, c, ...)](functions/sum.html) | Compute the sum of a matrix or a list with values.
-[math.variance(a, b, c, ...)](functions/variance.html) | Compute the variance of a matrix or a list with values.
-
-
-
-Function | Description
----- | -----------
-[math.bin(value)](functions/bin.html) | Format a number as binary.
-[math.format(value [, precision])](functions/format.html) | Format a value of any type into a string.
-[math.hex(value)](functions/hex.html) | Format a number as hexadecimal.
-[math.oct(value)](functions/oct.html) | Format a number as octal.
-[math.print(template, values [, precision])](functions/print.html) | Interpolate values into a string template.
-
-
-
-Function | Description
----- | -----------
-[math.acos(x)](functions/acos.html) | Calculate the inverse cosine of a value.
-[math.acosh(x)](functions/acosh.html) | Calculate the hyperbolic arccos of a value, defined as `acosh(x) = ln(sqrt(x^2 - 1) + x)`.
-[math.acot(x)](functions/acot.html) | Calculate the inverse cotangent of a value, defined as `acot(x) = atan(1/x)`.
-[math.acoth(x)](functions/acoth.html) | Calculate the inverse hyperbolic tangent of a value, defined as `acoth(x) = atanh(1/x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.
-[math.acsc(x)](functions/acsc.html) | Calculate the inverse cosecant of a value, defined as `acsc(x) = asin(1/x)`.
-[math.acsch(x)](functions/acsch.html) | Calculate the inverse hyperbolic cosecant of a value, defined as `acsch(x) = asinh(1/x) = ln(1/x + sqrt(1/x^2 + 1))`.
-[math.asec(x)](functions/asec.html) | Calculate the inverse secant of a value.
-[math.asech(x)](functions/asech.html) | Calculate the hyperbolic arcsecant of a value, defined as `asech(x) = acosh(1/x) = ln(sqrt(1/x^2 - 1) + 1/x)`.
-[math.asin(x)](functions/asin.html) | Calculate the inverse sine of a value.
-[math.asinh(x)](functions/asinh.html) | Calculate the hyperbolic arcsine of a value, defined as `asinh(x) = ln(x + sqrt(x^2 + 1))`.
-[math.atan(x)](functions/atan.html) | Calculate the inverse tangent of a value.
-[math.atan2(y, x)](functions/atan2.html) | Calculate the inverse tangent function with two arguments, y/x.
-[math.atanh(x)](functions/atanh.html) | Calculate the hyperbolic arctangent of a value, defined as `atanh(x) = ln((1 + x)/(1 - x)) / 2`.
-[math.cos(x)](functions/cos.html) | Calculate the cosine of a value.
-[math.cosh(x)](functions/cosh.html) | Calculate the hyperbolic cosine of a value, defined as `cosh(x) = 1/2 * (exp(x) + exp(-x))`.
-[math.cot(x)](functions/cot.html) | Calculate the cotangent of a value.
-[math.coth(x)](functions/coth.html) | Calculate the hyperbolic cotangent of a value, defined as `coth(x) = 1 / tanh(x)`.
-[math.csc(x)](functions/csc.html) | Calculate the cosecant of a value, defined as `csc(x) = 1/sin(x)`.
-[math.csch(x)](functions/csch.html) | Calculate the hyperbolic cosecant of a value, defined as `csch(x) = 1 / sinh(x)`.
-[math.sec(x)](functions/sec.html) | Calculate the secant of a value, defined as `sec(x) = 1/cos(x)`.
-[math.sech(x)](functions/sech.html) | Calculate the hyperbolic secant of a value, defined as `sech(x) = 1 / cosh(x)`.
-[math.sin(x)](functions/sin.html) | Calculate the sine of a value.
-[math.sinh(x)](functions/sinh.html) | Calculate the hyperbolic sine of a value, defined as `sinh(x) = 1/2 * (exp(x) - exp(-x))`.
-[math.tan(x)](functions/tan.html) | Calculate the tangent of a value.
-[math.tanh(x)](functions/tanh.html) | Calculate the hyperbolic tangent of a value, defined as `tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1)`.
-
-
-
-Function | Description
----- | -----------
-[math.clone(x)](functions/clone.html) | Clone an object.
-[math.hasNumericValue(x)](functions/hasNumericValue.html) | Test whether a value is an numeric value.
-[math.isInteger(x)](functions/isInteger.html) | Test whether a value is an integer number.
-[math.isNaN(x)](functions/isNaN.html) | Test whether a value is NaN (not a number).
-[math.isNegative(x)](functions/isNegative.html) | Test whether a value is negative: smaller than zero.
-[math.isNumeric(x)](functions/isNumeric.html) | Test whether a value is an numeric value.
-[math.isPositive(x)](functions/isPositive.html) | Test whether a value is positive: larger than zero.
-[math.isPrime(x)](functions/isPrime.html) | Test whether a value is prime: has no divisors other than itself and one.
-[math.isZero(x)](functions/isZero.html) | Test whether a value is zero.
-[math.numeric(x)](functions/numeric.html) | Convert a numeric input to a specific numeric type: number, BigNumber, bigint, or Fraction.
-[math.typeOf(x)](functions/typeOf.html) | Determine the type of an entity.
-
-
-
-
diff --git a/docs/reference/functions/abs.md b/docs/reference/functions/abs.md
deleted file mode 100644
index 73176957e6..0000000000
--- a/docs/reference/functions/abs.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-layout: default
----
-
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Fraction | Complex | Array | Matrix | Unit | A number or matrix for which to get the absolute value
-
-
-
-Calculate the hyperbolic arccos of a value,
-defined as `acosh(x) = ln(sqrt(x^2 - 1) + x)`.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Calculate the inverse cotangent of a value, defined as `acot(x) = atan(1/x)`.
-
-To avoid confusion with the matrix arccotanget, this function does not
-apply to matrices.
-
-
-
-
-Calculate the inverse hyperbolic tangent of a value,
-defined as `acoth(x) = atanh(1/x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.
-
-To avoid confusion with the matrix inverse hyperbolic tangent, this
-function does not apply to matrices.
-
-
-
-
-Calculate the inverse cosecant of a value, defined as `acsc(x) = asin(1/x)`.
-
-To avoid confusion with the matrix arccosecant, this function does not
-apply to matrices.
-
-
-
-
-Calculate the inverse hyperbolic cosecant of a value,
-defined as `acsch(x) = asinh(1/x) = ln(1/x + sqrt(1/x^2 + 1))`.
-
-To avoid confusion with the matrix inverse hyperbolic cosecant, this function
-does not apply to matrices.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Complex | Unit | Array | Matrix | First value to check
-`y` | number | BigNumber | bigint | Complex | Unit | Array | Matrix | Second value to check
-
-
-
-Apply a function that maps an array to a scalar
-along a given axis of a matrix or array.
-Returns a new matrix or array with one less dimension than the input.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`array` | Array | Matrix | The input Matrix
-`dim` | number | The dimension along which the callback is applied
-`callback` | Function | The callback function that is applied. This Function should take an array or 1-d matrix as an input and return a number.
-
-
-
-Compute the argument of a complex value.
-For a complex number `a + bi`, the argument is computed as `atan2(b, a)`.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Calculate the inverse secant of a value. Defined as `asec(x) = acos(1/x)`.
-
-To avoid confusion with the matrix arcsecant, this function does not
-apply to matrices.
-
-
-
-
-Calculate the hyperbolic arcsecant of a value,
-defined as `asech(x) = acosh(1/x) = ln(sqrt(1/x^2 - 1) + 1/x)`.
-
-To avoid confusion with the matrix hyperbolic arcsecant, this function
-does not apply to matrices.
-
-
-
-
-Calculate the hyperbolic arcsine of a value,
-defined as `asinh(x) = ln(x + sqrt(x^2 + 1))`.
-
-To avoid confusion with the matrix hyperbolic arcsine, this function
-does not apply to matrices.
-
-
-
-
-Calculate the inverse tangent function with two arguments, y/x.
-By providing two arguments, the right quadrant of the computed angle can be
-determined.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Calculate the hyperbolic arctangent of a value,
-defined as `atanh(x) = ln((1 + x)/(1 - x)) / 2`.
-
-To avoid confusion with the matrix hyperbolic arctangent, this function
-does not apply to matrices.
-
-
-
-
-The Bell Numbers count the number of partitions of a set. A partition is a pairwise disjoint subset of S whose union is S.
-bellNumbers only takes integer arguments.
-The following condition must be enforced: n >= 0
-
-
-
-
-Create a BigNumber, which can store numbers with arbitrary precision.
-When a matrix is provided, all elements will be converted to BigNumber.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | number | BigNumber | Value to be stringified
-`wordSize` | number | BigNumber | Optional word size (see `format`)
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Array | Matrix | First value to and
-`y` | number | BigNumber | bigint | Array | Matrix | Second value to and
-
-
-
-Bitwise NOT value, `~x`.
-For matrices, the function is evaluated element wise.
-For units, the function is evaluated on the best prefix base.
-
-
-
-
-Bitwise OR two values, `x | y`.
-For matrices, the function is evaluated element wise.
-For units, the function is evaluated on the lowest print base.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Array | Matrix | First value to or
-`y` | number | BigNumber | bigint | Array | Matrix | Second value to or
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Array | Matrix | First value to xor
-`y` | number | BigNumber | bigint | Array | Matrix | Second value to xor
-
-
-
-Create a boolean or convert a string or number to a boolean.
-In case of a number, `true` is returned for non-zero numbers, and `false` in
-case of zero.
-Strings can be `'true'` or `'false'`, or can contain a number.
-When value is a matrix, all elements will be converted to boolean.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | string | number | boolean | Array | Matrix | null | A value of any type
-
-
-
-The Catalan Numbers enumerate combinatorial structures of many different types.
-catalan only takes integer arguments.
-The following condition must be enforced: n >= 0
-
-
-
-
-Calculate the cubic root of a value.
-
-To avoid confusion with the matrix cube root, this function does not
-apply to matrices. For a matrix, to take the cube root elementwise,
-see the examples.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Complex | Unit | Value for which to calculate the cubic root.
-`allRoots` | boolean | Optional, false by default. Only applicable when `x` is a number or complex number. If true, all complex roots are returned, if false (default) the principal root is returned.
-
-
-
-Round a value towards plus infinity
-If `x` is complex, both real and imaginary part are rounded towards plus infinity.
-For matrices, the function is evaluated element wise.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Fraction | Complex | Unit | Array | Matrix | Value to be rounded
-`n` | number | BigNumber | Array | Number of decimals Default value: 0.
-`valuelessUnit` | Unit | A valueless unit
-
-
-
-Wrap any value in a chain, allowing to perform chained operations on
-the value.
-
-All methods available in the math.js library can be called upon the chain,
-and then will be evaluated with the value itself as first argument.
-The chain can be closed by executing `chain.done()`, which returns
-the final value.
-
-The chain has a number of special functions:
-
-- `done()` Finalize the chain and return the chain's value.
-- `valueOf()` The same as `done()`
-- `toString()` Executes `math.format()` onto the chain's value, returning
- a string representation of the value.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | Array | Matrix | An array or matrix
-`column` | number | The index of the column
-
-
-
-Compute the number of ways of picking `k` unordered outcomes from `n`
-possibilities.
-
-Combinations only takes integer arguments.
-The following condition must be enforced: k <= n.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`n` | number | BigNumber | Total number of objects in the set
-`k` | number | BigNumber | Number of objects in the subset
-
-
-
-Compute the number of ways of picking `k` unordered outcomes from `n`
-possibilities, allowing individual outcomes to be repeated more than once.
-
-CombinationsWithRep only takes integer arguments.
-The following condition must be enforced: k <= n + k -1.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`n` | number | BigNumber | Total number of objects in the set
-`k` | number | BigNumber | Number of objects in the subset
-
-
-
-Compare two values. Returns 1 when x > y, -1 when x < y, and 0 when x == y.
-
-x and y are considered equal when the relative difference between x and y
-is smaller than the configured absTol and relTol. The function cannot be used to
-compare values smaller than approximately 2.22e-16.
-
-For matrices, the function is evaluated element wise.
-Strings are compared by their numerical value.
-
-
-
-
-Type | Description
----- | -----------
-number | BigNumber | bigint | Fraction | Array | Matrix | Returns the result of the comparison: 1 when x > y, -1 when x < y, and 0 when x == y.
-
-
-
-
-Compare two values of any type in a deterministic, natural way.
-
-For numeric values, the function works the same as `math.compare`.
-For types of values that can't be compared mathematically,
-the function compares in a natural way.
-
-For numeric values, x and y are considered equal when the relative
-difference between x and y is smaller than the configured relTol and absTol.
-The function cannot be used to compare values smaller than
-approximately 2.22e-16.
-
-For Complex numbers, first the real parts are compared. If equal,
-the imaginary parts are compared.
-
-Strings are compared with a natural sorting algorithm, which
-orders strings in a "logic" way following some heuristics.
-This differs from the function `compare`, which converts the string
-into a numeric value and compares that. The function `compareText`
-on the other hand compares text lexically.
-
-Arrays and Matrices are compared value by value until there is an
-unequal pair of values encountered. Objects are compared by sorted
-keys until the keys or their values are unequal.
-
-
-
-
-Compare two strings lexically. Comparison is case sensitive.
-Returns 1 when x > y, -1 when x < y, and 0 when x == y.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Type | Description
----- | -----------
-number | Array | DenseMatrix | Returns the result of the comparison: 1 when x > y, -1 when x < y, and 0 when x == y.
-
-
-
-
-```js
-math.complex() // creates a complex value with zero
- // as real and imaginary part.
-math.complex(re : number, im : string) // creates a complex value with provided
- // values for real and imaginary part.
-math.complex(re : number) // creates a complex value with provided
- // real value and zero imaginary part.
-math.complex(complex : Complex) // clones the provided complex value.
-math.complex(arg : string) // parses a string into a complex value.
-math.complex(array : Array) // converts the elements of the array
- // or matrix element wise into a
- // complex value.
-math.complex({re: number, im: number}) // creates a complex value with provided
- // values for real an imaginary part.
-math.complex({r: number, phi: number}) // creates a complex value with provided
- // polar coordinates
-```
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`args` | * | Array | Matrix | Arguments specifying the real and imaginary part of the complex number
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`n` | Number | BigNumber | Total number of objects in the set
-`k` | Number | BigNumber | Number of objects in the subset
-
-
-
-Set configuration options for math.js, and get current options.
-Will emit a 'config' event, with arguments (curr, prev, changes).
-
-This function is only available on a mathjs instance created using `create`.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`options` | Object | Available options: {number} epsilon Minimum relative difference between two compared values, used by all comparison functions. {string} matrix A string 'Matrix' (default) or 'Array'. {string} number A string 'number' (default), 'BigNumber', or 'Fraction' {number} precision The number of significant digits for BigNumbers. Not applicable for Numbers. {string} parenthesis How to display parentheses in LaTeX and string output. {string} randomSeed Random seed for seeded pseudo random number generator. Set to null to randomly seed.
-
-
-
-Compute the complex conjugate of a complex value.
-If `x = a+bi`, the complex conjugate of `x` is `a - bi`.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Complex | Array | Matrix | Unit | A complex number or array with complex numbers
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`A` | Array | Matrix | The first array or matrix to compute correlation coefficient
-`B` | Array | Matrix | The second array or matrix to compute correlation coefficient
-
-
-
-Calculate the hyperbolic cosine of a value,
-defined as `cosh(x) = 1/2 * (exp(x) + exp(-x))`.
-
-To avoid confusion with the matrix hyperbolic cosine, this function does
-not apply to matrices.
-
-
-
-
-Calculate the cotangent of a value. Defined as `cot(x) = 1 / tan(x)`.
-
-To avoid confusion with the matrix cotangent, this function does not
-apply to matrices.
-
-
-
-
-Calculate the hyperbolic cotangent of a value,
-defined as `coth(x) = 1 / tanh(x)`.
-
-To avoid confusion with the matrix hyperbolic cotangent, this function
-does not apply to matrices.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`name` | string | The name of the new unit. Must be unique. Example: 'knot'
-`definition` | string, UnitDefinition, Unit | Definition of the unit in terms of existing units. For example, '0.514444444 m / s'.
-`options` | Object | (optional) An object containing any of the following properties:- `prefixes {string}` "none", "short", "long", "binary_short", or "binary_long". The default is "none".- `aliases {Array}` Array of strings. Example: ['knots', 'kt', 'kts']- `offset {Numeric}` An offset to apply when converting from the unit. For example, the offset for celsius is 273.15. Default is 0.
-
-
-
-Calculate the cross product for two vectors in three dimensional space.
-The cross product of `A = [a1, a2, a3]` and `B = [b1, b2, b3]` is defined
-as:
-
- cross(A, B) = [
- a2 * b3 - a3 * b2,
- a3 * b1 - a1 * b3,
- a1 * b2 - a2 * b1
- ]
-
-If one of the input vectors has a dimension greater than 1, the output
-vector will be a 1x3 (2-dimensional) matrix.
-
-
-
-
-Calculate the cosecant of a value, defined as `csc(x) = 1/sin(x)`.
-
-To avoid confusion with the matrix cosecant, this function does not
-apply to matrices.
-
-
-
-
-Calculate the hyperbolic cosecant of a value,
-defined as `csch(x) = 1 / sinh(x)`.
-
-To avoid confusion with the matrix hyperbolic cosecant, this function
-does not apply to matrices.
-
-
-
-
-Transpose and complex conjugate a matrix. All values of the matrix are
-reflected over its main diagonal and then the complex conjugate is
-taken. This is equivalent to complex conjugation for scalars and
-vectors.
-
-
-
-
-Compute the cube of a value, `x * x * x`.
-To avoid confusion with `pow(M,3)`, this function does not apply to matrices.
-If you wish to cube every entry of a matrix, see the examples.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Fraction | Complex | Unit | Number for which to calculate the cube
-
-
-
-Compute the cumulative sum of a matrix or a list with values.
-In case of a (multi dimensional) array or matrix, the cumulative sums
-along a specified dimension (defaulting to the first) will be calculated.
-
-
-
-
-Test element wise whether two matrices are equal.
-The function accepts both matrices and scalar values.
-
-Strings are compared by their numerical value.
-
-
-
-
-Type | Description
----- | -----------
-number | BigNumber | Fraction | Complex | Unit | Array | Matrix | Returns true when the input matrices have the same size and each of their elements is equal.
-
-
-
-
-Takes the derivative of an expression expressed in parser Nodes.
-The derivative will be taken over the supplied variable in the
-second parameter. If there are multiple variables in the expression,
-it will return a partial derivative.
-
-This uses rules of differentiation which can be found here:
-
-- [Differentiation rules (Wikipedia)](https://en.wikipedia.org/wiki/Differentiation_rules)
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`expr` | Node | string | The expression to differentiate
-`variable` | SymbolNode | string | The variable over which to differentiate
-`options` | {simplify: boolean} | There is one option available, `simplify`, which is true by default. When false, output will not be simplified.
-
-
-
-Create a diagonal matrix or retrieve the diagonal of a matrix
-
-When `x` is a vector, a matrix with vector `x` on the diagonal will be returned.
-When `x` is a two dimensional matrix, the matrixes `k`th diagonal will be returned as vector.
-When k is positive, the values are placed on the super diagonal.
-When k is negative, the values are placed on the sub diagonal.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Matrix | Array | A two dimensional matrix or a vector
-`k` | number | BigNumber | The diagonal where the vector will be filled in or retrieved. Default value: 0.
-`format` | string | The matrix storage format. Default value: 'dense'.
-
-
-
-Create a new matrix or array of the difference between elements of the given array
-The optional dim parameter lets you specify the dimension to evaluate the difference of
-If no dimension parameter is passed it is assumed as dimension 0
-
-Dimension is zero-based in javascript and one-based in the parser and can be a number or bignumber
-Arrays must be 'rectangular' meaning arrays like [1, 2]
-If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays
-
-
-
-
-Calculates:
- The eucledian distance between two points in N-dimensional spaces.
- Distance between point and a line in 2 and 3 dimensional spaces.
- Pairwise distance between a set of 2D or 3D points
-NOTE:
- When substituting coefficients of a line(a, b and c), use ax + by + c = 0 instead of ax + by = c
- For parametric equation of a 3D line, x0, y0, z0, a, b, c are from: (x−x0, y−y0, z−z0) = t(a, b, c)
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Fraction | Complex | Unit | Array | Matrix | Left hand value
-`y` | number | BigNumber | Fraction | Complex | Unit | Array | Matrix | Right hand value
-
-
-
-Compute eigenvalues and optionally eigenvectors of a square matrix.
-The eigenvalues are sorted by their absolute value, ascending, and
-returned as a vector in the `values` property of the returned project.
-An eigenvalue with algebraic multiplicity k will be listed k times, so
-that the returned `values` vector always has length equal to the size
-of the input matrix.
-
-The `eigenvectors` property of the return value provides the eigenvectors.
-It is an array of plain objects: the `value` property of each gives the
-associated eigenvalue, and the `vector` property gives the eigenvector
-itself. Note that the same `value` property will occur as many times in
-the list provided by `eigenvectors` as the geometric multiplicity of
-that value.
-
-If the algorithm fails to converge, it will throw an error –
-in that case, however, you may still find useful information
-in `err.values` and `err.vectors`.
-
-Note that the 'precision' option does not directly specify the _accuracy_
-of the returned eigenvalues. Rather, it determines how small an entry
-of the iterative approximations to an upper triangular matrix must be
-in order to be considered zero. The actual accuracy of the returned
-eigenvalues may be greater or less than the precision, depending on the
-conditioning of the matrix and how far apart or close the actual
-eigenvalues are. Note that currently, relatively simple, "traditional"
-methods of eigenvalue computation are being used; this is not a modern,
-high-precision eigenvalue computation. That said, it should typically
-produce fairly reasonable results.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Array | Matrix | Matrix to be diagonalized
-`opts` | number | BigNumber | OptsObject | Object with keys `precision`, defaulting to config.relTol, and `eigenvectors`, defaulting to true and specifying whether to compute eigenvectors. If just a number, specifies precision.
-
-
-
-Type | Description
----- | -----------
-{values: Array | Matrix, eigenvectors?: Array<EVobj>}} Object containing an array of eigenvalues and an array of {value: number | BigNumber, vector: Array | Matrix | objects. The eigenvectors property is undefined if eigenvectors were not requested.
-
-
-
-
-Test whether two values are equal.
-
-The function tests whether the relative difference between x and y is
-smaller than the configured relTol and absTol. The function cannot be used to
-compare values smaller than approximately 2.22e-16.
-
-For matrices, the function is evaluated element wise.
-In case of complex numbers, x.re must equal y.re, and x.im must equal y.im.
-
-Values `null` and `undefined` are compared strictly, thus `null` is only
-equal to `null` and nothing else, and `undefined` is only equal to
-`undefined` and nothing else. Strings are compared by their numerical value.
-
-
-
-
-Compute the erf function of a value using a rational Chebyshev
-approximations for different intervals of x.
-
-This is a translation of W. J. Cody's Fortran implementation from 1987
-( https://www.netlib.org/specfun/erf ). See the AMS publication
-"Rational Chebyshev Approximations for the Error Function" by W. J. Cody
-for an explanation of this process.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Evaluate an expression.
-
-The expression parser does not use JavaScript. Its syntax is close
-to JavaScript but more suited for mathematical expressions.
-See [https://mathjs.org/docs/expressions/syntax.html](https://mathjs.org/docs/expressions/syntax.html) to learn
-the syntax and get an overview of the exact differences from JavaScript.
-
-Note the evaluating arbitrary expressions may involve security risks,
-see [https://mathjs.org/docs/expressions/security.html](https://mathjs.org/docs/expressions/security.html) for more information.
-
-
-
-
-Calculate the exponential of a value.
-For matrices, if you want the matrix exponential of square matrix, use
-the `expm` function; if you want to take the exponential of each element,
-see the examples.
-
-
-
-
-Compute the matrix exponential, expm(A) = e^A. The matrix must be square.
-Not to be confused with exp(a), which performs element-wise
-exponentiation.
-
-The exponential is calculated using the Padé approximant with scaling and
-squaring; see "Nineteen Dubious Ways to Compute the Exponential of a
-Matrix," by Moler and Van Loan.
-
-
-
-
-Calculate the value of subtracting 1 from the exponential value.
-This function is more accurate than `math.exp(x)-1` when `x` is near 0
-To avoid ambiguity with the matrix exponential `expm`, this function
-does not operate on matrices; if you wish to apply it elementwise, see
-the examples.
-
-
-
-
-Compute the factorial of a value
-
-Factorial only supports an integer value as argument.
-For matrices, the function is evaluated element wise.
-
-
-
-
-Filter the items in an array or one dimensional matrix.
-
-The callback is invoked with three arguments: the current value,
-the current index, and the matrix operated upon.
-Note that because the matrix/array might be
-multidimensional, the "index" argument is always an array of numbers giving
-the index in each dimension. This is true even for vectors: the "index"
-argument is an array of length 1, rather than simply a number.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Matrix | Array | A one dimensional matrix or array to filter
-`test` | Function | RegExp | A function or regular expression to test items. All entries for which `test` returns true are returned. When `test` is a function, it is invoked with three parameters: the value of the element, the index of the element, and the matrix/array being traversed. The function must return a boolean.
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Fraction | Complex | Unit | Array | Matrix | Value to be rounded
-`n` | number | BigNumber | Array | Number of decimals Default value: 0.
-`valuelessUnit` | Unit | A valueless unit
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Fraction | Complex | Unit | Array | Matrix | Value to be rounded
-`n` | number | BigNumber | Array | Number of decimals Default value: 0.
-`valuelessUnit` | Unit | A valueless unit
-
-
-
-Iterate over all elements of a matrix/array, and executes the given callback function.
-
-The callback is invoked with three arguments: the current value,
-the current index, and the matrix operated upon.
-Note that because the matrix/array might be
-multidimensional, the "index" argument is always an array of numbers giving
-the index in each dimension. This is true even for vectors: the "index"
-argument is an array of length 1, rather than simply a number.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Matrix | Array | The matrix to iterate on.
-`callback` | Function | The callback function is invoked with three parameters: the value of the element, the index of the element, and the Matrix/array being traversed.
-
-
-
- - `value: *`
- The value to be formatted
- - `options: Object`
- An object with formatting options. Available options:
- - `notation: string`
- Number notation. Choose from:
- - `'fixed'`
- Always use regular number notation.
- For example `'123.40'` and `'14000000'`
- - `'exponential'`
- Always use exponential notation.
- For example `'1.234e+2'` and `'1.4e+7'`
- - `'engineering'`
- Always use engineering notation: always have exponential notation,
- and select the exponent to be a multiple of `3`.
- For example `'123.4e+0'` and `'14.0e+6'`
- - `'auto'` (default)
- Regular number notation for numbers having an absolute value between
- `lower` and `upper` bounds, and uses exponential notation elsewhere.
- Lower bound is included, upper bound is excluded.
- For example `'123.4'` and `'1.4e7'`.
- - `'bin'`, `'oct'`, or `'hex'`
- Format the number using binary, octal, or hexadecimal notation.
- For example `'0b1101'` and `'0x10fe'`.
- - `wordSize: number | BigNumber`
- The word size in bits to use for formatting in binary, octal, or
- hexadecimal notation. To be used only with `'bin'`, `'oct'`, or `'hex'`
- values for `notation` option. When this option is defined the value
- is formatted as a signed twos complement integer of the given word
- size and the size suffix is appended to the output.
- For example `format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'`.
- Default value is undefined.
- - `precision: number | BigNumber`
- Limit the number of digits of the formatted value.
- For regular numbers, must be a number between `0` and `16`.
- For bignumbers, the maximum depends on the configured precision,
- see function `config()`.
- In case of notations `'exponential'`, `'engineering'`, and `'auto'`,
- `precision` defines the total number of significant digits returned.
- In case of notation `'fixed'`, `precision` defines the number of
- significant digits after the decimal point.
- `precision` is undefined by default.
- - `lowerExp: number`
- Exponent determining the lower boundary for formatting a value with
- an exponent when `notation='auto'`. Default value is `-3`.
- - `upperExp: number`
- Exponent determining the upper boundary for formatting a value with
- an exponent when `notation='auto'`. Default value is `5`.
- - `fraction: string`. Available values: `'ratio'` (default) or `'decimal'`.
- For example `format(fraction(1, 3))` will output `'1/3'` when `'ratio'`
- is configured, and will output `'0.(3)'` when `'decimal'` is configured.
- - `truncate: number`. Specifies the maximum allowed length of the
- returned string. If it had been longer, the excess characters
- are deleted and replaced with `'...'`.
-- `callback: function`
- A custom formatting function, invoked for all numeric elements in `value`,
- for example all elements of a matrix, or the real and imaginary
- parts of a complex number. This callback can be used to override the
- built-in numeric notation with any type of formatting. Function `callback`
- is called with `value` as parameter and must return a string.
-
-
-
-Create a fraction or convert a value to a fraction.
-
-With one numeric argument, produces the closest rational approximation to the
-input.
-With two arguments, the first is the numerator and the second is the denominator,
-and creates the corresponding fraction. Both numerator and denominator must be
-integers.
-With one object argument, looks for the integer numerator as the value of property
-'n' and the integer denominator as the value of property 'd'.
-With a matrix argument, creates a matrix of the same shape with entries
-converted into fractions.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`b` | Array.<number> | The numerator coefficients of the filter.
-`a` | Array.<number> | The denominator coefficients of the filter.
-`w` | Array.<number> | A vector of frequencies (in radians/sample) at which the frequency response is to be computed or the number of points to compute (if a number is not provided, the default is 512 points)
-
-
-
-Type | Description
----- | -----------
-Object | An object with two properties: h, a vector containing the complex frequency response, and w, a vector containing the normalized frequencies (in radians/sample) at which the response was computed.
-
-
-
-
-Compute the gamma function of a value using Lanczos approximation for
-small values, and an extended Stirling approximation for large values.
-
-To avoid confusion with the matrix Gamma function, this function does
-not apply to matrices.
-
-
-
-
-Find the data type of all elements in a matrix or array,
-for example 'number' if all items are a number and 'Complex' if all values
-are complex numbers.
-If a matrix contains more than one data type, it will return 'mixed'.
-
-
-
-
-Type | Description
----- | -----------
-boolean | Returns true when `x` is a `number`, `BigNumber`, `Fraction`, `Boolean`, or a `String` containing number. Returns false for other types. Throws an error in case of unknown types.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`search` | Function | string | Object | A function or function name for which to get help
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | number | BigNumber | Value to be stringified
-`wordSize` | number | BigNumber | Optional word size (see `format`)
-
-
-
-Calculate the hypotenuse of a list with values. The hypotenuse is defined as:
-
- hypot(a, b, c, ...) = sqrt(a^2 + b^2 + c^2 + ...)
-
-For matrix input, the hypotenuse is calculated for all values in the matrix.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`args` | ... number | BigNumber | Array | Matrix | A list with numeric values or an Array or Matrix. Matrix and Array input is flattened and returns a single number for the whole matrix.
-
-
-
-Get the imaginary part of a complex number.
-For a complex number `a + bi`, the function returns `b`.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-- `functions: Object`
- An object with functions or factories to be imported.
-- `options: Object` An object with import options. Available options:
- - `override: boolean`
- If true, existing functions will be overwritten. False by default.
- - `silent: boolean`
- If true, the function will not throw errors on duplicates or invalid
- types. False by default.
- - `wrap: boolean`
- 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 these data type. False by default.
-
-
-
-Create an index. An Index can store ranges having start, step, and end
-for multiple dimensions.
-Matrix.get, Matrix.set, and math.subset accept an Index as input.
-
-
-
-
-Calculates the point of intersection of two lines in two or three dimensions
-and of a line and a plane in three dimensions. The inputs are in the form of
-arrays or 1 dimensional matrices. The line intersection functions return null
-if the lines do not meet.
-
-Note: Fill the plane coefficients as `x + y + z = c` and not as `x + y + z + c = 0`.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`w` | Array | Matrix | Co-ordinates of first end-point of first line
-`x` | Array | Matrix | Co-ordinates of second end-point of first line
-`y` | Array | Matrix | Co-ordinates of first end-point of second line OR Co-efficients of the plane's equation
-`z` | Array | Matrix | Co-ordinates of second end-point of second line OR undefined if the calculation is for line and plane
-
-
-
-Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation `ax ≣ 1 (mod b)`
-See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`a` | number | BigNumber | An integer number
-`b` | number | BigNumber | An integer number
-
-
-
-Test whether a value is an integer number.
-The function supports `number`, `BigNumber`, and `Fraction`.
-
-The function is evaluated element-wise in case of Array or Matrix input.
-
-
-
-
-Type | Description
----- | -----------
-boolean | Returns true when `x` contains a numeric, integer value. Throws an error in case of an unknown data type.
-
-
-
-
-Test whether a value is NaN (not a number).
-The function supports types `number`, `BigNumber`, `Fraction`, `Unit` and `Complex`.
-
-The function is evaluated element-wise in case of Array or Matrix input.
-
-
-
-
-Test whether a value is negative: smaller than zero.
-The function supports types `number`, `BigNumber`, `Fraction`, and `Unit`.
-
-The function is evaluated element-wise in case of Array or Matrix input.
-
-
-
-
-Type | Description
----- | -----------
-boolean | Returns true when `x` is a `number`, `BigNumber`, `Fraction`, or `boolean`. Returns false for other types. Throws an error in case of unknown types.
-
-
-
-
-Test whether a value is positive: larger than zero.
-The function supports types `number`, `BigNumber`, `Fraction`, and `Unit`.
-
-The function is evaluated element-wise in case of Array or Matrix input.
-
-
-
-
-Test whether a value is prime: has no divisors other than itself and one.
-The function supports type `number`, `bignumber`.
-
-The function is evaluated element-wise in case of Array or Matrix input.
-
-
-
-
-Test whether a value is zero.
-The function can check for zero for types `number`, `BigNumber`, `Fraction`,
-`Complex`, and `Unit`.
-
-The function is evaluated element-wise in case of Array or Matrix input.
-
-
-
-
-Calculates the Kronecker product of 2 matrices or vectors.
-
-NOTE: If a one dimensional vector / matrix is given, it will be
-wrapped so its two dimensions.
-See the examples.
-
-
-
-
-Test whether value x is larger than y.
-
-The function returns true when x is larger than y and the relative
-difference between x and y is larger than the configured relTol and absTol. The
-function cannot be used to compare values smaller than approximately 2.22e-16.
-
-For matrices, the function is evaluated element wise.
-Strings are compared by their numerical value.
-
-
-
-
-Test whether value x is larger or equal to y.
-
-The function returns true when x is larger than y or the relative
-difference between x and y is smaller than the configured relTol and absTol. The
-function cannot be used to compare values smaller than approximately 2.22e-16.
-
-For matrices, the function is evaluated element wise.
-Strings are compared by their numerical value.
-
-
-
-
-Calculate the least common multiple for two or more values or arrays.
-
-lcm is defined as:
-
- lcm(a, b) = abs(a * b) / gcd(a, b)
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Gives the number of "leaf nodes" in the parse tree of the given expression
-A leaf node is one that has no subexpressions, essentially either a
-symbol or a constant. Note that `5!` has just one leaf, the '5'; the
-unary factorial operator does not add a leaf. On the other hand,
-function symbols do add leaves, so `sin(x)/cos(x)` has four leaves.
-
-The `simplify()` function should generally not increase the `leafCount()`
-of an expression, although currently there is no guarantee that it never
-does so. In many cases, `simplify()` reduces the leaf count.
-
-
-
-
-Bitwise left logical shift of a value x by y number of bits, `x << y`.
-For matrices, the function is evaluated element wise.
-For units, the function is evaluated on the best prefix base.
-
-
-
-
-Logarithm of the gamma function for real, positive numbers and complex numbers,
-using Lanczos approximation for numbers and Stirling series for complex numbers.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Fraction | Complex | Value for which to calculate the logarithm.
-`base` | number | BigNumber | Fraction | Complex | Optional base for the logarithm. If not provided, the natural logarithm of `x` is calculated. Default value: e.
-
-
-
-Calculate the 10-base logarithm of a value. This is the same as calculating `log(x, 10)`.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Complex | Array | Matrix | Value for which to calculate the logarithm.
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Complex | Array | Matrix | Value for which to calculate the logarithm of `x+1`.
-`base` | number | BigNumber | Complex | Optional base for the logarithm. If not provided, the natural logarithm of `x+1` is calculated. Default value: e.
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Complex | Array | Matrix | Value for which to calculate the logarithm.
-
-
-
-Finds one solution of a linear equation system by forwards substitution. Matrix must be a lower triangular matrix. Throws an error if there's no solution.
-
-`L * x = b`
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`L` | Matrix, Array | A N x N matrix or array (L)
-`b` | Matrix, Array | A column vector with the b values
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`L` | Matrix, Array | A N x N matrix or array (L)
-`b` | Matrix, Array | A column vector with the b values
-
-
-
-Type | Description
----- | -----------
-DenseMatrix[] | Array[] | An array of affine-independent column vectors (x) that solve the linear system
-
-
-
-
-Calculate the Matrix LU decomposition with partial pivoting. Matrix `A` is decomposed in two matrices (`L`, `U`) and a
-row permutation vector `p` where `A[p,:] = L * U`
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`A` | Matrix | Array | A two dimensional matrix or array for which to get the LUP decomposition.
-
-
-
-```js
-math.lusolve(A, b) // returns column vector with the solution to the linear system A * x = b
-math.lusolve(lup, b) // returns column vector with the solution to the linear system A * x = b, lup = math.lup(A)
-```
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`A` | Matrix | Array | Object | Invertible Matrix or the Matrix LU decomposition
-`b` | Matrix | Array | Column Vector
-`order` | number | The Symbolic Ordering and Analysis order, see slu for details. Matrix must be a SparseMatrix
-`threshold` | Number | Partial pivoting threshold (1 for partial pivoting), see slu for details. Matrix must be a SparseMatrix.
-
-
-
-Solves the Continuous-time Lyapunov equation AP+PA'+Q=0 for P, where
-Q is an input matrix. When Q is symmetric, P is also symmetric. Notice
-that different equivalent definitions exist for the Continuous-time
-Lyapunov equation.
-https://en.wikipedia.org/wiki/Lyapunov_equation
-
-
-
-
-Compute the median absolute deviation of a matrix or a list with values.
-The median absolute deviation is defined as the median of the absolute
-deviations from the median.
-
-
-
-
-Create a new matrix or array with the results of a callback function executed on
-each entry of a given matrix/array.
-
-For each entry of the input,
-
-the callback is invoked with 2N + 1 arguments:
-the N values of the entry, the index at which that entry occurs, and the N full
-broadcasted matrix/array being traversed where N is the number of matrices being traversed.
-Note that because the matrix/array might be
-multidimensional, the "index" argument is always an array of numbers giving
-the index in each dimension. This is true even for vectors: the "index"
-argument is an array of length 1, rather than simply a number.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Matrix | Array | The input to iterate on.
-`callback` | Function | The function to call (as described above) on each entry of the input
-
-
-
-```js
-math.map([1, 2, 3], function(value) {
- return value * value
-}) // returns [1, 4, 9]
-math.map([1, 2], [3, 4], function(a, b) {
- return a + b
-}) // returns [4, 6]
-
-// The callback is normally called with three arguments:
-// callback(value, index, Array)
-// If you want to call with only one argument, use:
-math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
-// It can also be called with 2N + 1 arguments: for N arrays
-// callback(value1, value2, index, BroadcastedArray1, BroadcastedArray2)
-```
-
-
-
-
-Apply a function that maps an array to a scalar
-along a given axis of a matrix or array.
-Returns a new matrix or array with one less dimension than the input.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`array` | Array | Matrix | The input Matrix
-`dim` | number | The dimension along which the callback is applied
-`callback` | Function | The callback function that is applied. This Function should take an array or 1-d matrix as an input and return a number.
-
-
-
-Create a Matrix. The function creates a new `math.Matrix` object from
-an `Array`. A Matrix has utility functions to manipulate the data in the
-matrix, like getting the size and getting or setting values in the matrix.
-Supported storage formats are 'dense' and 'sparse'.
-
-
-
-
-```js
-math.matrix() // creates an empty matrix using default storage format (dense).
-math.matrix(data) // creates a matrix with initial data using default storage format (dense).
-math.matrix('dense') // creates an empty matrix using the given storage format.
-math.matrix(data, 'dense') // creates a matrix with initial data using the given storage format.
-math.matrix(data, 'sparse') // creates a sparse matrix with initial data.
-math.matrix(data, 'sparse', 'number') // creates a sparse matrix with initial data, number data type.
-```
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`data` | Array | Matrix | A multi dimensional array
-`format` | string | The Matrix storage format, either `'dense'` or `'sparse'`
-`datatype` | string | Type of the values
-
-
-
-Create a matrix by evaluating a generating function at each index.
-The simplest overload returns a multi-dimensional array as long as `size`
-is an array.
-Passing `size` as a Matrix or specifying a `format` will result in
-returning a Matrix.
-
-
-
-
- - `size: (number[] | Matrix)`
- A vector giving the extent of the array to be created in each
- dimension. If size has one entry, a vector is created; if it
- has two, a rectangular array/Matrix is created; if three, a
- three-dimensional array/Matrix is created; and so on.
- - `fn: (index: number[]) => MathType`
- The callback function that will generate the entries of the
- matrix. It is called in turn with the index of each entry of
- the matrix. The index is always an ordinary array of numbers
- with the same length as _size_. So for vectors, you will get
- indices like `[0]` or `[1]`, whereas for matrices, you will
- get indices like `[2, 0]` or `[1,3]`. The return value may
- be any type that can go in an array or Matrix entry, although
- if you supply the _datatype_ argument, you must yourself ensure
- the type of the return value matches. Note that currently,
- your callback _fn_ will receive 0-based indices for the matrix
- entries, regardless of whether matrixFromFunction is invoked
- directly from JavaScript or via the mathjs expression language.
- - `format: 'dense'|'sparse'`
- Specifies the storage format for the resulting Matrix. Note that
- if this argument is given, the return value will always be a
- Matrix (rather than possibly an Array).
- - `datatype: string`
- Specifies the data type of entries of the new matrix. If given,
- it should be the name of a data type that mathjs supports, as
- returned by the math.typeOf function. It is up to the caller
- to make certain that all values returned by _fn_ are consistent
- with this datatype if specified.
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`size` | Array | Matrix | The size of the matrix to be created
-`fn` | function | Callback function invoked for every entry in the matrix
-`format` | string | The Matrix storage format, either `'dense'` or `'sparse'`
-`datatype` | string | Type of the values
-
-
-
-Compute the maximum value of a matrix or a list with values.
-In case of a multidimensional array, the maximum of the flattened array
-will be calculated. When `dim` is provided, the maximum over the selected
-dimension will be calculated. Parameter `dim` is zero-based.
-
-
-
-
-Compute the mean value of matrix or a list with values.
-In case of a multidimensional array, the mean of the flattened array
-will be calculated. When `dim` is provided, the maximum over the selected
-dimension will be calculated. Parameter `dim` is zero-based.
-
-
-
-
-Compute the median of a matrix or a list with values. The values are
-sorted and the middle value is returned. In case of an even number of
-values, the average of the two middle values is returned.
-Supported types of values are: Number, BigNumber, Unit
-
-In case of a (multi dimensional) array or matrix, the median of all
-elements will be calculated.
-
-
-
-
-Compute the minimum value of a matrix or a list of values.
-In case of a multidimensional array, the minimum of the flattened array
-will be calculated. When `dim` is provided, the minimum over the selected
-dimension will be calculated. Parameter `dim` is zero-based.
-
-
-
-
-Calculates the modulus, the remainder of an integer division.
-
-For matrices, the function is evaluated element wise.
-
-The modulus is defined as:
-
- x - y * floor(x / y)
-
-See https://en.wikipedia.org/wiki/Modulo_operation.
-
-
-
-
-Computes the mode of a set of numbers or a list with values(numbers or characters).
-If there are multiple modes, it returns a list of those values.
-
-
-
-
-Multinomial Coefficients compute the number of ways of picking a1, a2, ..., ai unordered outcomes from `n` possibilities.
-
-multinomial takes one array of integers as an argument.
-The following condition must be enforced: every ai <= 0
-
-
-
-
-Calculate the nth root of a value.
-The principal nth root of a positive real number A, is the positive real
-solution of the equation
-
- x^root = A
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`a` | number | BigNumber | Array | Matrix | Complex | Value for which to calculate the nth root
-`root` | number | BigNumber | The root. Default value: 2.
-
-
-
-Calculate the nth roots of a value.
-An nth root of a positive real number A,
-is a positive real solution of the equation "x^root = A".
-This function returns an array of complex values.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Fraction | Complex | Number to be rounded
-`root` | number | Optional root, default value is 2 Default value: 2.
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | string | number | BigNumber | Fraction | boolean | Array | Matrix | Unit | null | Value to be converted
-`valuelessUnit` | Unit | string | A valueless unit, used to convert a unit to a number
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | string | number | BigNumber | bigint | Fraction | A numeric value or a string containing a numeric value
-`outputType` | string | Desired numeric output type. Available values: 'number', 'BigNumber', or 'Fraction'
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | number | BigNumber | Value to be stringified
-`wordSize` | number | BigNumber | Optional word size (see `format`)
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`size` | ...(number | BigNumber) | Array | The size of each dimension of the matrix
-`format` | string | The Matrix storage format
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Complex | Unit | Array | Matrix | First value to check
-`y` | number | BigNumber | bigint | Complex | Unit | Array | Matrix | Second value to check
-
-
-
-Type | Description
----- | -----------
-boolean | Array | Matrix | Returns true when one of the inputs is defined with a nonzero/nonempty value.
-
-
-
-
-Parse an expression. Returns a node tree, which can be evaluated by
-invoking node.evaluate().
-
-Note the evaluating arbitrary expressions may involve security risks,
-see [https://mathjs.org/docs/expressions/security.html](https://mathjs.org/docs/expressions/security.html) for more information.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Matrix | Array | A one dimensional matrix or array to sort
-`k` | Number | The kth smallest value to be retrieved zero-based index
-`compare` | Function | 'asc' | 'desc' | An optional comparator function. The function is called as `compare(a, b)`, and must return 1 when a > b, -1 when a < b, and 0 when a == b. Default value: 'asc'.
-
-
-
-Compute the number of ways of obtaining an ordered subset of `k` elements
-from a set of `n` elements.
-
-Permutations only takes integer arguments.
-The following condition must be enforced: k <= n.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`n` | number | BigNumber | The number of objects in total
-`k` | number | BigNumber | The number of objects in the subset
-
-
-
-Random pick one or more values from a one dimensional array.
-Array elements are picked using a random function with uniform or weighted distribution.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`array` | Array | Matrix | A one dimensional array
-`number` | Int | An int or float
-`weights` | Array | Matrix | An array of ints or floats
-
-
-
-Type | Description
----- | -----------
-number | Array | Returns a single random value from array when number is undefined. Returns an array with the configured number of elements when number is defined.
-
-
-
-
-```js
-math.pickRandom([3, 6, 12, 2]) // returns one of the values in the array
-math.pickRandom([3, 6, 12, 2], 2) // returns an array of two of the values in the array
-math.pickRandom([3, 6, 12, 2], { number: 2 }) // returns an array of two of the values in the array
-math.pickRandom([3, 6, 12, 2], [1, 3, 2, 1]) // returns one of the values in the array with weighted distribution
-math.pickRandom([3, 6, 12, 2], 2, [1, 3, 2, 1]) // returns an array of two of the values in the array with weighted distribution
-math.pickRandom([3, 6, 12, 2], [1, 3, 2, 1], 2) // returns an array of two of the values in the array with weighted distribution
-
-math.pickRandom([{x: 1.0, y: 2.0}, {x: 1.1, y: 2.0}], { elementWise: false })
- // returns one of the items in the array
-```
-
-
-
-
-Finds the numerical values of the distinct roots of a polynomial with real or complex coefficients.
-Currently operates only on linear, quadratic, and cubic polynomials using the standard
-formulas for the roots.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`coeffs` | ... number | Complex | The coefficients of the polynomial, starting with with the constant coefficent, followed by the linear coefficient and subsequent coefficients of increasing powers.
-
-
-
-Calculates the power of x to y, `x ^ y`.
-
-Matrix exponentiation is supported for square matrices `x` and integers `y`:
-when `y` is nonnegative, `x` may be any square matrix; and when `y` is
-negative, `x` must be invertible, and then this function returns
-inv(x)^(-y).
-
-For cubic roots of negative numbers, the function returns the principal
-root by default. In order to let the function return the real root,
-math.js can be configured with `math.config({predictable: true})`.
-To retrieve all cubic roots of a value, use `math.cbrt(x, true)`.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`template` | string | A string containing variable placeholders.
-`values` | Object | Array | Matrix | An object or array containing variables which will be filled in in the template.
-`options` | number | Object | Formatting options, or the number of digits to format numbers. See function math.format for a description of all options.
-
-
-
-```js
-// the following outputs: 'Lucy is 5 years old'
-math.print('Lucy is $age years old', {age: 5})
-
-// the following outputs: 'The value of pi is 3.141592654'
-math.print('The value of pi is $pi', {pi: math.pi}, 10)
-
-// the following outputs: 'Hello Mary! The date is 2013-03-23'
-math.print('Hello $user.name! The date is $date', {
- user: {
- name: 'Mary',
- },
- date: '2013-03-23'
-})
-
-// the following outputs: 'My favorite fruits are apples and bananas !'
-math.print('My favorite fruits are $0 and $1 !', [
- 'apples',
- 'bananas'
-])
-```
-
-
-
-
-Compute the product of a matrix or a list with values.
-In case of a multidimensional array or matrix, the sum of all
-elements will be calculated.
-
-
-
-
-Calculate the Matrix QR decomposition. Matrix `A` is decomposed in
-two matrices (`Q`, `R`) where `Q` is an
-orthogonal matrix and `R` is an upper triangular matrix.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`A` | Matrix | Array | A two dimensional matrix or array for which to get the QR decomposition.
-
-
-
-Compute the prob order quantile of a matrix or a list with values.
-The sequence is sorted and the middle value is returned.
-Supported types of sequence values are: Number, BigNumber, Unit
-Supported types of probability are: Number, BigNumber
-
-In case of a multidimensional array or matrix, the prob order quantile
-of all elements will be calculated.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`data` | Array, Matrix | A single matrix or Array
-`probOrN` | Number, BigNumber, Array | prob is the order of the quantile, while N is the amount of evenly distributed steps of probabilities; only one of these options can be provided
-`sorted` | Boolean | =false is data sorted in ascending order
-
-
-
-```js
-math.random() // generate a random number between 0 and 1
-math.random(max) // generate a random number between 0 and max
-math.random(min, max) // generate a random number between min and max
-math.random(size) // generate a matrix with random numbers between 0 and 1
-math.random(size, max) // generate a matrix with random numbers between 0 and max
-math.random(size, min, max) // generate a matrix with random numbers between min and max
-```
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`size` | Array | Matrix | If provided, an array or matrix with given size and filled with random values is returned
-`min` | number | Minimum boundary for the random value, included
-`max` | number | Maximum boundary for the random value, excluded
-
-
-
-```js
-math.random() // returns a random number between 0 and 1
-math.random(100) // returns a random number between 0 and 100
-math.random(30, 40) // returns a random number between 30 and 40
-math.random([2, 3]) // returns a 2x3 matrix with random numbers between 0 and 1
-```
-
-
-
-
-```js
-math.randomInt() // generate either 0 or 1, randomly
-math.randomInt(max) // generate a random integer between 0 and max
-math.randomInt(min, max) // generate a random integer between min and max
-math.randomInt(size) // generate a matrix with random integer between 0 and 1
-math.randomInt(size, max) // generate a matrix with random integer between 0 and max
-math.randomInt(size, min, max) // generate a matrix with random integer between min and max
-```
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`size` | Array | Matrix | If provided, an array or matrix with given size and filled with random values is returned
-`min` | number | Minimum boundary for the random value, included
-`max` | number | Maximum boundary for the random value, excluded
-
-
-
-```js
-math.randomInt(100) // returns a random integer between 0 and 100
-math.randomInt(30, 40) // returns a random integer between 30 and 40
-math.randomInt([2, 3]) // returns a 2x3 matrix with random integers between 0 and 1
-```
-
-
-
-
-```js
-math.range(str [, includeEnd]) // Create a range from a string,
- // where the string contains the
- // start, optional step, and end,
- // separated by a colon.
-math.range(start, end [, includeEnd]) // Create a range with start and
- // end and a step size of 1.
-math.range(start, end, step [, includeEnd]) // Create a range with start, step,
- // and end.
-```
-
-
-
-- `str: string`
- A string 'start:end' or 'start:step:end'
-- `start: {number | bigint | BigNumber | Fraction | Unit}`
- Start of the range
-- `end: number | bigint | BigNumber | Fraction | Unit`
- End of the range, excluded by default, included when parameter includeEnd=true
-- `step: number | bigint | BigNumber | Fraction | Unit`
- Step size. Default value is 1.
-- `includeEnd: boolean`
- Option to specify whether to include the end or not. False by default.
-
-
-
-Transform a rationalizable expression in a rational fraction.
-If rational fraction is one variable polynomial then converts
-the numerator and denominator in canonical form, with decreasing
-exponents, returning the coefficients of numerator.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`expr` | Node | string | The expression to check if is a polynomial expression
-`optional` | Object | boolean | scope of expression or true for already evaluated rational expression at input
-`detailed` | Boolean | optional True if return an object, false if return expression node (default)
-
-
-
-Type | Description
----- | -----------
-Object | Node | The rational polynomial of `expr` or an object `{expression, numerator, denominator, variables, coefficients}`, where `expression` is a `Node` with the node simplified expression, `numerator` is a `Node` with the simplified numerator of expression, `denominator` is a `Node` or `boolean` with the simplified denominator or `false` (if there is no denominator), `variables` is an array with variable names, and `coefficients` is an array with coefficients of numerator sorted by increased exponent {Expression Node} node simplified expression
-
-
-
-
-Get the real part of a complex number.
-For a complex number `a + bi`, the function returns `a`.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Array | Matrix | * | Matrix to be reshaped
-`sizes` | number[] | One dimensional array with integral sizes for each dimension. One -1 is allowed as wildcard, which calculates this dimension automatically.
-
-
-
-Type | Description
----- | -----------
-TypeError | If `sizes` does not contain solely integers
-DimensionError | If the product of the new dimension sizes does not equal that of the old ones
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Array | Matrix | * | Matrix to be resized
-`size` | Array | Matrix | One dimensional array with numbers
-`defaultValue` | number | string | Zero by default, except in case of a string, in that case defaultValue = ' ' Default value: 0.
-
-
-
-Type | Description
----- | -----------
-ReferenceError | If there is a cyclic dependency among the variables in `scope`, resolution is impossible and a ReferenceError is thrown.
-
-
-
-Bitwise right arithmetic shift of a value x by y number of bits, `x >> y`.
-For matrices, the function is evaluated element wise.
-For units, the function is evaluated on the best prefix base.
-
-
-
-
-Bitwise right logical shift of value x by y number of bits, `x >>> y`.
-For matrices, the function is evaluated element wise.
-For units, the function is evaluated on the best prefix base.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | Array | Matrix | Value to be shifted
-`y` | number | Amount of shifts
-
-
-
-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
-
-
-
-
-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).
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Fraction | Complex | Unit | Array | Matrix | Value to be rounded
-`n` | number | BigNumber | Array | Number of decimals Default value: 0.
-`valuelessUnit` | Unit | A valueless unit
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`value` | Array | Matrix | An array or matrix
-`row` | number | The index of the row
-
-
-
-Performs a real Schur decomposition of the real matrix A = UTU' where U is orthogonal
-and T is upper quasi-triangular.
-https://en.wikipedia.org/wiki/Schur_decomposition
-
-
-
-
-Calculate the secant of a value, defined as `sec(x) = 1/cos(x)`.
-
-To avoid confusion with the matrix secant, this function does not
-apply to matrices.
-
-
-
-
-Calculate the hyperbolic secant of a value,
-defined as `sech(x) = 1 / cosh(x)`.
-
-To avoid confusion with the matrix hyperbolic secant, this function does
-not apply to matrices.
-
-
-
-
-Create the cartesian product of two (multi)sets.
-Multi-dimension arrays will be converted to single-dimension arrays
-and the values will be sorted in ascending order before the operation.
-
-
-
-
-Create the difference of two (multi)sets: every element of set1, that is not the element of set2.
-Multi-dimension arrays will be converted to single-dimension arrays before the operation.
-
-
-
-
-Check whether a (multi)set is a subset of another (multi)set. (Every element of set1 is the element of set2.)
-Multi-dimension arrays will be converted to single-dimension arrays before the operation.
-
-
-
-
-Count the multiplicity of an element in a multiset.
-A multi-dimension array will be converted to a single-dimension array before the operation.
-
-
-
-
-Create the powerset of a (multi)set. (The powerset contains very possible subsets of a (multi)set.)
-A multi-dimension array will be converted to a single-dimension array before the operation.
-
-
-
-
-Count the number of elements of a (multi)set. When a second parameter is 'true', count only the unique values.
-A multi-dimension array will be converted to a single-dimension array before the operation.
-
-
-
-
-Create the symmetric difference of two (multi)sets.
-Multi-dimension arrays will be converted to single-dimension arrays before the operation.
-
-
-
-
-Compute the sign of a value. The sign of a value x is:
-
-- 1 when x > 0
-- -1 when x < 0
-- 0 when x == 0
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Fraction | Complex | Array | Matrix | Unit | The number for which to determine the sign
-
-
-
-Simplify an expression tree.
-
-A list of rules are applied to an expression, repeating over the list until
-no further changes are made.
-It's possible to pass a custom set of rules to the function as second
-argument. A rule can be specified as an object, string, or function:
-
- const rules = [
- { l: 'n1*n3 + n2*n3', r: '(n1+n2)*n3' },
- 'n1*n3 + n2*n3 -> (n1+n2)*n3',
- function (node) {
- // ... return a new node or return the node unchanged
- return node
- }
- ]
-
-String and object rules consist of a left and right pattern. The left is
-used to match against the expression and the right determines what matches
-are replaced with. The main difference between a pattern and a normal
-expression is that variables starting with the following characters are
-interpreted as wildcards:
-
-- 'n' - Matches any node [Node]
-- 'c' - Matches a constant literal (5 or 3.2) [ConstantNode]
-- 'cl' - Matches a constant literal; same as c [ConstantNode]
-- 'cd' - Matches a decimal literal (5 or -3.2) [ConstantNode or unaryMinus wrapping a ConstantNode]
-- 'ce' - Matches a constant expression (-5 or √3) [Expressions consisting of only ConstantNodes, functions, and operators]
-- 'v' - Matches a variable; anything not matched by c (-5 or x) [Node that is not a ConstantNode]
-- 'vl' - Matches a variable literal (x or y) [SymbolNode]
-- 'vd' - Matches a non-decimal expression; anything not matched by cd (x or √3) [Node that is not a ConstantNode or unaryMinus that is wrapping a ConstantNode]
-- 've' - Matches a variable expression; anything not matched by ce (x or 2x) [Expressions that contain a SymbolNode or other non-constant term]
-
-The default list of rules is exposed on the function as `simplify.rules`
-and can be used as a basis to built a set of custom rules. Note that since
-the `simplifyCore` function is in the default list of rules, by default
-simplify will convert any function calls in the expression that have
-operator equivalents to their operator forms.
-
-To specify a rule as a string, separate the left and right pattern by '->'
-When specifying a rule as an object, the following keys are meaningful:
-- l - the left pattern
-- r - the right pattern
-- s - in lieu of l and r, the string form that is broken at -> to give them
-- repeat - whether to repeat this rule until the expression stabilizes
-- assuming - gives a context object, as in the 'context' option to
- simplify. Every property in the context object must match the current
- context in order, or else the rule will not be applied.
-- imposeContext - gives a context object, as in the 'context' option to
- simplify. Any settings specified will override the incoming context
- for all matches of this rule.
-
-For more details on the theory, see:
-
-- [Strategies for simplifying math expressions (Stackoverflow)](https://stackoverflow.com/questions/7540227/strategies-for-simplifying-math-expressions)
-- [Symbolic computation - Simplification (Wikipedia)](https://en.wikipedia.org/wiki/Symbolic_computation#Simplification)
-
- An optional `options` argument can be passed as last argument of `simplify`.
- Currently available options (defaults in parentheses):
- - `consoleDebug` (false): whether to write the expression being simplified
- and any changes to it, along with the rule responsible, to console
- - `context` (simplify.defaultContext): an object giving properties of
- each operator, which determine what simplifications are allowed. The
- currently meaningful properties are commutative, associative,
- total (whether the operation is defined for all arguments), and
- trivial (whether the operation applied to a single argument leaves
- that argument unchanged). The default context is very permissive and
- allows almost all simplifications. Only properties differing from
- the default need to be specified; the default context is used as a
- fallback. Additional contexts `simplify.realContext` and
- `simplify.positiveContext` are supplied to cause simplify to perform
- just simplifications guaranteed to preserve all values of the expression
- assuming all variables and subexpressions are real numbers or
- positive real numbers, respectively. (Note that these are in some cases
- more restrictive than the default context; for example, the default
- context will allow `x/x` to simplify to 1, whereas
- `simplify.realContext` will not, as `0/0` is not equal to 1.)
- - `exactFractions` (true): whether to try to convert all constants to
- exact rational numbers.
- - `fractionsLimit` (10000): when `exactFractions` is true, constants will
- be expressed as fractions only when both numerator and denominator
- are smaller than `fractionsLimit`.
-
-
-
-
-simplifyConstant() takes a mathjs expression (either a Node representing
-a parse tree or a string which it parses to produce a node), and replaces
-any subexpression of it consisting entirely of constants with the computed
-value of that subexpression.
-
-
-
-
-simplifyCore() performs single pass simplification suitable for
-applications requiring ultimate performance. To roughly summarize,
-it handles cases along the lines of simplifyConstant() but where
-knowledge of a single argument is sufficient to determine the value.
-In contrast, simplify() extends simplifyCore() with additional passes
-to provide deeper simplification (such as gathering like terms).
-
-Specifically, simplifyCore:
-
-* Converts all function calls with operator equivalents to their
- operator forms.
-* Removes operators or function calls that are guaranteed to have no
- effect (such as unary '+').
-* Removes double unary '-', '~', and 'not'
-* Eliminates addition/subtraction of 0 and multiplication/division/powers
- by 1 or 0.
-* Converts addition of a negation into subtraction.
-* Eliminates logical operations with constant true or false leading
- arguments.
-* Puts constants on the left of a product, if multiplication is
- considered commutative by the options (which is the default)
-
-
-
-
-Calculate the hyperbolic sine of a value,
-defined as `sinh(x) = 1/2 * (exp(x) - exp(-x))`.
-
-To avoid confusion with the matrix hyperbolic sine, this function does
-not apply to matrices.
-
-
-
-
-Calculate the Sparse Matrix LU decomposition with full pivoting. Sparse Matrix `A` is decomposed in two matrices (`L`, `U`) and two permutation vectors (`pinv`, `q`) where
-
-`P * A * Q = L * U`
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`A` | SparseMatrix | A two dimensional sparse matrix for which to get the LU decomposition.
-`order` | Number | The Symbolic Ordering and Analysis order: 0 - Natural ordering, no permutation vector q is returned 1 - Matrix must be square, symbolic ordering and analisis is performed on M = A + A' 2 - Symbolic ordering and analisis is performed on M = A' * A. Dense columns from A' are dropped, A recreated from A'. This is appropriatefor LU factorization of unsymmetric matrices. 3 - Symbolic ordering and analisis is performed on M = A' * A. This is best used for LU factorization is matrix M has no dense rows. A dense row is a row with more than 10*sqr(columns) entries.
-`threshold` | Number | Partial pivoting threshold (1 for partial pivoting)
-
-
-
-Test whether value x is smaller than y.
-
-The function returns true when x is smaller than y and the relative
-difference between x and y is smaller than the configured relTol and absTol. The
-function cannot be used to compare values smaller than approximately 2.22e-16.
-
-For matrices, the function is evaluated element wise.
-Strings are compared by their numerical value.
-
-
-
-
-Test whether value x is smaller or equal to y.
-
-The function returns true when x is smaller than y or the relative
-difference between x and y is smaller than the configured relTol and absTol. The
-function cannot be used to compare values smaller than approximately 2.22e-16.
-
-For matrices, the function is evaluated element wise.
-Strings are compared by their numerical value.
-
-
-
-
-Numerical Integration of Ordinary Differential Equations
-
-Two variable step methods are provided:
-- "RK23": Bogacki–Shampine method
-- "RK45": Dormand-Prince method RK5(4)7M (default)
-
-The arguments are expected as follows.
-
-- `func` should be the forcing function `f(t, y)`
-- `tspan` should be a vector of two numbers or units `[tStart, tEnd]`
-- `y0` the initial state values, should be a scalar or a flat array
-- `options` should be an object with the following information:
- - `method` ('RK45'): ['RK23', 'RK45']
- - `tol` (1e-3): Numeric tolerance of the method, the solver keeps the error estimates less than this value
- - `firstStep`: Initial step size
- - `minStep`: minimum step size of the method
- - `maxStep`: maximum step size of the method
- - `minDelta` (0.2): minimum ratio of change for the step
- - `maxDelta` (5): maximum ratio of change for the step
- - `maxIter` (1e4): maximum number of iterations
-
-The returned value is an object with `{t, y}` please note that even though `t` means time, it can represent any other independant variable like `x`:
-- `t` an array of size `[n]`
-- `y` the states array can be in two ways
- - **if `y0` is a scalar:** returns an array-like of size `[n]`
- - **if `y0` is a flat array-like of size [m]:** returns an array like of size `[n, m]`
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Matrix | Array | A one dimensional matrix or array to sort
-`compare` | Function | 'asc' | 'desc' | 'natural' | An optional _comparator function or name. The function is called as `compare(a, b)`, and must return 1 when a > b, -1 when a < b, and 0 when a == b. Default value: 'asc'.
-
-
-
-Create a Sparse Matrix. The function creates a new `math.Matrix` object from
-an `Array`. A Matrix has utility functions to manipulate the data in the
-matrix, like getting the size and getting or setting values in the matrix.
-Note that a Sparse Matrix is always 2-dimensional, so for example if
-you create one from a plain array of _n_ numbers, you get an _n_ by 1
-Sparse "column vector".
-
-
-
-
-Calculate the square root of a value.
-
-For matrices, if you want the matrix square root of a square matrix,
-use the `sqrtm` function. If you wish to apply `sqrt` elementwise to
-a matrix M, use `math.map(M, math.sqrt)`.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | Complex | Unit | Value for which to calculate the square root.
-
-
-
-Calculate the principal square root of a square matrix.
-The principal square root matrix `X` of another matrix `A` is such that `X * X = A`.
-
-https://en.wikipedia.org/wiki/Square_root_of_a_matrix
-
-
-
-
-Compute the square of a value, `x * x`.
-To avoid confusion with multiplying a square matrix by itself,
-this function does not apply to matrices. If you wish to square
-every element of a matrix, see the examples.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Fraction | Complex | Unit | Number for which to calculate the square
-
-
-
-Compute the standard deviation of a matrix or a list with values.
-The standard deviations is defined as the square root of the variance:
-`std(A) = sqrt(variance(A))`.
-In case of a (multi dimensional) array or matrix, the standard deviation
-over all elements will be calculated by default, unless an axis is specified
-in which case the standard deviation will be computed along that axis.
-
-Additionally, it is possible to compute the standard deviation along the rows
-or columns of a matrix by specifying the dimension as the second argument.
-
-Optionally, the type of normalization can be specified as the final
-parameter. The parameter `normalization` can be one of the following values:
-
-- 'unbiased' (default) The sum of squared errors is divided by (n - 1)
-- 'uncorrected' The sum of squared errors is divided by n
-- 'biased' The sum of squared errors is divided by (n + 1)
-
-
-
-
-The Stirling numbers of the second kind, counts the number of ways to partition
-a set of n labelled objects into k nonempty unlabelled subsets.
-stirlingS2 only takes integer arguments.
-The following condition must be enforced: k <= n.
-
- If n = k or k = 1 <= n, then s(n,k) = 1
- If k = 0 < n, then s(n,k) = 0
-
-Note that if either n or k is supplied as a BigNumber, the result will be
-as well.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`n` | Number | BigNumber | Total number of objects in the set
-`k` | Number | BigNumber | Number of objects in the subset
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`matrix` | Array | Matrix | string | An array, matrix, or string
-`index` | Index | For each dimension of the target, specifies an index or a list of indices to fetch or set. `subset` uses the cartesian product of the indices specified in each dimension.
-`replacement` | * | An array, matrix, or scalar. If provided, the subset is replaced with replacement. If not provided, the subset is returned
-`defaultValue` | * | Default value, filled in on new entries when the matrix is resized. If not provided, math.matrix elements will be left undefined. Default value: undefined.
-
-
-
-Compute the sum of a matrix or a list with values.
-In case of a multidimensional array or matrix, the sum of all
-elements will be calculated.
-
-
-
-
-Solves the real-valued Sylvester equation AX+XB=C for X, where A, B and C are
-matrices of appropriate dimensions, being A and B squared. Notice that other
-equivalent definitions for the Sylvester equation exist and this function
-assumes the one presented in the original publication of the the Bartels-
-Stewart algorithm, which is implemented by this function.
-https://en.wikipedia.org/wiki/Sylvester_equation
-
-
-
-
-Attempts to determine if two expressions are symbolically equal, i.e.
-one is the result of valid algebraic manipulations on the other.
-Currently, this simply checks if the difference of the two expressions
-simplifies down to 0. So there are two important caveats:
-1. whether two expressions are symbolically equal depends on the
- manipulations allowed. Therefore, this function takes an optional
- third argument, which are the options that control the behavior
- as documented for the `simplify()` function.
-2. it is in general intractable to find the minimal simplification of
- an arbitrarily complicated expression. So while a `true` value
- of `symbolicEqual` ensures that the two expressions can be manipulated
- to match each other, a `false` value does not absolutely rule this out.
-
-
-
-
-Calculate the tangent of a value. `tan(x)` is equal to `sin(x) / cos(x)`.
-
-To avoid confusion with the matrix tangent, this function does not apply
-to matrices.
-
-
-
-
-Calculate the hyperbolic tangent of a value,
-defined as `tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1)`.
-
-To avoid confusion with matrix hyperbolic tangent, this function does
-not apply to matrices.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | Unit | Array | Matrix | The unit to be converted.
-`unit` | Unit | Array | Matrix | New unit. Can be a string like "cm" or a unit without value.
-
-
-
-Transpose a matrix. All values of the matrix are reflected over its
-main diagonal. Only applicable to two dimensional matrices containing
-a vector (i.e. having size `[1,n]` or `[n,1]`). One dimensional
-vectors and scalars return the input unchanged.
-
-
-
-
-Type | Description
----- | -----------
-string | Returns the name of the type. Primitive types are lower case, non-primitive types are upper-camel-case. For example 'number', 'string', 'Array', 'Date'.
-
-
-
-
-Create a typed-function which checks the types of the arguments and
-can match them against multiple provided signatures. The typed-function
-automatically converts inputs in order to find a matching signature.
-Typed functions throw informative errors in case of wrong input arguments.
-
-See the library [typed-function](https://github.com/josdejong/typed-function)
-for detailed documentation.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`name` | string | Optional name for the typed-function
-`signatures` | Object<string, function> | Object with one or multiple function signatures
-
-
-
-```js
-// create a typed function with multiple types per argument (type union)
-const fn2 = typed({
- 'number | boolean': function (b) {
- return 'b is a number or boolean'
- },
- 'string, number | boolean': function (a, b) {
- return 'a is a string, b is a number or boolean'
- }
-})
-
-// create a typed function with an any type argument
-const log = typed({
- 'string, any': function (event, data) {
- console.log('event: ' + event + ', data: ' + JSON.stringify(data))
- }
-})
-```
-
-
diff --git a/docs/reference/functions/unaryMinus.md b/docs/reference/functions/unaryMinus.md
deleted file mode 100644
index fc142ca173..0000000000
--- a/docs/reference/functions/unaryMinus.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-layout: default
----
-
-
-
-
-
-Inverse the sign of a value, apply a unary minus operation.
-
-For matrices, the function is evaluated element wise. Boolean values and
-strings will be converted to a number. For complex numbers, both real and
-complex value are inverted.
-
-
-
-
-Unary plus operation.
-Boolean values and strings will be converted to a number, numeric values will be returned as is.
-
-For matrices, the function is evaluated element wise.
-
-
-
-
-Type | Description
----- | -----------
-number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix | Returns the input value when numeric, converts to a number when input is non-numeric.
-
-
-
-
-Test whether two values are unequal.
-
-The function tests whether the relative difference between x and y is
-larger than the configured relTol and absTol. The function cannot be used to compare
-values smaller than approximately 2.22e-16.
-
-For matrices, the function is evaluated element wise.
-In case of complex numbers, x.re must unequal y.re, or x.im must unequal y.im.
-Strings are compared by their numerical value.
-
-Values `null` and `undefined` are compared strictly, thus `null` is unequal
-with everything except `null`, and `undefined` is unequal with everything
-except `undefined`.
-
-
-
-
-Create a unit. Depending on the passed arguments, the function
-will create and return a new math.Unit object.
-When a matrix is provided, all elements will be converted to units.
-
-
-
-
-```js
-const a = math.unit(5, 'cm') // returns Unit 50 mm
-const b = math.unit('23 kg') // returns Unit 23 kg
-a.to('m') // returns Unit 0.05 m
-```
-
-
-
-
-Finds one solution of a linear equation system by backward substitution. Matrix must be an upper triangular matrix. Throws an error if there's no solution.
-
-`U * x = b`
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`U` | Matrix, Array | A N x N matrix or array (U)
-`b` | Matrix, Array | A column vector with the b values
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`U` | Matrix, Array | A N x N matrix or array (U)
-`b` | Matrix, Array | A column vector with the b values
-
-
-
-Type | Description
----- | -----------
-DenseMatrix[] | Array[] | An array of affine-independent column vectors (x) that solve the linear system
-
-
-
-
-Compute the variance of a matrix or a list with values.
-In case of a multidimensional array or matrix, the variance over all
-elements will be calculated.
-
-Additionally, it is possible to compute the variance along the rows
-or columns of a matrix by specifying the dimension as the second argument.
-
-Optionally, the type of normalization can be specified as the final
-parameter. The parameter `normalization` can be one of the following values:
-
-- 'unbiased' (default) The sum of squared errors is divided by (n - 1)
-- 'uncorrected' The sum of squared errors is divided by n
-- 'biased' The sum of squared errors is divided by (n + 1)
-
-
-Note that older browser may not like the variable name `var`. In that
-case, the function can be called as `math['var'](...)` instead of
-`math.var(...)`.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`a` | number | BigNumber | An integer number
-`b` | number | BigNumber | An integer number
-
-
-
-Logical `xor`. Test whether one and only one value is defined with a nonzero/nonempty value.
-For matrices, the function is evaluated element wise.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`x` | number | BigNumber | bigint | Complex | Unit | Array | Matrix | First value to check
-`y` | number | BigNumber | bigint | Complex | Unit | Array | Matrix | Second value to check
-
-
-
-Type | Description
----- | -----------
-boolean | Array | Matrix | Returns true when one and only one input is defined with a nonzero/nonempty value.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`size` | ...(number | BigNumber) | Array | The size of each dimension of the matrix
-`format` | string | The Matrix storage format
-
-
-
-Compute the Riemann Zeta function of a value using an infinite series for
-all of the complex plane using Riemann's Functional equation.
-
-Based off the paper by Xavier Gourdon and Pascal Sebah
-( http://numbers.computation.free.fr/Constants/Miscellaneous/zetaevaluations.pdf )
-
-Implementation and slight modification by Anik Patel
-
-Note: the implementation is accurate up to about 6 digits.
-
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`s` | number | Complex | BigNumber | A Real, Complex or BigNumber parameter to the Riemann Zeta Function
-
-
-
-Parameter | Type | Description
---------- | ---- | -----------
-`z` | Array | Array of zeros values
-`p` | Array | Array of poles values
-`k` | number | Gain value
-
-
-
-
-Math.js can be installed via [npm](https://npmjs.org/):
-
-```
-npm install mathjs
-```
-
-When installed globally with [npm](https://npmjs.org/) (using the `-g` option), math.js is available as a command line application `mathjs`, see documentation on [Command Line Interface](docs/command_line_interface.html). Math.js ships with built-in TypeScript type definitions.
-
-
-
-Here some notable extensions for mathjs:
-
-Extension | Description
---------- | -----------
-[mathsteps](https://github.com/socraticorg/mathsteps) | A step-by-step math solver library that is focused on pedagogy (how best to teach). The math problems it focuses on are pre-algebra and algebra problems involving simplifying expressions.
-[mathjs‑expression‑parser](https://github.com/josdejong/mathjs-expression-parser) | This custom build of mathjs contains just the expression parser and basic arithmetic functions for numbers. About four times as small as the full mathjs library.
-[mathjs-simple-integral](https://github.com/joelhoover/mathjs-simple-integral) | Extends Math.js to be able to compute simple integrals.
-[math.diff.js](https://github.com/hausen/math.diff.js) | Symbolic differentiation plugin for Math.js
-[postcss-math](https://github.com/shauns/postcss-math) | PostCSS plugin for making calculations with math.js
-
-
-
-
-Here some other interesting JavaScript math libraries. Some can be imported into math.js using `math.import`.
-
-Extension | Description
---------- | -----------
-[math‑expression‑evaluator](https://www.npmjs.com/package/math-expression-evaluator) | An extremely efficient, flexible and amazing evaluator for Math expression in Javascript.
-[numbers.js](https://github.com/numbers/numbers.js) | Advanced Mathematics Library for Node.js and JavaScript
-[numeric.js](https://github.com/sloisel/numeric) | Numerical analysis in Javascript
-[decimal.js](https://github.com/MikeMcl/decimal.js/) | An arbitrary-precision Decimal type for JavaScript. Used by mathjs for BigNumber support.
-[ndarray](https://github.com/scijs/ndarray) | Multidimensional arrays for JavaScript
-[Algebrite](https://github.com/davidedc/Algebrite) | Computer Algebra System in Javascript (Coffeescript)
-[algebra.js](https://github.com/nicolewhite/algebra.js) | Build, display, and solve algebraic equations
-[Nerdamer](https://nerdamer.com) | Symbolic Math for Javascript
-[numeral-js](https://github.com/adamwdraper/Numeral-js) | A javascript library for formatting and manipulating numbers
-[Cortex Compute Engine](https://github.com/cortex-js/compute-engine) | The Cortex Compute Engine can parse LaTeX to MathJSON, serialize MathJSON to LaTeX, format, simplify and evaluate MathJSON expressions
-
-
-
-
-
-Math.js works on any ES5 compatible JavaScript engine: node.js, Chrome, Firefox, Safari, Edge, and IE11.
-
-Though there is no official support for older browsers, math.js should still work on older browsers
-when using the [es5-shim](https://github.com/kriskowal/es5-shim).
-
-
-
-
-Math.js is open source and licensed under the
-[Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
diff --git a/examples/advanced/convert_fraction_to_bignumber.js b/examples/advanced/convert_fraction_to_bignumber.js
deleted file mode 100644
index 989dfb15f5..0000000000
--- a/examples/advanced/convert_fraction_to_bignumber.js
+++ /dev/null
@@ -1,57 +0,0 @@
-// Convert from Fraction to BigNumber
-//
-// In the configuration of math.js one can specify the default number type to
-// be `number`, `BigNumber`, or `Fraction`. Not all functions support `Fraction`
-// or `BigNumber`, and if not supported these input types will be converted to
-// numbers.
-//
-// When `Fraction` is configured, one may want to fallback to `BigNumber`
-// instead of `number`. Also, one may want to be able to mix `Fraction` and
-// `BigNumber` in operations like summing them up. This can be achieved by
-// adding an extra conversion to the list of conversions as demonstrated in
-// this example.
-
-// Create an empty math.js instance, with only typed
-// (every instance contains `import` and `config` also out of the box)
-import { create, typedDependencies, all } from 'mathjs'
-const math = create({
- typedDependencies
-})
-
-// TODO: this should be much easier
-const allExceptLoaded = Object.keys(all)
- .map(key => all[key])
- .filter(factory => math[factory.fn] === undefined)
-
-// Configure to use fractions by default
-math.config({ number: 'Fraction' })
-
-// Add a conversion from Faction -> BigNumber
-// This conversion will to override the existing conversion from Fraction to
-// BigNumber. It must be added *after* the default conversions are loaded
-// and *before* the actual functions are imported into math.js.
-math.typed.addConversion({
- from: 'Fraction',
- to: 'BigNumber',
- convert: (fraction) => new math.BigNumber(fraction.n).div(fraction.d)
-}, { override: true })
-
-// Import all data types, functions, constants, the expression parser, etc.
-math.import(allExceptLoaded)
-
-// Operators `add` and `divide` do have support for Fractions, so the result
-// will simply be a Fraction (default behavior of math.js).
-const ans1 = math.evaluate('1/3 + 1/4')
-console.log(math.typeOf(ans1), math.format(ans1))
-// outputs "Fraction 7/12"
-
-// Function sqrt doesn't have Fraction support, will now fall back to BigNumber
-// instead of number.
-const ans2 = math.evaluate('sqrt(4)')
-console.log(math.typeOf(ans2), math.format(ans2))
-// outputs "BigNumber 2"
-
-// We can now do operations with mixed Fractions and BigNumbers
-const ans3 = math.add(math.fraction(2, 5), math.bignumber(3))
-console.log(math.typeOf(ans3), math.format(ans3))
-// outputs "BigNumber 3.4"
diff --git a/examples/advanced/convert_fraction_to_bignumber.js.md b/examples/advanced/convert_fraction_to_bignumber.js.md
deleted file mode 100644
index 9f6b687828..0000000000
--- a/examples/advanced/convert_fraction_to_bignumber.js.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-layout: default
----
-
-# Convert fraction to bignumber
-
-File: [convert_fraction_to_bignumber.js](convert_fraction_to_bignumber.js)
-
-```js
-// Convert from Fraction to BigNumber
-//
-// In the configuration of math.js one can specify the default number type to
-// be `number`, `BigNumber`, or `Fraction`. Not all functions support `Fraction`
-// or `BigNumber`, and if not supported these input types will be converted to
-// numbers.
-//
-// When `Fraction` is configured, one may want to fallback to `BigNumber`
-// instead of `number`. Also, one may want to be able to mix `Fraction` and
-// `BigNumber` in operations like summing them up. This can be achieved by
-// adding an extra conversion to the list of conversions as demonstrated in
-// this example.
-
-// Create an empty math.js instance, with only typed
-// (every instance contains `import` and `config` also out of the box)
-import { create, typedDependencies, all } from 'mathjs'
-const math = create({
- typedDependencies
-})
-
-// TODO: this should be much easier
-const allExceptLoaded = Object.keys(all)
- .map(key => all[key])
- .filter(factory => math[factory.fn] === undefined)
-
-// Configure to use fractions by default
-math.config({ number: 'Fraction' })
-
-// Add a conversion from Faction -> BigNumber
-// This conversion will to override the existing conversion from Fraction to
-// BigNumber. It must be added *after* the default conversions are loaded
-// and *before* the actual functions are imported into math.js.
-math.typed.addConversion({
- from: 'Fraction',
- to: 'BigNumber',
- convert: (fraction) => new math.BigNumber(fraction.n).div(fraction.d)
-}, { override: true })
-
-// Import all data types, functions, constants, the expression parser, etc.
-math.import(allExceptLoaded)
-
-// Operators `add` and `divide` do have support for Fractions, so the result
-// will simply be a Fraction (default behavior of math.js).
-const ans1 = math.evaluate('1/3 + 1/4')
-console.log(math.typeOf(ans1), math.format(ans1))
-// outputs "Fraction 7/12"
-
-// Function sqrt doesn't have Fraction support, will now fall back to BigNumber
-// instead of number.
-const ans2 = math.evaluate('sqrt(4)')
-console.log(math.typeOf(ans2), math.format(ans2))
-// outputs "BigNumber 2"
-
-// We can now do operations with mixed Fractions and BigNumbers
-const ans3 = math.add(math.fraction(2, 5), math.bignumber(3))
-console.log(math.typeOf(ans3), math.format(ans3))
-// outputs "BigNumber 3.4"
-
-```
-
-
-
diff --git a/examples/advanced/custom_argument_parsing.js b/examples/advanced/custom_argument_parsing.js
deleted file mode 100644
index 27d3eed6e5..0000000000
--- a/examples/advanced/custom_argument_parsing.js
+++ /dev/null
@@ -1,94 +0,0 @@
-/**
- * The expression parser of math.js has support for letting functions
- * parse and evaluate arguments themselves, instead of calling them with
- * evaluated arguments.
- *
- * By adding a property `raw` with value true to a function, the function
- * will be invoked with unevaluated arguments, allowing the function
- * to process the arguments in a customized way.
- */
-import { create, all } from 'mathjs'
-const math = create(all)
-
-/**
- * Calculate the numeric integration of a function
- * @param {Function} f
- * @param {number} start
- * @param {number} end
- * @param {number} [step=0.01]
- */
-function integrate (f, start, end, step) {
- let total = 0
- step = step || 0.01
- for (let x = start; x < end; x += step) {
- total += f(x + step / 2) * step
- }
- return total
-}
-
-/**
- * A transformation for the integrate function. This transformation will be
- * invoked when the function is used via the expression parser of math.js.
- *
- * Syntax:
- *
- * integrate(integrand, variable, start, end)
- * integrate(integrand, variable, start, end, step)
- *
- * Usage:
- *
- * math.evaluate('integrate(2*x, x, 0, 2)')
- * math.evaluate('integrate(2*x, x, 0, 2, 0.01)')
- *
- * @param {Array.} args
- * Expects the following arguments: [f, x, start, end, step]
- * @param {Object} math
- * @param {Map} [scope]
- */
-integrate.transform = function (args, math, scope) {
- // determine the variable name
- if (!args[1].isSymbolNode) {
- throw new Error('Second argument must be a symbol')
- }
- const variable = args[1].name
-
- // evaluate start, end, and step
- const start = args[2].compile().evaluate(scope)
- const end = args[3].compile().evaluate(scope)
- const step = args[4] && args[4].compile().evaluate(scope) // step is optional
-
- // construct a function which evaluates the first parameter f after applying
- // a value for parameter x.
- const fnCode = args[0].compile()
- const f = function (x) {
- scope.set(variable, x)
- return fnCode.evaluate(scope)
- }
-
- // execute the integration
- return integrate(f, start, end, step)
-}
-
-// mark the transform function with a "rawArgs" property, so it will be called
-// with uncompiled, unevaluated arguments.
-integrate.transform.rawArgs = true
-
-// import the function into math.js. Raw functions must be imported in the
-// math namespace, they can't be used via `evaluate(scope)`.
-math.import({
- integrate
-})
-
-// use the function in JavaScript
-function f (x) {
- return math.pow(x, 0.5)
-}
-console.log(math.integrate(f, 0, 1)) // outputs 0.6667254718034714
-
-// use the function via the expression parser
-console.log(math.evaluate('integrate(x^0.5, x, 0, 1)')) // outputs 0.6667254718034714
-
-// use the function via the expression parser (2)
-const scope = new Map()
-math.evaluate('f(x) = 2 * x', scope)
-console.log(math.evaluate('integrate(f(x), x, 0, 2)', scope)) // outputs 4.000000000000003
diff --git a/examples/advanced/custom_argument_parsing.js.md b/examples/advanced/custom_argument_parsing.js.md
deleted file mode 100644
index cb9a5de63c..0000000000
--- a/examples/advanced/custom_argument_parsing.js.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-layout: default
----
-
-# Custom argument parsing
-
-File: [custom_argument_parsing.js](custom_argument_parsing.js)
-
-```js
-/**
- * The expression parser of math.js has support for letting functions
- * parse and evaluate arguments themselves, instead of calling them with
- * evaluated arguments.
- *
- * By adding a property `raw` with value true to a function, the function
- * will be invoked with unevaluated arguments, allowing the function
- * to process the arguments in a customized way.
- */
-import { create, all } from 'mathjs'
-const math = create(all)
-
-/**
- * Calculate the numeric integration of a function
- * @param {Function} f
- * @param {number} start
- * @param {number} end
- * @param {number} [step=0.01]
- */
-function integrate (f, start, end, step) {
- let total = 0
- step = step || 0.01
- for (let x = start; x < end; x += step) {
- total += f(x + step / 2) * step
- }
- return total
-}
-
-/**
- * A transformation for the integrate function. This transformation will be
- * invoked when the function is used via the expression parser of math.js.
- *
- * Syntax:
- *
- * integrate(integrand, variable, start, end)
- * integrate(integrand, variable, start, end, step)
- *
- * Usage:
- *
- * math.evaluate('integrate(2*x, x, 0, 2)')
- * math.evaluate('integrate(2*x, x, 0, 2, 0.01)')
- *
- * @param {Array.} args
- * Expects the following arguments: [f, x, start, end, step]
- * @param {Object} math
- * @param {Map} [scope]
- */
-integrate.transform = function (args, math, scope) {
- // determine the variable name
- if (!args[1].isSymbolNode) {
- throw new Error('Second argument must be a symbol')
- }
- const variable = args[1].name
-
- // evaluate start, end, and step
- const start = args[2].compile().evaluate(scope)
- const end = args[3].compile().evaluate(scope)
- const step = args[4] && args[4].compile().evaluate(scope) // step is optional
-
- // construct a function which evaluates the first parameter f after applying
- // a value for parameter x.
- const fnCode = args[0].compile()
- const f = function (x) {
- scope.set(variable, x)
- return fnCode.evaluate(scope)
- }
-
- // execute the integration
- return integrate(f, start, end, step)
-}
-
-// mark the transform function with a "rawArgs" property, so it will be called
-// with uncompiled, unevaluated arguments.
-integrate.transform.rawArgs = true
-
-// import the function into math.js. Raw functions must be imported in the
-// math namespace, they can't be used via `evaluate(scope)`.
-math.import({
- integrate
-})
-
-// use the function in JavaScript
-function f (x) {
- return math.pow(x, 0.5)
-}
-console.log(math.integrate(f, 0, 1)) // outputs 0.6667254718034714
-
-// use the function via the expression parser
-console.log(math.evaluate('integrate(x^0.5, x, 0, 1)')) // outputs 0.6667254718034714
-
-// use the function via the expression parser (2)
-const scope = new Map()
-math.evaluate('f(x) = 2 * x', scope)
-console.log(math.evaluate('integrate(f(x), x, 0, 2)', scope)) // outputs 4.000000000000003
-
-```
-
-
-
diff --git a/examples/advanced/custom_datatype.js b/examples/advanced/custom_datatype.js
deleted file mode 100644
index 43c61ed9de..0000000000
--- a/examples/advanced/custom_datatype.js
+++ /dev/null
@@ -1,57 +0,0 @@
-// This example demonstrates importing a custom data type,
-// and extending an existing function (add) with support for this data type.
-
-import { all, create, factory } from 'mathjs'
-
-const math = create(all)
-
-// factory function which defines a new data type CustomValue
-const createCustomValue = factory('CustomValue', ['typed'], ({ typed }) => {
- // create a new data type
- function CustomValue (value) {
- this.value = value
- }
- CustomValue.prototype.isCustomValue = true
- CustomValue.prototype.toString = function () {
- return 'CustomValue:' + this.value
- }
-
- // define a new data type with typed-function
- typed.addType({
- name: 'CustomValue',
- test: function (x) {
- // test whether x is of type CustomValue
- return x && x.isCustomValue === true
- }
- })
-
- return CustomValue
-})
-
-// function add which can add the CustomValue data type
-// When imported in math.js, the existing function `add` with support for
-// CustomValue, because both implementations are typed-functions and do not
-// have conflicting signatures.
-const createAddCustomValue = factory('add', ['typed', 'CustomValue'], ({ typed, CustomValue }) => {
- return typed('add', {
- 'CustomValue, CustomValue': function (a, b) {
- return new CustomValue(a.value + b.value)
- }
- })
-})
-
-// import the new data type and function
-math.import([
- createCustomValue,
- createAddCustomValue
-])
-
-// use the new type
-const ans1 = math.add(new math.CustomValue(2), new math.CustomValue(3))
-console.log(ans1.toString())
-// outputs 'CustomValue:5'
-
-// you can automatically use the new type in functions which use `add` under the hood:
-const ans2 = math.sum(new math.CustomValue(6), new math.CustomValue(1), new math.CustomValue(2))
-console.log(ans2.toString())
-// outputs 'CustomValue:9'
diff --git a/examples/advanced/custom_datatype.js.md b/examples/advanced/custom_datatype.js.md
deleted file mode 100644
index b6aaa71510..0000000000
--- a/examples/advanced/custom_datatype.js.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-layout: default
----
-
-# Custom datatype
-
-File: [custom_datatype.js](custom_datatype.js)
-
-```js
-// This example demonstrates importing a custom data type,
-// and extending an existing function (add) with support for this data type.
-
-import { all, create, factory } from 'mathjs'
-
-const math = create(all)
-
-// factory function which defines a new data type CustomValue
-const createCustomValue = factory('CustomValue', ['typed'], ({ typed }) => {
- // create a new data type
- function CustomValue (value) {
- this.value = value
- }
- CustomValue.prototype.isCustomValue = true
- CustomValue.prototype.toString = function () {
- return 'CustomValue:' + this.value
- }
-
- // define a new data type with typed-function
- typed.addType({
- name: 'CustomValue',
- test: function (x) {
- // test whether x is of type CustomValue
- return x && x.isCustomValue === true
- }
- })
-
- return CustomValue
-})
-
-// function add which can add the CustomValue data type
-// When imported in math.js, the existing function `add` with support for
-// CustomValue, because both implementations are typed-functions and do not
-// have conflicting signatures.
-const createAddCustomValue = factory('add', ['typed', 'CustomValue'], ({ typed, CustomValue }) => {
- return typed('add', {
- 'CustomValue, CustomValue': function (a, b) {
- return new CustomValue(a.value + b.value)
- }
- })
-})
-
-// import the new data type and function
-math.import([
- createCustomValue,
- createAddCustomValue
-])
-
-// use the new type
-const ans1 = math.add(new math.CustomValue(2), new math.CustomValue(3))
-console.log(ans1.toString())
-// outputs 'CustomValue:5'
-
-// you can automatically use the new type in functions which use `add` under the hood:
-const ans2 = math.sum(new math.CustomValue(6), new math.CustomValue(1), new math.CustomValue(2))
-console.log(ans2.toString())
-// outputs 'CustomValue:9'
-
-```
-
-
-
diff --git a/examples/advanced/custom_evaluate_using_factories.js b/examples/advanced/custom_evaluate_using_factories.js
deleted file mode 100644
index 654b991925..0000000000
--- a/examples/advanced/custom_evaluate_using_factories.js
+++ /dev/null
@@ -1,22 +0,0 @@
-// we use the number only implementation in order to not pull in
-// the `Unit` class for example. when using as library,
-// use import 'mathjs/number'
-import { create, evaluateDependencies, factory } from 'mathjs/number'
-
-// custom implementations of all functions you want to support
-const add = (a, b) => a + b
-const subtract = (a, b) => a - b
-const multiply = (a, b) => a * b
-const divide = (a, b) => a / b
-
-// create factories for the functions, and create an evaluate function with those
-// these functions will also be used by the classes like Unit.
-const { evaluate } = create({
- evaluateDependencies,
- createAdd: factory('add', [], () => add),
- createSubtract: factory('subtract', [], () => subtract),
- createMultiply: factory('multiply', [], () => multiply),
- createDivide: factory('divide', [], () => divide)
-})
-
-console.log(evaluate('2 + 3 * 4')) // 14
diff --git a/examples/advanced/custom_evaluate_using_factories.js.md b/examples/advanced/custom_evaluate_using_factories.js.md
deleted file mode 100644
index a1365c7054..0000000000
--- a/examples/advanced/custom_evaluate_using_factories.js.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-layout: default
----
-
-# Custom evaluate using factories
-
-File: [custom_evaluate_using_factories.js](custom_evaluate_using_factories.js)
-
-```js
-// we use the number only implementation in order to not pull in
-// the `Unit` class for example. when using as library,
-// use import 'mathjs/number'
-import { create, evaluateDependencies, factory } from 'mathjs/number'
-
-// custom implementations of all functions you want to support
-const add = (a, b) => a + b
-const subtract = (a, b) => a - b
-const multiply = (a, b) => a * b
-const divide = (a, b) => a / b
-
-// create factories for the functions, and create an evaluate function with those
-// these functions will also be used by the classes like Unit.
-const { evaluate } = create({
- evaluateDependencies,
- createAdd: factory('add', [], () => add),
- createSubtract: factory('subtract', [], () => subtract),
- createMultiply: factory('multiply', [], () => multiply),
- createDivide: factory('divide', [], () => divide)
-})
-
-console.log(evaluate('2 + 3 * 4')) // 14
-
-```
-
-
-
diff --git a/examples/advanced/custom_evaluate_using_import.js b/examples/advanced/custom_evaluate_using_import.js
deleted file mode 100644
index 7df8553fd9..0000000000
--- a/examples/advanced/custom_evaluate_using_import.js
+++ /dev/null
@@ -1,21 +0,0 @@
-// we use the number only implementation in order to not pull in
-// the `Unit` class for example. when using as library,
-// use require('mathjs/number')
-import { create, evaluateDependencies } from 'mathjs/number'
-
-// custom implementations of all functions you want to support
-const add = (a, b) => a + b
-const subtract = (a, b) => a - b
-const multiply = (a, b) => a * b
-const divide = (a, b) => a / b
-
-// create a mathjs instance with hardly any functions
-// there are some functions created which are used internally by evaluate though,
-// for example by the Unit class which has dependencies on addScalar, subtractScalar,
-// multiplyScalar, etc.
-const math = create(evaluateDependencies)
-
-// import your own functions
-math.import({ add, subtract, multiply, divide }, { override: true })
-
-console.log(math.evaluate('2 + 3 * 4')) // 14
diff --git a/examples/advanced/custom_evaluate_using_import.js.md b/examples/advanced/custom_evaluate_using_import.js.md
deleted file mode 100644
index 141d9e2432..0000000000
--- a/examples/advanced/custom_evaluate_using_import.js.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-layout: default
----
-
-# Custom evaluate using import
-
-File: [custom_evaluate_using_import.js](custom_evaluate_using_import.js)
-
-```js
-// we use the number only implementation in order to not pull in
-// the `Unit` class for example. when using as library,
-// use require('mathjs/number')
-import { create, evaluateDependencies } from 'mathjs/number'
-
-// custom implementations of all functions you want to support
-const add = (a, b) => a + b
-const subtract = (a, b) => a - b
-const multiply = (a, b) => a * b
-const divide = (a, b) => a / b
-
-// create a mathjs instance with hardly any functions
-// there are some functions created which are used internally by evaluate though,
-// for example by the Unit class which has dependencies on addScalar, subtractScalar,
-// multiplyScalar, etc.
-const math = create(evaluateDependencies)
-
-// import your own functions
-math.import({ add, subtract, multiply, divide }, { override: true })
-
-console.log(math.evaluate('2 + 3 * 4')) // 14
-
-```
-
-
-
diff --git a/examples/advanced/custom_loading.js b/examples/advanced/custom_loading.js
deleted file mode 100644
index 55ed67555a..0000000000
--- a/examples/advanced/custom_loading.js
+++ /dev/null
@@ -1,36 +0,0 @@
-import {
- addDependencies,
- create,
- divideDependencies,
- formatDependencies,
- fractionDependencies
-} 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"
-
-// Now, when bundling your application for use in the browser, only the used
-// parts of math.js will be bundled. For example to create a bundle using Webpack:
-//
-// npx webpack-cli ./custom_loading.mjs --output-path custom_loading_bundle --mode=production
-//
-// Read more about what bundle sizes you can expect here:
-//
-// https://mathjs.org/docs/custom_bundling.html
diff --git a/examples/advanced/custom_loading.js.md b/examples/advanced/custom_loading.js.md
deleted file mode 100644
index db13492fd8..0000000000
--- a/examples/advanced/custom_loading.js.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-layout: default
----
-
-# Custom loading
-
-File: [custom_loading.js](custom_loading.js)
-
-```js
-import {
- addDependencies,
- create,
- divideDependencies,
- formatDependencies,
- fractionDependencies
-} 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"
-
-// Now, when bundling your application for use in the browser, only the used
-// parts of math.js will be bundled. For example to create a bundle using Webpack:
-//
-// npx webpack-cli ./custom_loading.mjs --output-path custom_loading_bundle --mode=production
-//
-// Read more about what bundle sizes you can expect here:
-//
-// https://mathjs.org/docs/custom_bundling.html
-
-```
-
-
-
diff --git a/examples/advanced/custom_relational_functions.js b/examples/advanced/custom_relational_functions.js
deleted file mode 100644
index 5a8860cd55..0000000000
--- a/examples/advanced/custom_relational_functions.js
+++ /dev/null
@@ -1,62 +0,0 @@
-import { all, create, factory } from 'mathjs'
-
-// 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())
- }
-}
diff --git a/examples/advanced/custom_relational_functions.js.md b/examples/advanced/custom_relational_functions.js.md
deleted file mode 100644
index 44f2f9ccef..0000000000
--- a/examples/advanced/custom_relational_functions.js.md
+++ /dev/null
@@ -1,76 +0,0 @@
----
-layout: default
----
-
-# Custom relational functions
-
-File: [custom_relational_functions.js](custom_relational_functions.js)
-
-```js
-import { all, create, factory } from 'mathjs'
-
-// 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())
- }
-}
-
-```
-
-
-
diff --git a/examples/advanced/custom_scope_objects.js b/examples/advanced/custom_scope_objects.js
deleted file mode 100644
index aedc11a253..0000000000
--- a/examples/advanced/custom_scope_objects.js
+++ /dev/null
@@ -1,109 +0,0 @@
-import { all, create } from 'mathjs'
-
-const math = create(all)
-
-// The expression evaluator accepts an optional scope Map or object that can
-// be used to keep additional variables and functions.
-
-// 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)
-}
-
-// This is a minimal set of functions to look like a Map.
-class CustomMap {
- 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 AdvancedCustomMap extends CustomMap {
- 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()
- }
-
- toString () {
- return this.localScope.toString()
- }
-}
-
-// Use a plain JavaScript object
-withObjectScope()
-
-// use a Map (recommended)
-withMapScope(new Map(), 'Map example')
-
-// Use a custom Map implementation
-withMapScope(new CustomMap(), 'CustomMap example')
-
-// Use a more advanced custom Map implementation
-withMapScope(new AdvancedCustomMap(), 'AdvancedCustomMap example')
diff --git a/examples/advanced/custom_scope_objects.js.md b/examples/advanced/custom_scope_objects.js.md
deleted file mode 100644
index f40c59939d..0000000000
--- a/examples/advanced/custom_scope_objects.js.md
+++ /dev/null
@@ -1,123 +0,0 @@
----
-layout: default
----
-
-# Custom scope objects
-
-File: [custom_scope_objects.js](custom_scope_objects.js)
-
-```js
-import { all, create } from 'mathjs'
-
-const math = create(all)
-
-// The expression evaluator accepts an optional scope Map or object that can
-// be used to keep additional variables and functions.
-
-// 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)
-}
-
-// This is a minimal set of functions to look like a Map.
-class CustomMap {
- 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 AdvancedCustomMap extends CustomMap {
- 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()
- }
-
- toString () {
- return this.localScope.toString()
- }
-}
-
-// Use a plain JavaScript object
-withObjectScope()
-
-// use a Map (recommended)
-withMapScope(new Map(), 'Map example')
-
-// Use a custom Map implementation
-withMapScope(new CustomMap(), 'CustomMap example')
-
-// Use a more advanced custom Map implementation
-withMapScope(new AdvancedCustomMap(), 'AdvancedCustomMap example')
-
-```
-
-
-
diff --git a/examples/advanced/expression_trees.js b/examples/advanced/expression_trees.js
deleted file mode 100644
index bb5c3162cf..0000000000
--- a/examples/advanced/expression_trees.js
+++ /dev/null
@@ -1,55 +0,0 @@
-import { parse, ConstantNode } from 'mathjs'
-
-// 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'
diff --git a/examples/advanced/expression_trees.js.md b/examples/advanced/expression_trees.js.md
deleted file mode 100644
index 7579fb1757..0000000000
--- a/examples/advanced/expression_trees.js.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-layout: default
----
-
-# Expression trees
-
-File: [expression_trees.js](expression_trees.js)
-
-```js
-import { parse, ConstantNode } from 'mathjs'
-
-// 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'
-
-```
-
-
-
diff --git a/examples/advanced/function_transform.js b/examples/advanced/function_transform.js
deleted file mode 100644
index b950d2bc0e..0000000000
--- a/examples/advanced/function_transform.js
+++ /dev/null
@@ -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.
- */
-import { all, create } from 'mathjs'
-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
diff --git a/examples/advanced/function_transform.js.md b/examples/advanced/function_transform.js.md
deleted file mode 100644
index bee123efdf..0000000000
--- a/examples/advanced/function_transform.js.md
+++ /dev/null
@@ -1,64 +0,0 @@
----
-layout: default
----
-
-# Function transform
-
-File: [function_transform.js](function_transform.js)
-
-```js
-/**
- * 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.
- */
-import { all, create } from 'mathjs'
-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
-
-```
-
-
-
diff --git a/examples/advanced/more_secure_eval.js b/examples/advanced/more_secure_eval.js
deleted file mode 100644
index 0fc73dd6be..0000000000
--- a/examples/advanced/more_secure_eval.js
+++ /dev/null
@@ -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.
-
-import { all, create } from 'mathjs'
-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
diff --git a/examples/advanced/more_secure_eval.js.md b/examples/advanced/more_secure_eval.js.md
deleted file mode 100644
index b443aeb702..0000000000
--- a/examples/advanced/more_secure_eval.js.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-layout: default
----
-
-# More secure eval
-
-File: [more_secure_eval.js](more_secure_eval.js)
-
-```js
-// 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.
-
-import { all, create } from 'mathjs'
-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
-
-```
-
-
-
diff --git a/examples/advanced/web_server/index.md b/examples/advanced/web_server/index.md
deleted file mode 100644
index 19c939d24f..0000000000
--- a/examples/advanced/web_server/index.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-layout: default
----
-
-# Web server
-
-File: [math_worker.js](math_worker.js)
-
-```js
-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
-})
-
-```
-
-File: [server.js](server.js)
-
-```js
-/**
- * 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)')
-})
-
-```
-
-
-
diff --git a/examples/advanced/web_server/math_worker.js b/examples/advanced/web_server/math_worker.js
deleted file mode 100644
index 56cd4973c7..0000000000
--- a/examples/advanced/web_server/math_worker.js
+++ /dev/null
@@ -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
-})
diff --git a/examples/advanced/web_server/server.js b/examples/advanced/web_server/server.js
deleted file mode 100644
index 24dba89a44..0000000000
--- a/examples/advanced/web_server/server.js
+++ /dev/null
@@ -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)')
-})
diff --git a/examples/algebra.js b/examples/algebra.js
deleted file mode 100644
index 9180e885ef..0000000000
--- a/examples/algebra.js
+++ /dev/null
@@ -1,32 +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.
-import { simplify, parse, derivative } from 'mathjs'
-
-// 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'
diff --git a/examples/algebra.js.md b/examples/algebra.js.md
deleted file mode 100644
index 0530885833..0000000000
--- a/examples/algebra.js.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-layout: default
----
-
-# Algebra
-
-File: [algebra.js](algebra.js)
-
-```js
-// 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.
-import { simplify, parse, derivative } from 'mathjs'
-
-// 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'
-
-```
-
-
-
diff --git a/examples/basic_usage.js b/examples/basic_usage.js
deleted file mode 100644
index 1cbf96ab3b..0000000000
--- a/examples/basic_usage.js
+++ /dev/null
@@ -1,64 +0,0 @@
-// basic usage
-import {
- add,
- atan2,
- chain,
- derivative,
- e,
- evaluate,
- format,
- log,
- matrix,
- multiply,
- pi,
- pow,
- round,
- sqrt,
- subtract,
- unit
-} from 'mathjs'
-
-// functions and constants
-console.log('functions and constants')
-print(round(e, 3)) // 2.718
-print(atan2(3, -3) / pi) // 0.75
-print(log(10000, 10)) // 4
-print(sqrt(-4)) // 2i
-print(pow([[-1, 2], [3, 1]], 2)) // [[7, 0], [0, 7]]
-print(derivative('x^2 + x', 'x')) // 2 * x + 1
-console.log()
-
-// expressions
-console.log('expressions')
-print(evaluate('1.2 * (2 + 4.5)')) // 7.8
-print(evaluate('12.7 cm to inch')) // 5 inch
-print(evaluate('sin(45 deg) ^ 2')) // 0.5
-print(evaluate('9 / 3 + 2i')) // 3 + 2i
-print(evaluate('det([-1, 2; 3, 1])')) // -7
-console.log()
-
-// chained operations
-console.log('chained operations')
-const a = 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(add(4, [5, 6])) // number + Array, [9, 10]
-print(multiply(unit('5 mm'), 3)) // Unit * number, 15 mm
-print(subtract([2, 3, 4], 5)) // Array - number, [-3, -2, -1]
-print(add(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(format(value, precision))
-}
diff --git a/examples/basic_usage.js.md b/examples/basic_usage.js.md
deleted file mode 100644
index b943bf3a19..0000000000
--- a/examples/basic_usage.js.md
+++ /dev/null
@@ -1,78 +0,0 @@
----
-layout: default
----
-
-# Basic usage
-
-File: [basic_usage.js](basic_usage.js)
-
-```js
-// basic usage
-import {
- add,
- atan2,
- chain,
- derivative,
- e,
- evaluate,
- format,
- log,
- matrix,
- multiply,
- pi,
- pow,
- round,
- sqrt,
- subtract,
- unit
-} from 'mathjs'
-
-// functions and constants
-console.log('functions and constants')
-print(round(e, 3)) // 2.718
-print(atan2(3, -3) / pi) // 0.75
-print(log(10000, 10)) // 4
-print(sqrt(-4)) // 2i
-print(pow([[-1, 2], [3, 1]], 2)) // [[7, 0], [0, 7]]
-print(derivative('x^2 + x', 'x')) // 2 * x + 1
-console.log()
-
-// expressions
-console.log('expressions')
-print(evaluate('1.2 * (2 + 4.5)')) // 7.8
-print(evaluate('12.7 cm to inch')) // 5 inch
-print(evaluate('sin(45 deg) ^ 2')) // 0.5
-print(evaluate('9 / 3 + 2i')) // 3 + 2i
-print(evaluate('det([-1, 2; 3, 1])')) // -7
-console.log()
-
-// chained operations
-console.log('chained operations')
-const a = 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(add(4, [5, 6])) // number + Array, [9, 10]
-print(multiply(unit('5 mm'), 3)) // Unit * number, 15 mm
-print(subtract([2, 3, 4], 5)) // Array - number, [-3, -2, -1]
-print(add(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(format(value, precision))
-}
-
-```
-
-
-
diff --git a/examples/bignumbers.js b/examples/bignumbers.js
deleted file mode 100644
index 56a8fc9df6..0000000000
--- a/examples/bignumbers.js
+++ /dev/null
@@ -1,49 +0,0 @@
-// BigNumbers
-import { create, all } from 'mathjs'
-
-// 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))
-}
diff --git a/examples/bignumbers.js.md b/examples/bignumbers.js.md
deleted file mode 100644
index 2ca8999f59..0000000000
--- a/examples/bignumbers.js.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-layout: default
----
-
-# Bignumbers
-
-File: [bignumbers.js](bignumbers.js)
-
-```js
-// BigNumbers
-import { create, all } from 'mathjs'
-
-// 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))
-}
-
-```
-
-
-
diff --git a/examples/browser/angle_configuration.html b/examples/browser/angle_configuration.html
deleted file mode 100644
index ce8803a723..0000000000
--- a/examples/browser/angle_configuration.html
+++ /dev/null
@@ -1,134 +0,0 @@
-
-
-
-
- math.js | angle configuration
-
-
-
-
-
-
-
- This code example extends the trigonometric functions of math.js with configurable angles: degrees, radians, or gradians.
-
-
-
-
-
Angles
-
-
-
-
-
-
Expression
-
-
-
-
-
-
-
Result
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/examples/browser/angle_configuration.html.md b/examples/browser/angle_configuration.html.md
deleted file mode 100644
index 9f965b36a1..0000000000
--- a/examples/browser/angle_configuration.html.md
+++ /dev/null
@@ -1,147 +0,0 @@
----
-layout: default
----
-
-# Angle configuration
-
-File: [angle_configuration.html](angle_configuration.html) (click for a live demo)
-
-```html
-
-
-
-
- math.js | angle configuration
-
-
-
-
-
-
-
- This code example extends the trigonometric functions of math.js with configurable angles: degrees, radians, or gradians.
-
- In this example, a math.js parser is running in a separate
- web worker,
- preventing the user interface from freezing during heavy calculations.
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/examples/browser/webworkers/worker.js b/examples/browser/webworkers/worker.js
deleted file mode 100644
index 452c9b678e..0000000000
--- a/examples/browser/webworkers/worker.js
+++ /dev/null
@@ -1,28 +0,0 @@
-importScripts('https://unpkg.com/mathjs@14.5.2/lib/browser/math.js')
-
-// create a parser
-const parser = self.math.parser()
-
-self.addEventListener('message', function (event) {
- const request = JSON.parse(event.data)
- let result = null
- let err = null
-
- try {
- // evaluate the expression
- result = parser.evaluate(request.expr)
- } catch (e) {
- // return the error
- err = e
- }
-
- // build a response
- const response = {
- id: request.id,
- result: self.math.format(result),
- err: err
- }
-
- // send the response back
- self.postMessage(JSON.stringify(response))
-}, false)
diff --git a/examples/chaining.js b/examples/chaining.js
deleted file mode 100644
index 950aa70585..0000000000
--- a/examples/chaining.js
+++ /dev/null
@@ -1,54 +0,0 @@
-// chaining
-import { chain, format, index, pi } from 'mathjs'
-
-// create a chained operation using the function `chain(value)`
-// end a chain using done(). Let's calculate (3 + 4) * 2
-const a = chain(3)
- .add(4)
- .multiply(2)
- .done()
-print(a) // 14
-
-// Another example, calculate square(sin(pi / 4))
-const b = chain(pi)
- .divide(4)
- .sin()
- .square()
- .done()
-print(b) // 0.5
-
-// A chain has a few special methods: done, toString, valueOf, get, and set.
-// these are demonstrated in the following examples
-
-// toString will return a string representation of the chain's value
-const myChain = chain(2).divide(3)
-const str = myChain.toString()
-print(str) // "0.6666666666666666"
-
-// a chain has a function .valueOf(), which returns the value hold by the chain.
-// This allows using it in regular operations. The function valueOf() acts the
-// same as function done().
-print(myChain.valueOf()) // 0.66666666666667
-print(myChain + 2) // 2.6666666666667
-
-// the function subset can be used to get or replace sub matrices
-const array = [[1, 2], [3, 4]]
-const v = chain(array)
- .subset(index(1, 0))
- .done()
-print(v) // 3
-
-const m = chain(array)
- .subset(index(0, 0), 8)
- .multiply(3)
- .done()
-print(m) // [[24, 6], [9, 12]]
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
diff --git a/examples/chaining.js.md b/examples/chaining.js.md
deleted file mode 100644
index 82f9753bb5..0000000000
--- a/examples/chaining.js.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-layout: default
----
-
-# Chaining
-
-File: [chaining.js](chaining.js)
-
-```js
-// chaining
-import { chain, format, index, pi } from 'mathjs'
-
-// create a chained operation using the function `chain(value)`
-// end a chain using done(). Let's calculate (3 + 4) * 2
-const a = chain(3)
- .add(4)
- .multiply(2)
- .done()
-print(a) // 14
-
-// Another example, calculate square(sin(pi / 4))
-const b = chain(pi)
- .divide(4)
- .sin()
- .square()
- .done()
-print(b) // 0.5
-
-// A chain has a few special methods: done, toString, valueOf, get, and set.
-// these are demonstrated in the following examples
-
-// toString will return a string representation of the chain's value
-const myChain = chain(2).divide(3)
-const str = myChain.toString()
-print(str) // "0.6666666666666666"
-
-// a chain has a function .valueOf(), which returns the value hold by the chain.
-// This allows using it in regular operations. The function valueOf() acts the
-// same as function done().
-print(myChain.valueOf()) // 0.66666666666667
-print(myChain + 2) // 2.6666666666667
-
-// the function subset can be used to get or replace sub matrices
-const array = [[1, 2], [3, 4]]
-const v = chain(array)
- .subset(index(1, 0))
- .done()
-print(v) // 3
-
-const m = chain(array)
- .subset(index(0, 0), 8)
- .multiply(3)
- .done()
-print(m) // [[24, 6], [9, 12]]
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
-
-```
-
-
-
diff --git a/examples/code editor/README.md b/examples/code editor/README.md
deleted file mode 100644
index 9be41f658a..0000000000
--- a/examples/code editor/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Code Editor Example
-
-This is an example for using [mathjs](https://mathjs.org) with a code editor.
-
-To run your own you need to install the dependancies with.
-```
-npm install
-```
-
-You can start development mode with:
-```
-npm run dev
-```
-
-Or build the project with:
-```
-npm run build
-```
\ No newline at end of file
diff --git a/examples/code editor/getExpressions.js b/examples/code editor/getExpressions.js
deleted file mode 100644
index e61ed19d50..0000000000
--- a/examples/code editor/getExpressions.js
+++ /dev/null
@@ -1,59 +0,0 @@
-import { parse } from 'mathjs'
-
-/**
- * Extracts parsable expressions from a multiline string.
- *
- * @param {string} str - The multiline string containing expressions.
- * @returns {Array<{from: number, to: number, source: string}>} An array of objects,
- * where each object represents a parsable expression and contains:
- * - from: The starting line number of the expression within the original string.
- * - to: The ending line number of the expression within the original string.
- * - source: The actual string content of the expression.
- */
-export default function getExpressions(str) {
- const lines = str.split('\n');
- let nextLineToParse = 0;
- const result = [];
-
- for (let lineID = 0; lineID < lines.length; lineID++) {
- const linesToTest = lines.slice(nextLineToParse, lineID + 1).join('\n');
- if (canBeParsed(linesToTest)) {
- if (!isEmptyString(linesToTest)) {
- result.push({ from: nextLineToParse, to: lineID, source: linesToTest });
- }
- // Start the next parsing attempt from the line after the successfully parsed expression.
- nextLineToParse = lineID + 1;
- }
- }
- // Handle any remaining lines that couldn't be parsed as expressions.
- const linesToTest = lines.slice(nextLineToParse).join('\n');
- if (!isEmptyString(linesToTest)) {
- result.push({ from: nextLineToParse, to: lines.length - 1, source: linesToTest });
- }
- return result;
-}
-
-/**
- * Determines whether a given expression can be successfully parsed.
- *
- * @param {string} expression - The expression to parse.
- * @returns {boolean} True if the expression can be parsed, false otherwise.
- */
-function canBeParsed(expression) {
- try {
- parse(expression)
- return true
- } catch (error) {
- return false
- }
-}
-
-/**
- * Checks if a given string is empty or only contains whitespace characters.
- *
- * @param {string} str - The string to check.
- * @returns {boolean} True if the string is empty or only contains whitespace, false otherwise.
- */
-function isEmptyString(str) {
- return str.trim() === ""
-}
\ No newline at end of file
diff --git a/examples/code editor/index.html b/examples/code editor/index.html
deleted file mode 100644
index d8f86f276c..0000000000
--- a/examples/code editor/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-
-
-
-
- math.js | code editor
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/examples/code editor/main.js b/examples/code editor/main.js
deleted file mode 100644
index 3d8ece502a..0000000000
--- a/examples/code editor/main.js
+++ /dev/null
@@ -1,214 +0,0 @@
-import './style.css'
-import 'github-markdown-css/github-markdown.css'
-import 'katex/dist/katex.min.css'
-import { StreamLanguage } from '@codemirror/language'
-import { EditorState } from '@codemirror/state'
-import { basicSetup, EditorView } from 'codemirror'
-import katex from 'katex'
-import { all, create } from 'mathjs'
-import getExpressions from './getExpressions'
-import { mathjsLang } from './mathjs-lang.js'
-
-const timeout = 250 // milliseconds
-const digits = 14
-
-const math = create(all)
-const parser = math.parser()
-const editorDOM = document.querySelector('#editor')
-const resultsDOM = document.querySelector('#result')
-
-let processedExpressions
-let previousSelectedExpressionIndex
-let timer
-
-const doc = [
- "round(e, 3)",
- "atan2(3, -3) / pi",
- "log(10000, 10)",
- "sqrt(-4)",
- "derivative('x^2 + x', 'x')",
- "pow([[-1, 2], [3, 1]], 2)",
- "# expressions",
- "1.2 * (2 + 4.5)",
- "12.7 cm to inch",
- "sin(45 deg) ^ 2",
- "9 / 3 + 2i",
- "det([-1, 2; 3, 1])"
-].join('\n')
-
-let startState = EditorState.create({
- doc,
- extensions: [
- basicSetup,
- StreamLanguage.define(mathjsLang(math)),
- EditorView.lineWrapping,
- EditorView.updateListener.of((update) => {
- if (update.docChanged) {
- // if doc changed debounce and update results after a timeout
- clearTimeout(timer)
- timer = setTimeout(() => {
- updateResults()
- previousSelectedExpressionIndex = null
- updateSelection()
- }, timeout)
- } else if (update.selectionSet) {
- updateSelection()
- }
- })
- ],
-})
-
-let editor = new EditorView({
- state: startState,
- parent: editorDOM
-})
-
-/**
- * Evaluates a given expression using a parser.
- *
- * @param {string} expression - The expression to evaluate.
- * @returns {any} The result of the evaluation, or the error message if an error occurred.
-*/
-function calc(expression) {
- let result
- try {
- result = parser.evaluate(expression)
- } catch (error) {
- result = error.toString()
- }
- return result
-}
-
-/**
- * Formats result depending on the type of result
- *
- * @param {number, string, Help, any} result - The result to format
- * @returns {string} The string in HTML with the formated result
- */
-const formatResult = math.typed({
- 'number': result => math.format(result, { precision: digits }),
- 'string': result => `${result}`,
- 'Help': result => `
${math.format(result)}
`,
- 'any': math.typed.referTo(
- 'number',
- fnumber => result => katex.renderToString(math.parse(fnumber(result)).toTex())
- )
-})
-
-/**
- * Processes an array of expressions by evaluating them, formatting the results,
- * and determining their visibility.
- *
- * @param {Array<{from: number, to: number, source: string}>} expressions - An array of objects representing expressions,
- * where each object has `from`, `to`, and `source` properties.
- * @returns {Array<{from: number, to: number, source: string, outputs: any, visible: boolean}>} An array of processed expressions,
- * where each object has additional `outputs` and `visible` properties.
- */
-function processExpressions(expressions) {
- parser.clear()
- return expressions.map(expression => {
- const result = calc(expression.source)
- const outputs = formatResult(result)
- // Determine visibility based on the result type:
- // - Undefined results are hidden.
- // - Results with an `isResultSet` property are hidden when empty.
- // - All other results are visible.
- const visible = result === undefined ? false : (result.isResultSet && result.entries.length === 0) ? false : true
- return ({
- ...expression,
- outputs,
- visible
- })
- })
-}
-
-/**
- * Updates the displayed results based on the editor's current content.
- *
- * @function updateResults
- * @requires getExpressions, processExpressions, resultsToHTML
- *
- * @description
- * 1. Extracts expressions from the editor's content.
- * 2. Evaluates and analyzes the expressions.
- * 3. Generates HTML to display the processed results.
- * 4. Renders the generated HTML in the designated results container.
- */
-function updateResults() {
- // Extract expressions from the editor's content.
- const expressions = getExpressions(editor.state.doc.toString());
-
- // Evaluate and analyze the expressions.
- processedExpressions = processExpressions(expressions);
-
- // Generate HTML to display the results.
- const resultsHtml = resultsToHTML(processedExpressions);
-
- // Render the generated HTML in the results container.
- resultsDOM.innerHTML = resultsHtml;
-}
-
-/**
-* Updates the visual highlighting of results based on the current line selection in the editor.
-*
-* @function updateSelection
-* @requires editor, processedExpressions
-*
-* @description
-* 1. Determines the current line number in the editor's selection.
-* 2. Finds the corresponding result (processed expression) that matches the current line.
-* 3. If a different result is selected than before:
-* - Removes highlighting from the previously selected result.
-* - Highlights the newly selected result.
-* - Scrolls the newly selected result into view.
-*/
-function updateSelection() {
- const selectedLine = editor.state.doc.lineAt(
- editor.state.selection.ranges[editor.state.selection.mainIndex].from
- ).number - 1;
-
- let selectedExpressionIndex;
-
- processedExpressions.forEach((result, index) => {
- if ((selectedLine >= result.from) && (selectedLine <= result.to)) {
- selectedExpressionIndex = index;
- }
- });
-
- if (selectedExpressionIndex !== previousSelectedExpressionIndex) {
- const previouslyHighlightedResult = document.querySelector('#result').children[previousSelectedExpressionIndex];
- if (previouslyHighlightedResult !== undefined) {
- previouslyHighlightedResult.className = null;
- }
-
- const currentlySelectedResult = document.querySelector('#result').children[selectedExpressionIndex];
- if (currentlySelectedResult !== undefined) {
- currentlySelectedResult.className = 'highlighted';
- currentlySelectedResult.scrollIntoView({ block: 'nearest', inline: 'start' });
- }
-
- previousSelectedExpressionIndex = selectedExpressionIndex;
- }
-}
-
-/**
-* Converts an array of processed results into HTML elements for display.
-*
-* @function resultsToHTML
-* @param {Array<{from: number, to: number, source: string, outputs: any, visible: boolean}>} results - An array of processed results, where each object has:
-* - from: The starting line number of the expression.
-* - to: The ending line number of the expression.
-* - source: The original expression string.
-* - outputs: The formatted result of evaluating the expression.
-* - visible: A boolean indicating whether the result should be displayed or hidden.
-* @returns {string} A string of HTML elements representing the results, where each result is enclosed in a
tag with appropriate styling based on its visibility.
-*/
-function resultsToHTML(results) {
- return results.map(el => {
- const elementStyle = el.visible ? '' : 'style="display:none"'
- return `
${el.outputs}
`
- }
- ).join('')
-}
-
-updateResults()
diff --git a/examples/code editor/mathjs-lang.js b/examples/code editor/mathjs-lang.js
deleted file mode 100644
index 137086ea3b..0000000000
--- a/examples/code editor/mathjs-lang.js
+++ /dev/null
@@ -1,244 +0,0 @@
-/**
- * Create mathjs syntax highlighting for CodeMirror
- *
- * TODO: this is using CodeMirror v5 functionality, upgrade this to v6
- *
- * @param {Object} math A mathjs instance
- */
-export function mathjsLang(math) {
- function wordRegexp(words) {
- return new RegExp('^((' + words.join(')|(') + '))\\b')
- }
-
- const singleOperators = new RegExp("^[-+*/&|^~<>!%']")
- const singleDelimiters = new RegExp('^[([{},:=;.?]')
- const doubleOperators = new RegExp('^((==)|(!=)|(<=)|(>=)|(<<)|(>>)|(\\.[-+*/^]))')
- const doubleDelimiters = new RegExp('^((!=)|(^\\|))')
- const tripleDelimiters = new RegExp('^((>>>)|(<<<))')
- const expressionEnd = new RegExp('^[\\])]')
- const identifiers = new RegExp('^[_A-Za-z\xa1-\uffff][_A-Za-z0-9\xa1-\uffff]*')
-
- const mathFunctions = []
- const mathPhysicalConstants = []
- const mathIgnore = ['expr', 'type']
- const numberLiterals = [
- 'e',
- 'E',
- 'i',
- 'Infinity',
- 'LN2',
- 'LN10',
- 'LOG2E',
- 'LOG10E',
- 'NaN',
- 'null',
- 'phi',
- 'pi',
- 'PI',
- 'SQRT1_2',
- 'SQRT2',
- 'tau',
- 'undefined',
- 'version'
- ]
-
- // based on https://github.com/josdejong/mathjs/blob/develop/bin/cli.js
- for (const expr in math.expression.mathWithTransform) {
- if (!mathIgnore.includes(expr)) {
- if (typeof math[expr] === 'function') {
- mathFunctions.push(expr)
- } else if (!numberLiterals.includes(expr)) {
- mathPhysicalConstants.push(expr)
- }
- }
- }
-
- // generates a list of all valid units in mathjs
- const listOfUnits = []
- for (const unit in math.Unit.UNITS) {
- for (const prefix in math.Unit.UNITS[unit].prefixes) {
- listOfUnits.push(prefix + unit)
- }
- }
-
- const builtins = wordRegexp(mathFunctions)
-
- const keywords = wordRegexp(['to', 'in', 'and', 'not', 'or', 'xor', 'mod'])
-
- const units = wordRegexp(Array.from(new Set(listOfUnits)))
- const physicalConstants = wordRegexp(mathPhysicalConstants)
-
- // tokenizers
- function tokenTranspose(stream, state) {
- if (!stream.sol() && stream.peek() === "'") {
- stream.next()
- state.tokenize = tokenBase
- return 'operator'
- }
- state.tokenize = tokenBase
- return tokenBase(stream, state)
- }
-
- function tokenComment(stream, state) {
- if (stream.match(/^.*#}/)) {
- state.tokenize = tokenBase
- return 'comment'
- }
- stream.skipToEnd()
- return 'comment'
- }
-
- function tokenBase(stream, state) {
- // whitespaces
- if (stream.eatSpace()) return null
-
- // Handle one line Comments
- if (stream.match('#{')) {
- state.tokenize = tokenComment
- stream.skipToEnd()
- return 'comment'
- }
-
- if (stream.match(/^#/)) {
- stream.skipToEnd()
- return 'comment'
- }
-
- // Handle Number Literals
- if (stream.match(/^[0-9.+-]/, false)) {
- if (stream.match(/^[+-]?0x[0-9a-fA-F]+[ij]?/)) {
- stream.tokenize = tokenBase
- return 'number'
- }
- if (stream.match(/^[+-]?\d*\.\d+([EeDd][+-]?\d+)?[ij]?/)) {
- return 'number'
- }
- if (stream.match(/^[+-]?\d+([EeDd][+-]?\d+)?[ij]?/)) {
- return 'number'
- }
- }
- if (stream.match(wordRegexp(numberLiterals))) {
- return 'number'
- }
-
- // Handle Strings
- let m = stream.match(/^"(?:[^"]|"")*("|$)/) || stream.match(/^'(?:[^']|'')*('|$)/)
- if (m) {
- return m[1] ? 'string' : 'string error'
- }
-
- // Handle words
- if (stream.match(keywords)) {
- return 'keyword'
- }
- if (stream.match(builtins)) {
- return 'builtin'
- }
- if (stream.match(physicalConstants)) {
- return 'tag'
- }
- if (stream.match(units)) {
- return 'attribute'
- }
- if (stream.match(identifiers)) {
- return 'variable'
- }
- if (stream.match(singleOperators) || stream.match(doubleOperators)) {
- return 'operator'
- }
- if (
- stream.match(singleDelimiters) ||
- stream.match(doubleDelimiters) ||
- stream.match(tripleDelimiters)
- ) {
- return null
- }
- if (stream.match(expressionEnd)) {
- state.tokenize = tokenTranspose
- return null
- }
- // Handle non-detected items
- stream.next()
- return 'error'
- }
-
- return {
- name: 'mathjs',
-
- startState: function () {
- return {
- tokenize: tokenBase
- }
- },
-
- token: function (stream, state) {
- const style = state.tokenize(stream, state)
- if (style === 'number' || style === 'variable') {
- state.tokenize = tokenTranspose
- }
- return style
- },
-
- languageData: {
- commentTokens: { line: '#' },
- autocomplete: myCompletions
- }
- }
-
- function myCompletions(context) {
- let word = context.matchBefore(/\w*/)
- if (word.from == word.to && !context.explicit) return null
- let options = []
- mathFunctions.forEach((func) => options.push({ label: func, type: 'function' }))
-
- mathPhysicalConstants.forEach((constant) => options.push({ label: constant, type: 'constant' }))
-
- numberLiterals.forEach((number) => options.push({ label: number, type: 'variable' }))
-
- // units as enum
- for (const name in math.Unit.UNITS) {
- if (hasOwnPropertySafe(math.Unit.UNITS, name)) {
- if (name.startsWith(word.text)) {
- options.push({ label: name, type: 'enum' })
- }
- }
- }
- for (const name in math.Unit.PREFIXES) {
- if (hasOwnPropertySafe(math.Unit.PREFIXES, name)) {
- const prefixes = math.Unit.PREFIXES[name]
- for (const prefix in prefixes) {
- if (hasOwnPropertySafe(prefixes, prefix)) {
- if (prefix.startsWith(word.text)) {
- options.push({ label: prefix, type: 'enum' })
- } else if (word.text.startsWith(prefix)) {
- const unitKeyword = word.text.substring(prefix.length)
- for (const n in math.Unit.UNITS) {
- const fullUnit = prefix + n
- if (hasOwnPropertySafe(math.Unit.UNITS, n)) {
- if (
- !options.includes(fullUnit) &&
- n.startsWith(unitKeyword) &&
- math.Unit.isValuelessUnit(fullUnit)
- ) {
- options.push({ label: fullUnit, type: 'enum' })
- }
- }
- }
- }
- }
- }
- }
- }
-
- return {
- from: word.from,
- options
- }
- }
-}
-
-// helper function to safely check whether an object has a property
-// copy from the function in object.js which is ES6
-function hasOwnPropertySafe(object, property) {
- return object && Object.hasOwnProperty.call(object, property)
-}
\ No newline at end of file
diff --git a/examples/code editor/package-lock.json b/examples/code editor/package-lock.json
deleted file mode 100644
index b6614b9b2d..0000000000
--- a/examples/code editor/package-lock.json
+++ /dev/null
@@ -1,1120 +0,0 @@
-{
- "name": "code-editor",
- "version": "1.0.0",
- "lockfileVersion": 3,
- "requires": true,
- "packages": {
- "": {
- "name": "code-editor",
- "version": "1.0.0",
- "dependencies": {
- "@codemirror/language": "6.10.2",
- "@codemirror/state": "6.4.1",
- "codemirror": "6.0.1",
- "github-markdown-css": "5.6.1",
- "katex": "0.16.11",
- "mathjs": "13.0.2"
- },
- "devDependencies": {
- "vite": "5.3.3"
- }
- },
- "node_modules/@babel/runtime": {
- "version": "7.24.7",
- "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.24.7.tgz",
- "integrity": "sha512-UwgBRMjJP+xv857DCngvqXI3Iq6J4v0wXmwc6sapg+zyhbwmQX67LUEFrkK5tbyJ30jGuG3ZvWpBiB9LCy1kWw==",
- "license": "MIT",
- "dependencies": {
- "regenerator-runtime": "^0.14.0"
- },
- "engines": {
- "node": ">=6.9.0"
- }
- },
- "node_modules/@codemirror/autocomplete": {
- "version": "6.10.2",
- "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.10.2.tgz",
- "integrity": "sha512-3dCL7b0j2GdtZzWN5j7HDpRAJ26ip07R4NGYz7QYthIYMiX8I4E4TNrYcdTayPJGeVQtd/xe7lWU4XL7THFb/w==",
- "dependencies": {
- "@codemirror/language": "^6.0.0",
- "@codemirror/state": "^6.0.0",
- "@codemirror/view": "^6.17.0",
- "@lezer/common": "^1.0.0"
- },
- "peerDependencies": {
- "@codemirror/language": "^6.0.0",
- "@codemirror/state": "^6.0.0",
- "@codemirror/view": "^6.0.0",
- "@lezer/common": "^1.0.0"
- }
- },
- "node_modules/@codemirror/commands": {
- "version": "6.3.0",
- "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.3.0.tgz",
- "integrity": "sha512-tFfcxRIlOWiQDFhjBSWJ10MxcvbCIsRr6V64SgrcaY0MwNk32cUOcCuNlWo8VjV4qRQCgNgUAnIeo0svkk4R5Q==",
- "dependencies": {
- "@codemirror/language": "^6.0.0",
- "@codemirror/state": "^6.2.0",
- "@codemirror/view": "^6.0.0",
- "@lezer/common": "^1.1.0"
- }
- },
- "node_modules/@codemirror/language": {
- "version": "6.10.2",
- "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.10.2.tgz",
- "integrity": "sha512-kgbTYTo0Au6dCSc/TFy7fK3fpJmgHDv1sG1KNQKJXVi+xBTEeBPY/M30YXiU6mMXeH+YIDLsbrT4ZwNRdtF+SA==",
- "license": "MIT",
- "dependencies": {
- "@codemirror/state": "^6.0.0",
- "@codemirror/view": "^6.23.0",
- "@lezer/common": "^1.1.0",
- "@lezer/highlight": "^1.0.0",
- "@lezer/lr": "^1.0.0",
- "style-mod": "^4.0.0"
- }
- },
- "node_modules/@codemirror/lint": {
- "version": "6.4.2",
- "resolved": "https://registry.npmjs.org/@codemirror/lint/-/lint-6.4.2.tgz",
- "integrity": "sha512-wzRkluWb1ptPKdzlsrbwwjYCPLgzU6N88YBAmlZi8WFyuiEduSd05MnJYNogzyc8rPK7pj6m95ptUApc8sHKVA==",
- "dependencies": {
- "@codemirror/state": "^6.0.0",
- "@codemirror/view": "^6.0.0",
- "crelt": "^1.0.5"
- }
- },
- "node_modules/@codemirror/search": {
- "version": "6.5.4",
- "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.5.4.tgz",
- "integrity": "sha512-YoTrvjv9e8EbPs58opjZKyJ3ewFrVSUzQ/4WXlULQLSDDr1nGPJ67mMXFNNVYwdFhybzhrzrtqgHmtpJwIF+8g==",
- "dependencies": {
- "@codemirror/state": "^6.0.0",
- "@codemirror/view": "^6.0.0",
- "crelt": "^1.0.5"
- }
- },
- "node_modules/@codemirror/state": {
- "version": "6.4.1",
- "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.4.1.tgz",
- "integrity": "sha512-QkEyUiLhsJoZkbumGZlswmAhA7CBU02Wrz7zvH4SrcifbsqwlXShVXg65f3v/ts57W3dqyamEriMhij1Z3Zz4A==",
- "license": "MIT"
- },
- "node_modules/@codemirror/view": {
- "version": "6.23.0",
- "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.23.0.tgz",
- "integrity": "sha512-/51px9N4uW8NpuWkyUX+iam5+PM6io2fm+QmRnzwqBy5v/pwGg9T0kILFtYeum8hjuvENtgsGNKluOfqIICmeQ==",
- "dependencies": {
- "@codemirror/state": "^6.4.0",
- "style-mod": "^4.1.0",
- "w3c-keyname": "^2.2.4"
- }
- },
- "node_modules/@esbuild/aix-ppc64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
- "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
- "cpu": [
- "ppc64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "aix"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/android-arm": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
- "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
- "cpu": [
- "arm"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/android-arm64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
- "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/android-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
- "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/darwin-arm64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
- "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/darwin-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
- "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/freebsd-arm64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
- "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "freebsd"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/freebsd-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
- "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "freebsd"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-arm": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
- "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
- "cpu": [
- "arm"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-arm64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
- "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-ia32": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
- "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
- "cpu": [
- "ia32"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-loong64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
- "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
- "cpu": [
- "loong64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-mips64el": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
- "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
- "cpu": [
- "mips64el"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-ppc64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
- "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
- "cpu": [
- "ppc64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-riscv64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
- "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
- "cpu": [
- "riscv64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-s390x": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
- "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
- "cpu": [
- "s390x"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/linux-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
- "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/netbsd-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
- "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "netbsd"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/openbsd-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
- "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "openbsd"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/sunos-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
- "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "sunos"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/win32-arm64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
- "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/win32-ia32": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
- "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
- "cpu": [
- "ia32"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@esbuild/win32-x64": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
- "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ],
- "engines": {
- "node": ">=12"
- }
- },
- "node_modules/@lezer/common": {
- "version": "1.1.0",
- "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.1.0.tgz",
- "integrity": "sha512-XPIN3cYDXsoJI/oDWoR2tD++juVrhgIago9xyKhZ7IhGlzdDM9QgC8D8saKNCz5pindGcznFr2HBSsEQSWnSjw=="
- },
- "node_modules/@lezer/highlight": {
- "version": "1.1.6",
- "resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.1.6.tgz",
- "integrity": "sha512-cmSJYa2us+r3SePpRCjN5ymCqCPv+zyXmDl0ciWtVaNiORT/MxM7ZgOMQZADD0o51qOaOg24qc/zBViOIwAjJg==",
- "dependencies": {
- "@lezer/common": "^1.0.0"
- }
- },
- "node_modules/@lezer/lr": {
- "version": "1.3.13",
- "resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.3.13.tgz",
- "integrity": "sha512-RLAbau/4uSzKgIKj96mI5WUtG1qtiR0Frn0Ei9zhPj8YOkHM+1Bb8SgdVvmR/aWJCFIzjo2KFnDiRZ75Xf5NdQ==",
- "dependencies": {
- "@lezer/common": "^1.0.0"
- }
- },
- "node_modules/@rollup/rollup-android-arm-eabi": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.18.0.tgz",
- "integrity": "sha512-Tya6xypR10giZV1XzxmH5wr25VcZSncG0pZIjfePT0OVBvqNEurzValetGNarVrGiq66EBVAFn15iYX4w6FKgQ==",
- "cpu": [
- "arm"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ]
- },
- "node_modules/@rollup/rollup-android-arm64": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.18.0.tgz",
- "integrity": "sha512-avCea0RAP03lTsDhEyfy+hpfr85KfyTctMADqHVhLAF3MlIkq83CP8UfAHUssgXTYd+6er6PaAhx/QGv4L1EiA==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ]
- },
- "node_modules/@rollup/rollup-darwin-arm64": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.18.0.tgz",
- "integrity": "sha512-IWfdwU7KDSm07Ty0PuA/W2JYoZ4iTj3TUQjkVsO/6U+4I1jN5lcR71ZEvRh52sDOERdnNhhHU57UITXz5jC1/w==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ]
- },
- "node_modules/@rollup/rollup-darwin-x64": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.18.0.tgz",
- "integrity": "sha512-n2LMsUz7Ynu7DoQrSQkBf8iNrjOGyPLrdSg802vk6XT3FtsgX6JbE8IHRvposskFm9SNxzkLYGSq9QdpLYpRNA==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ]
- },
- "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.18.0.tgz",
- "integrity": "sha512-C/zbRYRXFjWvz9Z4haRxcTdnkPt1BtCkz+7RtBSuNmKzMzp3ZxdM28Mpccn6pt28/UWUCTXa+b0Mx1k3g6NOMA==",
- "cpu": [
- "arm"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-arm-musleabihf": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.18.0.tgz",
- "integrity": "sha512-l3m9ewPgjQSXrUMHg93vt0hYCGnrMOcUpTz6FLtbwljo2HluS4zTXFy2571YQbisTnfTKPZ01u/ukJdQTLGh9A==",
- "cpu": [
- "arm"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-arm64-gnu": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.18.0.tgz",
- "integrity": "sha512-rJ5D47d8WD7J+7STKdCUAgmQk49xuFrRi9pZkWoRD1UeSMakbcepWXPF8ycChBoAqs1pb2wzvbY6Q33WmN2ftw==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-arm64-musl": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.18.0.tgz",
- "integrity": "sha512-be6Yx37b24ZwxQ+wOQXXLZqpq4jTckJhtGlWGZs68TgdKXJgw54lUUoFYrg6Zs/kjzAQwEwYbp8JxZVzZLRepQ==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.18.0.tgz",
- "integrity": "sha512-hNVMQK+qrA9Todu9+wqrXOHxFiD5YmdEi3paj6vP02Kx1hjd2LLYR2eaN7DsEshg09+9uzWi2W18MJDlG0cxJA==",
- "cpu": [
- "ppc64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-riscv64-gnu": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.18.0.tgz",
- "integrity": "sha512-ROCM7i+m1NfdrsmvwSzoxp9HFtmKGHEqu5NNDiZWQtXLA8S5HBCkVvKAxJ8U+CVctHwV2Gb5VUaK7UAkzhDjlg==",
- "cpu": [
- "riscv64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-s390x-gnu": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.18.0.tgz",
- "integrity": "sha512-0UyyRHyDN42QL+NbqevXIIUnKA47A+45WyasO+y2bGJ1mhQrfrtXUpTxCOrfxCR4esV3/RLYyucGVPiUsO8xjg==",
- "cpu": [
- "s390x"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-x64-gnu": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.18.0.tgz",
- "integrity": "sha512-xuglR2rBVHA5UsI8h8UbX4VJ470PtGCf5Vpswh7p2ukaqBGFTnsfzxUBetoWBWymHMxbIG0Cmx7Y9qDZzr648w==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-linux-x64-musl": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.18.0.tgz",
- "integrity": "sha512-LKaqQL9osY/ir2geuLVvRRs+utWUNilzdE90TpyoX0eNqPzWjRm14oMEE+YLve4k/NAqCdPkGYDaDF5Sw+xBfg==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ]
- },
- "node_modules/@rollup/rollup-win32-arm64-msvc": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.18.0.tgz",
- "integrity": "sha512-7J6TkZQFGo9qBKH0pk2cEVSRhJbL6MtfWxth7Y5YmZs57Pi+4x6c2dStAUvaQkHQLnEQv1jzBUW43GvZW8OFqA==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ]
- },
- "node_modules/@rollup/rollup-win32-ia32-msvc": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.18.0.tgz",
- "integrity": "sha512-Txjh+IxBPbkUB9+SXZMpv+b/vnTEtFyfWZgJ6iyCmt2tdx0OF5WhFowLmnh8ENGNpfUlUZkdI//4IEmhwPieNg==",
- "cpu": [
- "ia32"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ]
- },
- "node_modules/@rollup/rollup-win32-x64-msvc": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.18.0.tgz",
- "integrity": "sha512-UOo5FdvOL0+eIVTgS4tIdbW+TtnBLWg1YBCcU2KWM7nuNwRz9bksDX1bekJJCpu25N1DVWaCwnT39dVQxzqS8g==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ]
- },
- "node_modules/@types/estree": {
- "version": "1.0.5",
- "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
- "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
- "dev": true,
- "license": "MIT"
- },
- "node_modules/codemirror": {
- "version": "6.0.1",
- "resolved": "https://registry.npmjs.org/codemirror/-/codemirror-6.0.1.tgz",
- "integrity": "sha512-J8j+nZ+CdWmIeFIGXEFbFPtpiYacFMDR8GlHK3IyHQJMCaVRfGx9NT+Hxivv1ckLWPvNdZqndbr/7lVhrf/Svg==",
- "dependencies": {
- "@codemirror/autocomplete": "^6.0.0",
- "@codemirror/commands": "^6.0.0",
- "@codemirror/language": "^6.0.0",
- "@codemirror/lint": "^6.0.0",
- "@codemirror/search": "^6.0.0",
- "@codemirror/state": "^6.0.0",
- "@codemirror/view": "^6.0.0"
- }
- },
- "node_modules/commander": {
- "version": "8.3.0",
- "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
- "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
- "engines": {
- "node": ">= 12"
- }
- },
- "node_modules/complex.js": {
- "version": "2.1.1",
- "resolved": "https://registry.npmjs.org/complex.js/-/complex.js-2.1.1.tgz",
- "integrity": "sha512-8njCHOTtFFLtegk6zQo0kkVX1rngygb/KQI6z1qZxlFI3scluC+LVTCFbrkWjBv4vvLlbQ9t88IPMC6k95VTTg==",
- "engines": {
- "node": "*"
- },
- "funding": {
- "type": "patreon",
- "url": "https://www.patreon.com/infusion"
- }
- },
- "node_modules/crelt": {
- "version": "1.0.6",
- "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.6.tgz",
- "integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g=="
- },
- "node_modules/decimal.js": {
- "version": "10.4.3",
- "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.4.3.tgz",
- "integrity": "sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA=="
- },
- "node_modules/esbuild": {
- "version": "0.21.5",
- "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
- "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
- "dev": true,
- "hasInstallScript": true,
- "license": "MIT",
- "bin": {
- "esbuild": "bin/esbuild"
- },
- "engines": {
- "node": ">=12"
- },
- "optionalDependencies": {
- "@esbuild/aix-ppc64": "0.21.5",
- "@esbuild/android-arm": "0.21.5",
- "@esbuild/android-arm64": "0.21.5",
- "@esbuild/android-x64": "0.21.5",
- "@esbuild/darwin-arm64": "0.21.5",
- "@esbuild/darwin-x64": "0.21.5",
- "@esbuild/freebsd-arm64": "0.21.5",
- "@esbuild/freebsd-x64": "0.21.5",
- "@esbuild/linux-arm": "0.21.5",
- "@esbuild/linux-arm64": "0.21.5",
- "@esbuild/linux-ia32": "0.21.5",
- "@esbuild/linux-loong64": "0.21.5",
- "@esbuild/linux-mips64el": "0.21.5",
- "@esbuild/linux-ppc64": "0.21.5",
- "@esbuild/linux-riscv64": "0.21.5",
- "@esbuild/linux-s390x": "0.21.5",
- "@esbuild/linux-x64": "0.21.5",
- "@esbuild/netbsd-x64": "0.21.5",
- "@esbuild/openbsd-x64": "0.21.5",
- "@esbuild/sunos-x64": "0.21.5",
- "@esbuild/win32-arm64": "0.21.5",
- "@esbuild/win32-ia32": "0.21.5",
- "@esbuild/win32-x64": "0.21.5"
- }
- },
- "node_modules/escape-latex": {
- "version": "1.2.0",
- "resolved": "https://registry.npmjs.org/escape-latex/-/escape-latex-1.2.0.tgz",
- "integrity": "sha512-nV5aVWW1K0wEiUIEdZ4erkGGH8mDxGyxSeqPzRNtWP7ataw+/olFObw7hujFWlVjNsaDFw5VZ5NzVSIqRgfTiw=="
- },
- "node_modules/fraction.js": {
- "version": "4.3.7",
- "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz",
- "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==",
- "license": "MIT",
- "engines": {
- "node": "*"
- },
- "funding": {
- "type": "patreon",
- "url": "https://github.com/sponsors/rawify"
- }
- },
- "node_modules/fsevents": {
- "version": "2.3.3",
- "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
- "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
- "dev": true,
- "hasInstallScript": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ],
- "engines": {
- "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
- }
- },
- "node_modules/github-markdown-css": {
- "version": "5.6.1",
- "resolved": "https://registry.npmjs.org/github-markdown-css/-/github-markdown-css-5.6.1.tgz",
- "integrity": "sha512-DItLFgHd+s7HQmk63YN4/TdvLeRqk1QP7pPKTTPrDTYoI5x7f/luJWSOZxesmuxBI2srHp8RDyoZd+9WF+WK8Q==",
- "license": "MIT",
- "engines": {
- "node": ">=10"
- },
- "funding": {
- "url": "https://github.com/sponsors/sindresorhus"
- }
- },
- "node_modules/javascript-natural-sort": {
- "version": "0.7.1",
- "resolved": "https://registry.npmjs.org/javascript-natural-sort/-/javascript-natural-sort-0.7.1.tgz",
- "integrity": "sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw=="
- },
- "node_modules/katex": {
- "version": "0.16.11",
- "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.11.tgz",
- "integrity": "sha512-RQrI8rlHY92OLf3rho/Ts8i/XvjgguEjOkO1BEXcU3N8BqPpSzBNwV/G0Ukr+P/l3ivvJUE/Fa/CwbS6HesGNQ==",
- "funding": [
- "https://opencollective.com/katex",
- "https://github.com/sponsors/katex"
- ],
- "license": "MIT",
- "dependencies": {
- "commander": "^8.3.0"
- },
- "bin": {
- "katex": "cli.js"
- }
- },
- "node_modules/mathjs": {
- "version": "13.0.2",
- "resolved": "https://registry.npmjs.org/mathjs/-/mathjs-13.0.2.tgz",
- "integrity": "sha512-8vK/+InU4FTphRTWsrnvRsgSjbyNupRQYDDIXLuEGDZtJsGdbA9dVV4HZ0amBQb+RXplRjVJNGZZfB0WoHWFWA==",
- "license": "Apache-2.0",
- "dependencies": {
- "@babel/runtime": "^7.24.7",
- "complex.js": "^2.1.1",
- "decimal.js": "^10.4.3",
- "escape-latex": "^1.2.0",
- "fraction.js": "^4.3.7",
- "javascript-natural-sort": "^0.7.1",
- "seedrandom": "^3.0.5",
- "tiny-emitter": "^2.1.0",
- "typed-function": "^4.2.1"
- },
- "bin": {
- "mathjs": "bin/cli.js"
- },
- "engines": {
- "node": ">= 18"
- }
- },
- "node_modules/nanoid": {
- "version": "3.3.7",
- "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz",
- "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==",
- "dev": true,
- "funding": [
- {
- "type": "github",
- "url": "https://github.com/sponsors/ai"
- }
- ],
- "license": "MIT",
- "bin": {
- "nanoid": "bin/nanoid.cjs"
- },
- "engines": {
- "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
- }
- },
- "node_modules/picocolors": {
- "version": "1.0.1",
- "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.1.tgz",
- "integrity": "sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==",
- "dev": true,
- "license": "ISC"
- },
- "node_modules/postcss": {
- "version": "8.4.39",
- "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.39.tgz",
- "integrity": "sha512-0vzE+lAiG7hZl1/9I8yzKLx3aR9Xbof3fBHKunvMfOCYAtMhrsnccJY2iTURb9EZd5+pLuiNV9/c/GZJOHsgIw==",
- "dev": true,
- "funding": [
- {
- "type": "opencollective",
- "url": "https://opencollective.com/postcss/"
- },
- {
- "type": "tidelift",
- "url": "https://tidelift.com/funding/github/npm/postcss"
- },
- {
- "type": "github",
- "url": "https://github.com/sponsors/ai"
- }
- ],
- "license": "MIT",
- "dependencies": {
- "nanoid": "^3.3.7",
- "picocolors": "^1.0.1",
- "source-map-js": "^1.2.0"
- },
- "engines": {
- "node": "^10 || ^12 || >=14"
- }
- },
- "node_modules/regenerator-runtime": {
- "version": "0.14.1",
- "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
- "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
- "license": "MIT"
- },
- "node_modules/rollup": {
- "version": "4.18.0",
- "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.18.0.tgz",
- "integrity": "sha512-QmJz14PX3rzbJCN1SG4Xe/bAAX2a6NpCP8ab2vfu2GiUr8AQcr2nCV/oEO3yneFarB67zk8ShlIyWb2LGTb3Sg==",
- "dev": true,
- "license": "MIT",
- "dependencies": {
- "@types/estree": "1.0.5"
- },
- "bin": {
- "rollup": "dist/bin/rollup"
- },
- "engines": {
- "node": ">=18.0.0",
- "npm": ">=8.0.0"
- },
- "optionalDependencies": {
- "@rollup/rollup-android-arm-eabi": "4.18.0",
- "@rollup/rollup-android-arm64": "4.18.0",
- "@rollup/rollup-darwin-arm64": "4.18.0",
- "@rollup/rollup-darwin-x64": "4.18.0",
- "@rollup/rollup-linux-arm-gnueabihf": "4.18.0",
- "@rollup/rollup-linux-arm-musleabihf": "4.18.0",
- "@rollup/rollup-linux-arm64-gnu": "4.18.0",
- "@rollup/rollup-linux-arm64-musl": "4.18.0",
- "@rollup/rollup-linux-powerpc64le-gnu": "4.18.0",
- "@rollup/rollup-linux-riscv64-gnu": "4.18.0",
- "@rollup/rollup-linux-s390x-gnu": "4.18.0",
- "@rollup/rollup-linux-x64-gnu": "4.18.0",
- "@rollup/rollup-linux-x64-musl": "4.18.0",
- "@rollup/rollup-win32-arm64-msvc": "4.18.0",
- "@rollup/rollup-win32-ia32-msvc": "4.18.0",
- "@rollup/rollup-win32-x64-msvc": "4.18.0",
- "fsevents": "~2.3.2"
- }
- },
- "node_modules/seedrandom": {
- "version": "3.0.5",
- "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
- "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg=="
- },
- "node_modules/source-map-js": {
- "version": "1.2.0",
- "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.0.tgz",
- "integrity": "sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==",
- "dev": true,
- "license": "BSD-3-Clause",
- "engines": {
- "node": ">=0.10.0"
- }
- },
- "node_modules/style-mod": {
- "version": "4.1.0",
- "resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.1.0.tgz",
- "integrity": "sha512-Ca5ib8HrFn+f+0n4N4ScTIA9iTOQ7MaGS1ylHcoVqW9J7w2w8PzN6g9gKmTYgGEBH8e120+RCmhpje6jC5uGWA=="
- },
- "node_modules/tiny-emitter": {
- "version": "2.1.0",
- "resolved": "https://registry.npmjs.org/tiny-emitter/-/tiny-emitter-2.1.0.tgz",
- "integrity": "sha512-NB6Dk1A9xgQPMoGqC5CVXn123gWyte215ONT5Pp5a0yt4nlEoO1ZWeCwpncaekPHXO60i47ihFnZPiRPjRMq4Q=="
- },
- "node_modules/typed-function": {
- "version": "4.2.1",
- "resolved": "https://registry.npmjs.org/typed-function/-/typed-function-4.2.1.tgz",
- "integrity": "sha512-EGjWssW7Tsk4DGfE+5yluuljS1OGYWiI1J6e8puZz9nTMM51Oug8CD5Zo4gWMsOhq5BI+1bF+rWTm4Vbj3ivRA==",
- "license": "MIT",
- "engines": {
- "node": ">= 18"
- }
- },
- "node_modules/vite": {
- "version": "5.3.3",
- "resolved": "https://registry.npmjs.org/vite/-/vite-5.3.3.tgz",
- "integrity": "sha512-NPQdeCU0Dv2z5fu+ULotpuq5yfCS1BzKUIPhNbP3YBfAMGJXbt2nS+sbTFu+qchaqWTD+H3JK++nRwr6XIcp6A==",
- "dev": true,
- "license": "MIT",
- "dependencies": {
- "esbuild": "^0.21.3",
- "postcss": "^8.4.39",
- "rollup": "^4.13.0"
- },
- "bin": {
- "vite": "bin/vite.js"
- },
- "engines": {
- "node": "^18.0.0 || >=20.0.0"
- },
- "funding": {
- "url": "https://github.com/vitejs/vite?sponsor=1"
- },
- "optionalDependencies": {
- "fsevents": "~2.3.3"
- },
- "peerDependencies": {
- "@types/node": "^18.0.0 || >=20.0.0",
- "less": "*",
- "lightningcss": "^1.21.0",
- "sass": "*",
- "stylus": "*",
- "sugarss": "*",
- "terser": "^5.4.0"
- },
- "peerDependenciesMeta": {
- "@types/node": {
- "optional": true
- },
- "less": {
- "optional": true
- },
- "lightningcss": {
- "optional": true
- },
- "sass": {
- "optional": true
- },
- "stylus": {
- "optional": true
- },
- "sugarss": {
- "optional": true
- },
- "terser": {
- "optional": true
- }
- }
- },
- "node_modules/w3c-keyname": {
- "version": "2.2.8",
- "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
- "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ=="
- }
- }
-}
diff --git a/examples/code editor/package.json b/examples/code editor/package.json
deleted file mode 100644
index 6a732ec62d..0000000000
--- a/examples/code editor/package.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "name": "code-editor",
- "private": true,
- "version": "1.0.0",
- "type": "module",
- "scripts": {
- "dev": "vite",
- "build": "vite build",
- "preview": "vite preview"
- },
- "devDependencies": {
- "vite": "5.3.3"
- },
- "dependencies": {
- "@codemirror/language": "6.10.2",
- "@codemirror/state": "6.4.1",
- "codemirror": "6.0.1",
- "github-markdown-css": "5.6.1",
- "katex": "0.16.11",
- "mathjs": "13.0.2"
- }
-}
diff --git a/examples/code editor/style.css b/examples/code editor/style.css
deleted file mode 100644
index bc4a5d2dbf..0000000000
--- a/examples/code editor/style.css
+++ /dev/null
@@ -1,60 +0,0 @@
-html,
-body {
- margin: 0;
- padding: 0;
- height: 100vh;
- overflow: hidden;
-}
-
-body {
- display: flex;
- flex-direction: column;
-}
-
-#app {
- display: flex;
- overflow: hidden;
- flex: 1;
- flex-direction: row;
-}
-
-#editor {
- flex: 1;
- height: auto;
- display: flex;
- overflow: auto;
-}
-
-#editor>.cm-editor {
- flex: 1;
- overflow: scroll;
-}
-
-#app>article {
- flex: 1;
- overflow: auto;
- box-sizing: border-box;
-}
-
-article.markdown-body .results {
- padding: 0.5em;
- margin: 0.5em;
-}
-
-article.markdown-body > .highlighted {
- background-color: rgba(0, 150, 255, 0.2);
-}
-
-article.markdown-body {
- box-sizing: border-box;
- min-width: 200px;
- max-width: 980px;
- margin: 0 auto;
- padding: 1em;
-}
-
-@media (max-width: 767px) {
- .markdown-body {
- padding: 15px;
- }
-}
\ No newline at end of file
diff --git a/examples/complex_numbers.js b/examples/complex_numbers.js
deleted file mode 100644
index 0d44041548..0000000000
--- a/examples/complex_numbers.js
+++ /dev/null
@@ -1,65 +0,0 @@
-// complex numbers
-import { complex, add, multiply, sin, sqrt, pi, equal, sort, format } from 'mathjs'
-
-// create a complex number with a numeric real and complex part
-console.log('create and manipulate complex numbers')
-const a = complex(2, 3)
-print(a) // 2 + 3i
-
-// read the real and complex parts of the complex number
-print(a.re) // 2
-print(a.im) // 3
-
-// clone a complex value
-const clone = a.clone()
-print(clone) // 2 + 3i
-
-// adjust the complex value
-a.re = 5
-print(a) // 5 + 3i
-
-// create a complex number by providing a string with real and complex parts
-const b = complex('3-7i')
-print(b) // 3 - 7i
-console.log()
-
-// perform operations with complex numbers
-console.log('perform operations')
-print(add(a, b)) // 8 - 4i
-print(multiply(a, b)) // 36 - 26i
-print(sin(a)) // -9.6541254768548 + 2.8416922956064i
-
-// some operations will return a complex number depending on the arguments
-print(sqrt(4)) // 2
-print(sqrt(-4)) // 2i
-console.log()
-
-// create a complex number from polar coordinates
-console.log('create complex numbers with polar coordinates')
-const c = complex({ r: sqrt(2), phi: pi / 4 })
-print(c) // 1 + i
-
-// get polar coordinates of a complex number
-const d = complex(3, 4)
-console.log(d.abs(), d.arg()) // radius = 5, phi = 0.9272952180016122
-console.log()
-
-// comparision operations
-// note that there is no mathematical ordering defined for complex numbers
-// we can only check equality. To sort a list with complex numbers,
-// the natural sorting can be used
-console.log('\ncomparision and sorting operations')
-console.log('equal', equal(a, b)) // returns false
-const values = [a, b, c]
-console.log('values:', format(values, 14)) // [5 + 3i, 3 - 7i, 1 + i]
-sort(values, 'natural')
-console.log('sorted:', format(values, 14)) // [1 + i, 3 - 7i, 5 + 3i]
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
diff --git a/examples/complex_numbers.js.md b/examples/complex_numbers.js.md
deleted file mode 100644
index df7de481ae..0000000000
--- a/examples/complex_numbers.js.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-layout: default
----
-
-# Complex numbers
-
-File: [complex_numbers.js](complex_numbers.js)
-
-```js
-// complex numbers
-import { complex, add, multiply, sin, sqrt, pi, equal, sort, format } from 'mathjs'
-
-// create a complex number with a numeric real and complex part
-console.log('create and manipulate complex numbers')
-const a = complex(2, 3)
-print(a) // 2 + 3i
-
-// read the real and complex parts of the complex number
-print(a.re) // 2
-print(a.im) // 3
-
-// clone a complex value
-const clone = a.clone()
-print(clone) // 2 + 3i
-
-// adjust the complex value
-a.re = 5
-print(a) // 5 + 3i
-
-// create a complex number by providing a string with real and complex parts
-const b = complex('3-7i')
-print(b) // 3 - 7i
-console.log()
-
-// perform operations with complex numbers
-console.log('perform operations')
-print(add(a, b)) // 8 - 4i
-print(multiply(a, b)) // 36 - 26i
-print(sin(a)) // -9.6541254768548 + 2.8416922956064i
-
-// some operations will return a complex number depending on the arguments
-print(sqrt(4)) // 2
-print(sqrt(-4)) // 2i
-console.log()
-
-// create a complex number from polar coordinates
-console.log('create complex numbers with polar coordinates')
-const c = complex({ r: sqrt(2), phi: pi / 4 })
-print(c) // 1 + i
-
-// get polar coordinates of a complex number
-const d = complex(3, 4)
-console.log(d.abs(), d.arg()) // radius = 5, phi = 0.9272952180016122
-console.log()
-
-// comparision operations
-// note that there is no mathematical ordering defined for complex numbers
-// we can only check equality. To sort a list with complex numbers,
-// the natural sorting can be used
-console.log('\ncomparision and sorting operations')
-console.log('equal', equal(a, b)) // returns false
-const values = [a, b, c]
-console.log('values:', format(values, 14)) // [5 + 3i, 3 - 7i, 1 + i]
-sort(values, 'natural')
-console.log('sorted:', format(values, 14)) // [1 + i, 3 - 7i, 5 + 3i]
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
-
-```
-
-
-
diff --git a/examples/expressions.js b/examples/expressions.js
deleted file mode 100644
index 68067d4281..0000000000
--- a/examples/expressions.js
+++ /dev/null
@@ -1,186 +0,0 @@
-/**
- * Expressions can be evaluated in various ways:
- *
- * 1. using the function evaluate
- * 2. using the function parse
- * 3. using a parser. A parser contains functions evaluate and parse,
- * and keeps a scope with assigned variables in memory
- */
-import { compile, evaluate, format, parse, parser } from 'mathjs'
-
-// 1. using the function evaluate
-//
-// Function `evaluate` accepts a single expression or an array with
-// expressions as first argument, and has an optional second argument
-// containing a scope with variables and functions. The scope is a regular
-// JavaScript Object. The scope will be used to resolve symbols, and to write
-// assigned variables or function.
-console.log('1. USING FUNCTION MATH.EVAL')
-
-// evaluate expressions
-console.log('\nevaluate expressions')
-print(evaluate('sqrt(3^2 + 4^2)')) // 5
-print(evaluate('sqrt(-4)')) // 2i
-print(evaluate('2 inch to cm')) // 5.08 cm
-print(evaluate('cos(45 deg)')) // 0.70711
-
-// evaluate multiple expressions at once
-console.log('\nevaluate multiple expressions at once')
-print(evaluate([
- 'f = 3',
- 'g = 4',
- 'f * g'
-])) // [3, 4, 12]
-
-// provide a scope (just a regular JavaScript Object)
-console.log('\nevaluate expressions providing a scope with variables and functions')
-const scope = {
- a: 3,
- b: 4
-}
-
-// variables can be read from the scope
-print(evaluate('a * b', scope)) // 12
-
-// variable assignments are written to the scope
-print(evaluate('c = 2.3 + 4.5', scope)) // 6.8
-print(scope.c) // 6.8
-
-// scope can contain both variables and functions
-scope.hello = function (name) {
- return 'hello, ' + name + '!'
-}
-print(evaluate('hello("hero")', scope)) // "hello, hero!"
-
-// define a function as an expression
-const f = evaluate('f(x) = x ^ a', scope)
-print(f(2)) // 8
-print(scope.f(2)) // 8
-
-// 2. using function parse
-//
-// Function `parse` parses expressions into a node tree. The syntax is
-// similar to function `evaluate`.
-// Function `parse` accepts a single expression or an array with
-// expressions as first argument. The function returns a node tree, which
-// then can be compiled against math, and then evaluated against an (optional
-// scope. This scope is a regular JavaScript Object. The scope will be used
-// to resolve symbols, and to write assigned variables or function.
-console.log('\n2. USING FUNCTION MATH.PARSE')
-
-// parse an expression
-console.log('\nparse an expression into a node tree')
-const node1 = parse('sqrt(3^2 + 4^2)')
-print(node1.toString()) // "sqrt((3 ^ 2) + (4 ^ 2))"
-
-// compile and evaluate the compiled code
-// you could also do this in two steps: node1.compile().evaluate()
-print(node1.evaluate()) // 5
-
-// provide a scope
-console.log('\nprovide a scope')
-const node2 = parse('x^a')
-const code2 = node2.compile()
-print(node2.toString()) // "x ^ a"
-const scope2 = {
- x: 3,
- a: 2
-}
-print(code2.evaluate(scope2)) // 9
-
-// change a value in the scope and re-evaluate the node
-scope2.a = 3
-print(code2.evaluate(scope2)) // 27
-
-// 3. using function compile
-//
-// Function `compile` compiles expressions into a node tree. The syntax is
-// similar to function `evaluate`.
-// Function `compile` accepts a single expression or an array with
-// expressions as first argument, and returns an object with a function evaluate
-// to evaluate the compiled expression. On evaluation, an optional scope can
-// be provided. This scope will be used to resolve symbols, and to write
-// assigned variables or function.
-console.log('\n3. USING FUNCTION MATH.COMPILE')
-
-// parse an expression
-console.log('\ncompile an expression')
-const code3 = compile('sqrt(3^2 + 4^2)')
-
-// evaluate the compiled code
-print(code3.evaluate()) // 5
-
-// provide a scope for the variable assignment
-console.log('\nprovide a scope')
-const code4 = compile('a = a + 3')
-const scope3 = {
- a: 7
-}
-code4.evaluate(scope3)
-print(scope3.a) // 10
-
-// 4. using a parser
-//
-// In addition to the static functions `evaluate` and `parse`, js
-// contains a parser with functions `evaluate` and `parse`, which automatically
-// keeps a scope with assigned variables in memory. The parser also contains
-// some convenience methods to get, set, and remove variables from memory.
-console.log('\n4. USING A PARSER')
-const myParser = parser()
-
-// evaluate with parser
-console.log('\nevaluate expressions')
-print(myParser.evaluate('sqrt(3^2 + 4^2)')) // 5
-print(myParser.evaluate('sqrt(-4)')) // 2i
-print(myParser.evaluate('2 inch to cm')) // 5.08 cm
-print(myParser.evaluate('cos(45 deg)')) // 0.70710678118655
-
-// define variables and functions
-console.log('\ndefine variables and functions')
-print(myParser.evaluate('x = 7 / 2')) // 3.5
-print(myParser.evaluate('x + 3')) // 6.5
-print(myParser.evaluate('f2(x, y) = x^y')) // f2(x, y)
-print(myParser.evaluate('f2(2, 3)')) // 8
-
-// manipulate matrices
-// Note that matrix indexes in the expression parser are one-based with the
-// upper-bound included. On a JavaScript level however, js uses zero-based
-// indexes with an excluded upper-bound.
-console.log('\nmanipulate matrices')
-print(myParser.evaluate('k = [1, 2; 3, 4]')) // [[1, 2], [3, 4]]
-print(myParser.evaluate('l = zeros(2, 2)')) // [[0, 0], [0, 0]]
-print(myParser.evaluate('l[1, 1:2] = [5, 6]')) // [5, 6]
-print(myParser.evaluate('l')) // [[5, 6], [0, 0]]
-print(myParser.evaluate('l[2, :] = [7, 8]')) // [7, 8]
-print(myParser.evaluate('l')) // [[5, 6], [7, 8]]
-print(myParser.evaluate('m = k * l')) // [[19, 22], [43, 50]]
-print(myParser.evaluate('n = m[2, 1]')) // 43
-print(myParser.evaluate('n = m[:, 1]')) // [[19], [43]]
-
-// get and set variables and functions
-console.log('\nget and set variables and function in the scope of the parser')
-const x = myParser.get('x')
-console.log('x =', x) // x = 3.5
-const f2 = myParser.get('f2')
-console.log('f2 =', format(f2)) // f2 = f2(x, y)
-const h = f2(3, 3)
-console.log('h =', h) // h = 27
-
-myParser.set('i', 500)
-print(myParser.evaluate('i / 2')) // 250
-myParser.set('hello', function (name) {
- return 'hello, ' + name + '!'
-})
-print(myParser.evaluate('hello("hero")')) // "hello, hero!"
-
-// clear defined functions and variables
-myParser.clear()
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
diff --git a/examples/expressions.js.md b/examples/expressions.js.md
deleted file mode 100644
index d123e776ab..0000000000
--- a/examples/expressions.js.md
+++ /dev/null
@@ -1,200 +0,0 @@
----
-layout: default
----
-
-# Expressions
-
-File: [expressions.js](expressions.js)
-
-```js
-/**
- * Expressions can be evaluated in various ways:
- *
- * 1. using the function evaluate
- * 2. using the function parse
- * 3. using a parser. A parser contains functions evaluate and parse,
- * and keeps a scope with assigned variables in memory
- */
-import { compile, evaluate, format, parse, parser } from 'mathjs'
-
-// 1. using the function evaluate
-//
-// Function `evaluate` accepts a single expression or an array with
-// expressions as first argument, and has an optional second argument
-// containing a scope with variables and functions. The scope is a regular
-// JavaScript Object. The scope will be used to resolve symbols, and to write
-// assigned variables or function.
-console.log('1. USING FUNCTION MATH.EVAL')
-
-// evaluate expressions
-console.log('\nevaluate expressions')
-print(evaluate('sqrt(3^2 + 4^2)')) // 5
-print(evaluate('sqrt(-4)')) // 2i
-print(evaluate('2 inch to cm')) // 5.08 cm
-print(evaluate('cos(45 deg)')) // 0.70711
-
-// evaluate multiple expressions at once
-console.log('\nevaluate multiple expressions at once')
-print(evaluate([
- 'f = 3',
- 'g = 4',
- 'f * g'
-])) // [3, 4, 12]
-
-// provide a scope (just a regular JavaScript Object)
-console.log('\nevaluate expressions providing a scope with variables and functions')
-const scope = {
- a: 3,
- b: 4
-}
-
-// variables can be read from the scope
-print(evaluate('a * b', scope)) // 12
-
-// variable assignments are written to the scope
-print(evaluate('c = 2.3 + 4.5', scope)) // 6.8
-print(scope.c) // 6.8
-
-// scope can contain both variables and functions
-scope.hello = function (name) {
- return 'hello, ' + name + '!'
-}
-print(evaluate('hello("hero")', scope)) // "hello, hero!"
-
-// define a function as an expression
-const f = evaluate('f(x) = x ^ a', scope)
-print(f(2)) // 8
-print(scope.f(2)) // 8
-
-// 2. using function parse
-//
-// Function `parse` parses expressions into a node tree. The syntax is
-// similar to function `evaluate`.
-// Function `parse` accepts a single expression or an array with
-// expressions as first argument. The function returns a node tree, which
-// then can be compiled against math, and then evaluated against an (optional
-// scope. This scope is a regular JavaScript Object. The scope will be used
-// to resolve symbols, and to write assigned variables or function.
-console.log('\n2. USING FUNCTION MATH.PARSE')
-
-// parse an expression
-console.log('\nparse an expression into a node tree')
-const node1 = parse('sqrt(3^2 + 4^2)')
-print(node1.toString()) // "sqrt((3 ^ 2) + (4 ^ 2))"
-
-// compile and evaluate the compiled code
-// you could also do this in two steps: node1.compile().evaluate()
-print(node1.evaluate()) // 5
-
-// provide a scope
-console.log('\nprovide a scope')
-const node2 = parse('x^a')
-const code2 = node2.compile()
-print(node2.toString()) // "x ^ a"
-const scope2 = {
- x: 3,
- a: 2
-}
-print(code2.evaluate(scope2)) // 9
-
-// change a value in the scope and re-evaluate the node
-scope2.a = 3
-print(code2.evaluate(scope2)) // 27
-
-// 3. using function compile
-//
-// Function `compile` compiles expressions into a node tree. The syntax is
-// similar to function `evaluate`.
-// Function `compile` accepts a single expression or an array with
-// expressions as first argument, and returns an object with a function evaluate
-// to evaluate the compiled expression. On evaluation, an optional scope can
-// be provided. This scope will be used to resolve symbols, and to write
-// assigned variables or function.
-console.log('\n3. USING FUNCTION MATH.COMPILE')
-
-// parse an expression
-console.log('\ncompile an expression')
-const code3 = compile('sqrt(3^2 + 4^2)')
-
-// evaluate the compiled code
-print(code3.evaluate()) // 5
-
-// provide a scope for the variable assignment
-console.log('\nprovide a scope')
-const code4 = compile('a = a + 3')
-const scope3 = {
- a: 7
-}
-code4.evaluate(scope3)
-print(scope3.a) // 10
-
-// 4. using a parser
-//
-// In addition to the static functions `evaluate` and `parse`, js
-// contains a parser with functions `evaluate` and `parse`, which automatically
-// keeps a scope with assigned variables in memory. The parser also contains
-// some convenience methods to get, set, and remove variables from memory.
-console.log('\n4. USING A PARSER')
-const myParser = parser()
-
-// evaluate with parser
-console.log('\nevaluate expressions')
-print(myParser.evaluate('sqrt(3^2 + 4^2)')) // 5
-print(myParser.evaluate('sqrt(-4)')) // 2i
-print(myParser.evaluate('2 inch to cm')) // 5.08 cm
-print(myParser.evaluate('cos(45 deg)')) // 0.70710678118655
-
-// define variables and functions
-console.log('\ndefine variables and functions')
-print(myParser.evaluate('x = 7 / 2')) // 3.5
-print(myParser.evaluate('x + 3')) // 6.5
-print(myParser.evaluate('f2(x, y) = x^y')) // f2(x, y)
-print(myParser.evaluate('f2(2, 3)')) // 8
-
-// manipulate matrices
-// Note that matrix indexes in the expression parser are one-based with the
-// upper-bound included. On a JavaScript level however, js uses zero-based
-// indexes with an excluded upper-bound.
-console.log('\nmanipulate matrices')
-print(myParser.evaluate('k = [1, 2; 3, 4]')) // [[1, 2], [3, 4]]
-print(myParser.evaluate('l = zeros(2, 2)')) // [[0, 0], [0, 0]]
-print(myParser.evaluate('l[1, 1:2] = [5, 6]')) // [5, 6]
-print(myParser.evaluate('l')) // [[5, 6], [0, 0]]
-print(myParser.evaluate('l[2, :] = [7, 8]')) // [7, 8]
-print(myParser.evaluate('l')) // [[5, 6], [7, 8]]
-print(myParser.evaluate('m = k * l')) // [[19, 22], [43, 50]]
-print(myParser.evaluate('n = m[2, 1]')) // 43
-print(myParser.evaluate('n = m[:, 1]')) // [[19], [43]]
-
-// get and set variables and functions
-console.log('\nget and set variables and function in the scope of the parser')
-const x = myParser.get('x')
-console.log('x =', x) // x = 3.5
-const f2 = myParser.get('f2')
-console.log('f2 =', format(f2)) // f2 = f2(x, y)
-const h = f2(3, 3)
-console.log('h =', h) // h = 27
-
-myParser.set('i', 500)
-print(myParser.evaluate('i / 2')) // 250
-myParser.set('hello', function (name) {
- return 'hello, ' + name + '!'
-})
-print(myParser.evaluate('hello("hero")')) // "hello, hero!"
-
-// clear defined functions and variables
-myParser.clear()
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
-
-```
-
-
-
diff --git a/examples/fractions.js b/examples/fractions.js
deleted file mode 100644
index d1239b0fdd..0000000000
--- a/examples/fractions.js
+++ /dev/null
@@ -1,72 +0,0 @@
-// Fractions
-import { create, all } from 'mathjs'
-
-// configure the default type of numbers as Fractions
-const config = {
- // Default type of number
- // Available options: 'number' (default), 'BigNumber', or 'Fraction'
- number: 'Fraction'
-}
-
-// create a mathjs instance with everything included
-const math = create(all, config)
-
-console.log('basic usage')
-printRatio(math.fraction(0.125)) // Fraction, 1/8
-printRatio(math.fraction(0.32)) // Fraction, 8/25
-printRatio(math.fraction('1/3')) // Fraction, 1/3
-printRatio(math.fraction('0.(3)')) // Fraction, 1/3
-printRatio(math.fraction(2, 3)) // Fraction, 2/3
-printRatio(math.fraction('0.(285714)')) // Fraction, 2/7
-console.log()
-
-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 fractions :)')
-print(math.add(math.fraction(0.1), math.fraction(0.2))) // Fraction, 0.3
-print(math.divide(math.fraction(0.3), math.fraction(0.2))) // Fraction, 1.5
-console.log()
-
-console.log('represent an infinite number of repeating digits')
-print(math.fraction('1/3')) // Fraction, 0.(3)
-print(math.fraction('2/7')) // Fraction, 0.(285714)
-print(math.fraction('23/11')) // Fraction, 2.(09)
-console.log()
-
-// one can work conveniently with fractions using the expression parser.
-// note though that Fractions are only supported by basic arithmetic functions
-console.log('use fractions in the expression parser')
-printRatio(math.evaluate('0.1 + 0.2')) // Fraction, 3/10
-printRatio(math.evaluate('0.3 / 0.2')) // Fraction, 3/2
-printRatio(math.evaluate('23 / 11')) // Fraction, 23/11
-console.log()
-
-// output formatting
-console.log('output formatting of fractions')
-const a = math.fraction('2/3')
-console.log(math.format(a)) // Fraction, 2/3
-console.log(math.format(a, { fraction: 'ratio' })) // Fraction, 2/3
-console.log(math.format(a, { fraction: 'decimal' })) // Fraction, 0.(6)
-console.log(a.toString()) // Fraction, 0.(6)
-console.log()
-
-/**
- * Helper function to output a value in the console.
- * Fractions will be formatted as ratio, like '1/3'.
- * @param {*} value
- */
-function printRatio (value) {
- console.log(math.format(value, { fraction: 'ratio' }))
-}
-
-/**
- * Helper function to output a value in the console.
- * Fractions will be formatted as decimal, like '0.(3)'.
- * @param {*} value
- */
-function print (value) {
- console.log(math.format(value, { fraction: 'decimal' }))
-}
diff --git a/examples/fractions.js.md b/examples/fractions.js.md
deleted file mode 100644
index 536383b97f..0000000000
--- a/examples/fractions.js.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-layout: default
----
-
-# Fractions
-
-File: [fractions.js](fractions.js)
-
-```js
-// Fractions
-import { create, all } from 'mathjs'
-
-// configure the default type of numbers as Fractions
-const config = {
- // Default type of number
- // Available options: 'number' (default), 'BigNumber', or 'Fraction'
- number: 'Fraction'
-}
-
-// create a mathjs instance with everything included
-const math = create(all, config)
-
-console.log('basic usage')
-printRatio(math.fraction(0.125)) // Fraction, 1/8
-printRatio(math.fraction(0.32)) // Fraction, 8/25
-printRatio(math.fraction('1/3')) // Fraction, 1/3
-printRatio(math.fraction('0.(3)')) // Fraction, 1/3
-printRatio(math.fraction(2, 3)) // Fraction, 2/3
-printRatio(math.fraction('0.(285714)')) // Fraction, 2/7
-console.log()
-
-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 fractions :)')
-print(math.add(math.fraction(0.1), math.fraction(0.2))) // Fraction, 0.3
-print(math.divide(math.fraction(0.3), math.fraction(0.2))) // Fraction, 1.5
-console.log()
-
-console.log('represent an infinite number of repeating digits')
-print(math.fraction('1/3')) // Fraction, 0.(3)
-print(math.fraction('2/7')) // Fraction, 0.(285714)
-print(math.fraction('23/11')) // Fraction, 2.(09)
-console.log()
-
-// one can work conveniently with fractions using the expression parser.
-// note though that Fractions are only supported by basic arithmetic functions
-console.log('use fractions in the expression parser')
-printRatio(math.evaluate('0.1 + 0.2')) // Fraction, 3/10
-printRatio(math.evaluate('0.3 / 0.2')) // Fraction, 3/2
-printRatio(math.evaluate('23 / 11')) // Fraction, 23/11
-console.log()
-
-// output formatting
-console.log('output formatting of fractions')
-const a = math.fraction('2/3')
-console.log(math.format(a)) // Fraction, 2/3
-console.log(math.format(a, { fraction: 'ratio' })) // Fraction, 2/3
-console.log(math.format(a, { fraction: 'decimal' })) // Fraction, 0.(6)
-console.log(a.toString()) // Fraction, 0.(6)
-console.log()
-
-/**
- * Helper function to output a value in the console.
- * Fractions will be formatted as ratio, like '1/3'.
- * @param {*} value
- */
-function printRatio (value) {
- console.log(math.format(value, { fraction: 'ratio' }))
-}
-
-/**
- * Helper function to output a value in the console.
- * Fractions will be formatted as decimal, like '0.(3)'.
- * @param {*} value
- */
-function print (value) {
- console.log(math.format(value, { fraction: 'decimal' }))
-}
-
-```
-
-
-
diff --git a/examples/import.js b/examples/import.js
deleted file mode 100644
index 0b941d3dc7..0000000000
--- a/examples/import.js
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * Math.js can easily be extended with functions and variables using the
- * `import` function. The function `import` accepts a module name or an object
- * containing functions and variables.
- */
-import { create, all } from 'mathjs'
-const math = create(all)
-
-/**
- * Define new functions and variables
- */
-math.import({
- myConstant: 42,
- hello: function (name) {
- return 'hello, ' + name + '!'
- }
-})
-
-// defined methods can be used in both JavaScript as well as the parser
-print(math.myConstant * 2) // 84
-print(math.hello('user')) // 'hello, user!'
-
-print(math.evaluate('myConstant + 10')) // 52
-print(math.evaluate('hello("user")')) // 'hello, user!'
-
-/**
- * Import the math library numbers.js, https://github.com/sjkaliski/numbers.js
- * The library must be installed first using npm:
- * npm install numbers
- */
-try {
- // load the numbers.js library
- const numbers = require('numbers')
-
- // import the numbers.js library into math.js
- math.import(numbers, { wrap: true, silent: true })
-
- if (math.fibonacci) {
- // calculate fibonacci
- print(math.fibonacci(7)) // 13
- print(math.evaluate('fibonacci(7)')) // 13
- }
-} catch (err) {
- console.log('Warning: To use numbers.js, the library must ' +
- 'be installed first via `npm install numbers`.')
-}
-
-/**
- * Import the math library numeric.js, https://github.com/sloisel/numeric
- * The library must be installed first using npm:
- * npm install numeric
- */
-try {
- // load the numeric.js library
- const numeric = require('numeric')
-
- // import the numeric.js library into math.js
- math.import(numeric, { wrap: true, silent: true })
-
- if (math.eig) {
- // calculate eigenvalues of a matrix
- print(math.evaluate('eig([1, 2; 4, 3])').lambda.x) // [5, -1]
-
- // solve AX = b
- const A = math.evaluate('[1, 2, 3; 2, -1, 1; 3, 0, -1]')
- const b = [9, 8, 3]
- print(math.solve(A, b)) // [2, -1, 3]
- }
-} catch (err) {
- console.log('Warning: To use numeric.js, the library must ' +
- 'be installed first via `npm install numeric`.')
-}
-
-/**
- * By default, the function import does not allow overriding existing functions.
- * Existing functions can be overridden by specifying option `override: true`
- */
-math.import({
- pi: 3.14
-}, {
- override: true
-})
-
-print(math.pi) // returns 3.14 instead of 3.141592653589793
-
-/**
- * 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))
-}
diff --git a/examples/import.js.md b/examples/import.js.md
deleted file mode 100644
index 7a1a0e218a..0000000000
--- a/examples/import.js.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-layout: default
----
-
-# Import
-
-File: [import.js](import.js)
-
-```js
-/**
- * Math.js can easily be extended with functions and variables using the
- * `import` function. The function `import` accepts a module name or an object
- * containing functions and variables.
- */
-import { create, all } from 'mathjs'
-const math = create(all)
-
-/**
- * Define new functions and variables
- */
-math.import({
- myConstant: 42,
- hello: function (name) {
- return 'hello, ' + name + '!'
- }
-})
-
-// defined methods can be used in both JavaScript as well as the parser
-print(math.myConstant * 2) // 84
-print(math.hello('user')) // 'hello, user!'
-
-print(math.evaluate('myConstant + 10')) // 52
-print(math.evaluate('hello("user")')) // 'hello, user!'
-
-/**
- * Import the math library numbers.js, https://github.com/sjkaliski/numbers.js
- * The library must be installed first using npm:
- * npm install numbers
- */
-try {
- // load the numbers.js library
- const numbers = require('numbers')
-
- // import the numbers.js library into math.js
- math.import(numbers, { wrap: true, silent: true })
-
- if (math.fibonacci) {
- // calculate fibonacci
- print(math.fibonacci(7)) // 13
- print(math.evaluate('fibonacci(7)')) // 13
- }
-} catch (err) {
- console.log('Warning: To use numbers.js, the library must ' +
- 'be installed first via `npm install numbers`.')
-}
-
-/**
- * Import the math library numeric.js, https://github.com/sloisel/numeric
- * The library must be installed first using npm:
- * npm install numeric
- */
-try {
- // load the numeric.js library
- const numeric = require('numeric')
-
- // import the numeric.js library into math.js
- math.import(numeric, { wrap: true, silent: true })
-
- if (math.eig) {
- // calculate eigenvalues of a matrix
- print(math.evaluate('eig([1, 2; 4, 3])').lambda.x) // [5, -1]
-
- // solve AX = b
- const A = math.evaluate('[1, 2, 3; 2, -1, 1; 3, 0, -1]')
- const b = [9, 8, 3]
- print(math.solve(A, b)) // [2, -1, 3]
- }
-} catch (err) {
- console.log('Warning: To use numeric.js, the library must ' +
- 'be installed first via `npm install numeric`.')
-}
-
-/**
- * By default, the function import does not allow overriding existing functions.
- * Existing functions can be overridden by specifying option `override: true`
- */
-math.import({
- pi: 3.14
-}, {
- override: true
-})
-
-print(math.pi) // returns 3.14 instead of 3.141592653589793
-
-/**
- * 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))
-}
-
-```
-
-
-
diff --git a/examples/index.md b/examples/index.md
deleted file mode 100644
index b20393389b..0000000000
--- a/examples/index.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-layout: default
----
-
-# Examples
-
-- [Algebra](algebra.js.html)
-- [Basic usage](basic_usage.js.html)
-- [Bignumbers](bignumbers.js.html)
-- [Chaining](chaining.js.html)
-- [Complex numbers](complex_numbers.js.html)
-- [Expressions](expressions.js.html)
-- [Fractions](fractions.js.html)
-- [Import](import.js.html)
-- [Matrices](matrices.js.html)
-- [Objects](objects.js.html)
-- [Serialization](serialization.js.html)
-- [Sparse matrices](sparse_matrices.js.html)
-- [Units](units.js.html)
-
-# Browser examples
-
-- [Angle configuration](browser\angle_configuration.html.html)
-- [Basic usage](browser\basic_usage.html.html)
-- [Currency conversion](browser\currency_conversion.html.html)
-- [Custom separators](browser\custom_separators.html.html)
-- [Lorenz](browser\lorenz.html.html)
-- [Lorenz interactive](browser\lorenz_interactive.html.html)
-- [Plot](browser\plot.html.html)
-- [Pretty printing with mathjax](browser\pretty_printing_with_mathjax.html.html)
-- [Printing html](browser\printing_html.html.html)
-- [Requirejs loading](browser\requirejs_loading.html.html)
-- [Rocket trajectory optimization](browser\rocket_trajectory_optimization.html.html)
-- [Webworkers](browser\webworkers\index.html)
-
-# Advanced examples
-
-- [Convert fraction to bignumber](advanced\convert_fraction_to_bignumber.js.html)
-- [Custom argument parsing](advanced\custom_argument_parsing.js.html)
-- [Custom datatype](advanced\custom_datatype.js.html)
-- [Custom evaluate using factories](advanced\custom_evaluate_using_factories.js.html)
-- [Custom evaluate using import](advanced\custom_evaluate_using_import.js.html)
-- [Custom loading](advanced\custom_loading.js.html)
-- [Custom relational functions](advanced\custom_relational_functions.js.html)
-- [Custom scope objects](advanced\custom_scope_objects.js.html)
-- [Expression trees](advanced\expression_trees.js.html)
-- [Function transform](advanced\function_transform.js.html)
-- [More secure eval](advanced\more_secure_eval.js.html)
-- [Web server](advanced\web_server\index.html)
-
-
-
diff --git a/examples/matrices.js b/examples/matrices.js
deleted file mode 100644
index 760a553743..0000000000
--- a/examples/matrices.js
+++ /dev/null
@@ -1,109 +0,0 @@
-// matrices
-import { diag, factorial, format, index, map, matrix, multiply, ones, range, sqrt } from 'mathjs'
-
-// create matrices and arrays. a matrix is just a wrapper around an Array,
-// providing some handy utilities.
-console.log('create a matrix')
-const a = matrix([1, 4, 9, 16, 25])
-print(a) // [1, 4, 9, 16, 25]
-const b = matrix(ones([2, 3]))
-print(b) // [[1, 1, 1], [1, 1, 1]]
-print(b.size()) // [2, 3]
-
-// the Array data of a Matrix can be retrieved using valueOf()
-const array = a.valueOf()
-print(array) // [1, 4, 9, 16, 25]
-
-// Matrices can be cloned
-const clone = a.clone()
-print(clone) // [1, 4, 9, 16, 25]
-console.log()
-
-// perform operations with matrices
-console.log('perform operations')
-print(map(a, sqrt)) // [1, 2, 3, 4, 5]
-const c = [1, 2, 3, 4, 5]
-print(factorial(c)) // [1, 2, 6, 24, 120]
-console.log()
-
-// create and manipulate matrices. Arrays and Matrices can be used mixed.
-console.log('manipulate matrices')
-const d = [[1, 2], [3, 4]]
-print(d) // [[1, 2], [3, 4]]
-const e = matrix([[5, 6], [1, 1]])
-print(e) // [[5, 6], [1, 1]]
-
-// set a submatrix
-// Matrix indexes are zero-based.
-e.subset(index(1, [0, 1]), [[7, 8]])
-print(e) // [[5, 6], [7, 8]]
-const f = multiply(d, e)
-print(f) // [[19, 22], [43, 50]]
-const g = f.subset(index(1, 0))
-print(g) // 43
-console.log()
-
-// get a sub matrix
-// Matrix indexes are zero-based.
-console.log('get a sub matrix')
-const h = diag(range(1, 4))
-print(h) // [[1, 0, 0], [0, 2, 0], [0, 0, 3]]
-print(h.subset(index([1, 2], [1, 2]))) // [[2, 0], [0, 3]]
-const i = range(1, 6)
-print(i) // [1, 2, 3, 4, 5]
-print(i.subset(index(range(1, 4)))) // [2, 3, 4]
-console.log()
-
-// replace a single value in a matrix
-// this will mutate the matrix
-console.log('set and get a value')
-const p = matrix([[1, 2], [3, 4]])
-p.set([0, 1], 5)
-print(p) // [[1, 5], [3, 4]]
-const p21 = p.get([1, 0])
-print(p21) // 3
-console.log()
-
-// resize a multi dimensional matrix
-console.log('resizing a matrix')
-const j = matrix()
-let defaultValue = 0
-j.resize([2, 2, 2], defaultValue)
-print(j) // [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
-print(j.size()) // [2, 2, 2]
-j.resize([2, 2])
-print(j) // [[0, 0], [0, 0]]
-print(j.size()) // [2, 2]
-console.log()
-
-// setting a value outside the matrices range will resize the matrix.
-// new elements will be initialized with zero.
-console.log('set a value outside a matrices range')
-const k = matrix()
-k.subset(index(2), 6)
-print(k) // [0, 0, 6]
-console.log()
-
-console.log('set a value outside a matrices range, setting other new entries to null')
-const m = matrix()
-defaultValue = null
-m.subset(index(2), 6, defaultValue)
-print(m) // [null, null, 6]
-console.log()
-
-// create ranges
-console.log('create ranges')
-print(range(1, 6)) // [1, 2, 3, 4, 5]
-print(range(0, 18, 3)) // [0, 3, 6, 9, 12, 15]
-print(range('2:-1:-3')) // [2, 1, 0, -1, -2]
-print(factorial(range('1:6'))) // [1, 2, 6, 24, 120]
-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(format(value, precision))
-}
diff --git a/examples/matrices.js.md b/examples/matrices.js.md
deleted file mode 100644
index 0ae1b0e72c..0000000000
--- a/examples/matrices.js.md
+++ /dev/null
@@ -1,123 +0,0 @@
----
-layout: default
----
-
-# Matrices
-
-File: [matrices.js](matrices.js)
-
-```js
-// matrices
-import { diag, factorial, format, index, map, matrix, multiply, ones, range, sqrt } from 'mathjs'
-
-// create matrices and arrays. a matrix is just a wrapper around an Array,
-// providing some handy utilities.
-console.log('create a matrix')
-const a = matrix([1, 4, 9, 16, 25])
-print(a) // [1, 4, 9, 16, 25]
-const b = matrix(ones([2, 3]))
-print(b) // [[1, 1, 1], [1, 1, 1]]
-print(b.size()) // [2, 3]
-
-// the Array data of a Matrix can be retrieved using valueOf()
-const array = a.valueOf()
-print(array) // [1, 4, 9, 16, 25]
-
-// Matrices can be cloned
-const clone = a.clone()
-print(clone) // [1, 4, 9, 16, 25]
-console.log()
-
-// perform operations with matrices
-console.log('perform operations')
-print(map(a, sqrt)) // [1, 2, 3, 4, 5]
-const c = [1, 2, 3, 4, 5]
-print(factorial(c)) // [1, 2, 6, 24, 120]
-console.log()
-
-// create and manipulate matrices. Arrays and Matrices can be used mixed.
-console.log('manipulate matrices')
-const d = [[1, 2], [3, 4]]
-print(d) // [[1, 2], [3, 4]]
-const e = matrix([[5, 6], [1, 1]])
-print(e) // [[5, 6], [1, 1]]
-
-// set a submatrix
-// Matrix indexes are zero-based.
-e.subset(index(1, [0, 1]), [[7, 8]])
-print(e) // [[5, 6], [7, 8]]
-const f = multiply(d, e)
-print(f) // [[19, 22], [43, 50]]
-const g = f.subset(index(1, 0))
-print(g) // 43
-console.log()
-
-// get a sub matrix
-// Matrix indexes are zero-based.
-console.log('get a sub matrix')
-const h = diag(range(1, 4))
-print(h) // [[1, 0, 0], [0, 2, 0], [0, 0, 3]]
-print(h.subset(index([1, 2], [1, 2]))) // [[2, 0], [0, 3]]
-const i = range(1, 6)
-print(i) // [1, 2, 3, 4, 5]
-print(i.subset(index(range(1, 4)))) // [2, 3, 4]
-console.log()
-
-// replace a single value in a matrix
-// this will mutate the matrix
-console.log('set and get a value')
-const p = matrix([[1, 2], [3, 4]])
-p.set([0, 1], 5)
-print(p) // [[1, 5], [3, 4]]
-const p21 = p.get([1, 0])
-print(p21) // 3
-console.log()
-
-// resize a multi dimensional matrix
-console.log('resizing a matrix')
-const j = matrix()
-let defaultValue = 0
-j.resize([2, 2, 2], defaultValue)
-print(j) // [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
-print(j.size()) // [2, 2, 2]
-j.resize([2, 2])
-print(j) // [[0, 0], [0, 0]]
-print(j.size()) // [2, 2]
-console.log()
-
-// setting a value outside the matrices range will resize the matrix.
-// new elements will be initialized with zero.
-console.log('set a value outside a matrices range')
-const k = matrix()
-k.subset(index(2), 6)
-print(k) // [0, 0, 6]
-console.log()
-
-console.log('set a value outside a matrices range, setting other new entries to null')
-const m = matrix()
-defaultValue = null
-m.subset(index(2), 6, defaultValue)
-print(m) // [null, null, 6]
-console.log()
-
-// create ranges
-console.log('create ranges')
-print(range(1, 6)) // [1, 2, 3, 4, 5]
-print(range(0, 18, 3)) // [0, 3, 6, 9, 12, 15]
-print(range('2:-1:-3')) // [2, 1, 0, -1, -2]
-print(factorial(range('1:6'))) // [1, 2, 6, 24, 120]
-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(format(value, precision))
-}
-
-```
-
-
-
diff --git a/examples/objects.js b/examples/objects.js
deleted file mode 100644
index 57f73ad4c0..0000000000
--- a/examples/objects.js
+++ /dev/null
@@ -1,33 +0,0 @@
-// objects
-import { evaluate, format } from 'mathjs'
-
-// create an object. Keys can be symbols or strings
-print(evaluate('{x: 2 + 1, y: 4}')) // {"x": 3, "y": 4}
-print(evaluate('{"name": "John"}')) // {"name": "John"}
-
-// create an object containing an object
-print(evaluate('{a: 2, b: {c: 3, d: 4}}')) // {"a": 2, "b": {"c": 3, "d": 4}}
-
-const scope = {
- obj: {
- prop: 42
- }
-}
-
-// retrieve properties using dot notation or bracket notation
-print(evaluate('obj.prop', scope)) // 42
-print(evaluate('obj["prop"]', scope)) // 42
-
-// set properties (returns the whole object, not the property value!)
-print(evaluate('obj.prop = 43', scope)) // 43
-print(evaluate('obj["prop"] = 43', scope)) // 43
-print(scope.obj) // {"prop": 43}
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
diff --git a/examples/objects.js.md b/examples/objects.js.md
deleted file mode 100644
index 0b6d6b2d6d..0000000000
--- a/examples/objects.js.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-layout: default
----
-
-# Objects
-
-File: [objects.js](objects.js)
-
-```js
-// objects
-import { evaluate, format } from 'mathjs'
-
-// create an object. Keys can be symbols or strings
-print(evaluate('{x: 2 + 1, y: 4}')) // {"x": 3, "y": 4}
-print(evaluate('{"name": "John"}')) // {"name": "John"}
-
-// create an object containing an object
-print(evaluate('{a: 2, b: {c: 3, d: 4}}')) // {"a": 2, "b": {"c": 3, "d": 4}}
-
-const scope = {
- obj: {
- prop: 42
- }
-}
-
-// retrieve properties using dot notation or bracket notation
-print(evaluate('obj.prop', scope)) // 42
-print(evaluate('obj["prop"]', scope)) // 42
-
-// set properties (returns the whole object, not the property value!)
-print(evaluate('obj.prop = 43', scope)) // 43
-print(evaluate('obj["prop"] = 43', scope)) // 43
-print(scope.obj) // {"prop": 43}
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- const precision = 14
- console.log(format(value, precision))
-}
-
-```
-
-
-
diff --git a/examples/serialization.js b/examples/serialization.js
deleted file mode 100644
index eb0cf4ab4f..0000000000
--- a/examples/serialization.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// serialization
-import { complex, replacer, reviver, typeOf } from 'mathjs'
-
-// serialize a math.js data type into a JSON string
-// the replacer function is needed to correctly stringify a value like Infinity
-const x = complex('2+3i')
-const str1 = JSON.stringify(x, replacer)
-console.log(str1)
-// outputs {"mathjs":"Complex","re":2,"im":3}
-
-// deserialize a JSON string into a math.js data type
-// note that the reviver of math.js is needed for this:
-const str2 = '{"mathjs":"Unit","value":5,"unit":"cm"}'
-const y = JSON.parse(str2, reviver)
-console.log(typeOf(y)) // 'Unit'
-console.log(y.toString()) // 5 cm
diff --git a/examples/serialization.js.md b/examples/serialization.js.md
deleted file mode 100644
index e600c5e722..0000000000
--- a/examples/serialization.js.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-layout: default
----
-
-# Serialization
-
-File: [serialization.js](serialization.js)
-
-```js
-// serialization
-import { complex, replacer, reviver, typeOf } from 'mathjs'
-
-// serialize a math.js data type into a JSON string
-// the replacer function is needed to correctly stringify a value like Infinity
-const x = complex('2+3i')
-const str1 = JSON.stringify(x, replacer)
-console.log(str1)
-// outputs {"mathjs":"Complex","re":2,"im":3}
-
-// deserialize a JSON string into a math.js data type
-// note that the reviver of math.js is needed for this:
-const str2 = '{"mathjs":"Unit","value":5,"unit":"cm"}'
-const y = JSON.parse(str2, reviver)
-console.log(typeOf(y)) // 'Unit'
-console.log(y.toString()) // 5 cm
-
-```
-
-
-
diff --git a/examples/sparse_matrices.js b/examples/sparse_matrices.js
deleted file mode 100644
index f65d415154..0000000000
--- a/examples/sparse_matrices.js
+++ /dev/null
@@ -1,19 +0,0 @@
-// Sparse matrices
-import { identity, multiply, transpose, complex } from 'mathjs'
-
-// create a sparse matrix
-console.log('creating a 1000x1000 sparse matrix...')
-const a = identity(1000, 1000, 'sparse')
-
-// do operations with a sparse matrix
-console.log('doing some operations on the sparse matrix...')
-const b = multiply(a, a)
-const c = multiply(b, complex(2, 2))
-const d = transpose(c)
-const e = multiply(d, a)
-console.log('size(e)=', e.size())
-
-// we will not print the output, but doing the same operations
-// with a dense matrix are very slow, try it for yourself.
-console.log('already done')
-console.log('now try this with a dense matrix :)')
diff --git a/examples/sparse_matrices.js.md b/examples/sparse_matrices.js.md
deleted file mode 100644
index fccea2b554..0000000000
--- a/examples/sparse_matrices.js.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-layout: default
----
-
-# Sparse matrices
-
-File: [sparse_matrices.js](sparse_matrices.js)
-
-```js
-// Sparse matrices
-import { identity, multiply, transpose, complex } from 'mathjs'
-
-// create a sparse matrix
-console.log('creating a 1000x1000 sparse matrix...')
-const a = identity(1000, 1000, 'sparse')
-
-// do operations with a sparse matrix
-console.log('doing some operations on the sparse matrix...')
-const b = multiply(a, a)
-const c = multiply(b, complex(2, 2))
-const d = transpose(c)
-const e = multiply(d, a)
-console.log('size(e)=', e.size())
-
-// we will not print the output, but doing the same operations
-// with a dense matrix are very slow, try it for yourself.
-console.log('already done')
-console.log('now try this with a dense matrix :)')
-
-```
-
-
-
diff --git a/examples/units.js b/examples/units.js
deleted file mode 100644
index 6f7e9c0f73..0000000000
--- a/examples/units.js
+++ /dev/null
@@ -1,106 +0,0 @@
-// units
-import { add, cross, divide, evaluate, format as _format, multiply, number, pow, to, unit } from 'mathjs'
-
-// units can be created by providing a value and unit name, or by providing
-// a string with a valued unit.
-console.log('create units')
-const a = unit(45, 'cm')
-const b = unit('0.1m')
-print(a) // 45 cm
-print(b) // 0.1 m
-console.log()
-
-// units can be added, subtracted, and multiplied or divided by numbers and by other units
-console.log('perform operations')
-print(add(a, b)) // 55 cm
-print(multiply(b, 2)) // 0.2 m
-print(divide(unit('1 m'), unit('1 s'))) // 1 m / s
-print(pow(unit('12 in'), 3)) // 1728 in^3
-console.log()
-
-// units can be converted to a specific type, or to a number
-console.log('convert to another type or to a number')
-print(b.to('cm')) // 10 cm Alternatively: to(b, 'cm')
-print(to(b, 'inch')) // 3.9370078740157 inch
-print(b.toNumber('cm')) // 10
-print(number(b, 'cm')) // 10
-console.log()
-
-// the expression parser supports units too
-console.log('parse expressions')
-print(evaluate('2 inch to cm')) // 5.08 cm
-print(evaluate('cos(45 deg)')) // 0.70710678118655
-print(evaluate('90 km/h to m/s')) // 25 m / s
-console.log()
-
-// convert a unit to a number
-// A second parameter with the unit for the exported number must be provided
-print(evaluate('number(5 cm, mm)')) // number, 50
-console.log()
-
-// simplify units
-console.log('simplify units')
-print(evaluate('100000 N / m^2')) // 100 kPa
-print(evaluate('9.81 m/s^2 * 100 kg * 40 m')) // 39.24 kJ
-console.log()
-
-// example engineering calculations
-console.log('compute molar volume of ideal gas at 65 Fahrenheit, 14.7 psi in L/mol')
-const Rg = unit('8.314 N m / (mol K)')
-const T = unit('65 degF')
-const P = unit('14.7 psi')
-const v = divide(multiply(Rg, T), P)
-console.log('gas constant (Rg) = ', format(Rg))
-console.log('P = ' + format(P))
-console.log('T = ' + format(T))
-console.log('v = Rg * T / P = ' + format(to(v, 'L/mol')))
-// 23.910432393453 L / mol
-console.log()
-
-console.log('compute speed of fluid flowing out of hole in a container')
-const g = unit('9.81 m / s^2')
-const h = unit('1 m')
-const v2 = pow(multiply(2, multiply(g, h)), 0.5) // Can also use sqrt
-console.log('g = ' + format(g))
-console.log('h = ' + format(h))
-console.log('v = (2 g h) ^ 0.5 = ' + format(v2))
-// 4.42944691807 m / s
-console.log()
-
-console.log('electrical power consumption:')
-const expr1 = '460 V * 20 A * 30 days to kWh'
-console.log(expr1 + ' = ' + evaluate(expr1)) // 6624 kWh
-console.log()
-
-console.log('circuit design:')
-const expr2 = '24 V / (6 mA)'
-console.log(expr2 + ' = ' + evaluate(expr2)) // 4 kohm
-console.log()
-
-console.log('operations on arrays:')
-const B = evaluate('[1, 0, 0] T')
-const v3 = evaluate('[0, 1, 0] m/s')
-const q = evaluate('1 C')
-const F = multiply(q, cross(v3, B))
-console.log('B (magnetic field strength) = ' + format(B)) // [1 T, 0 T, 0 T]
-console.log('v (particle velocity) = ' + format(v3)) // [0 m / s, 1 m / s, 0 m / s]
-console.log('q (particle charge) = ' + format(q)) // 1 C
-console.log('F (force) = q (v cross B) = ' + format(F)) // [0 N, 0 N, -1 N]
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- console.log(format(value))
-}
-
-/**
- * Helper function to format an output a value.
- * @param {*} value
- * @return {string} Returns the formatted value
- */
-function format (value) {
- const precision = 14
- return _format(value, precision)
-}
diff --git a/examples/units.js.md b/examples/units.js.md
deleted file mode 100644
index 5b127e2990..0000000000
--- a/examples/units.js.md
+++ /dev/null
@@ -1,120 +0,0 @@
----
-layout: default
----
-
-# Units
-
-File: [units.js](units.js)
-
-```js
-// units
-import { add, cross, divide, evaluate, format as _format, multiply, number, pow, to, unit } from 'mathjs'
-
-// units can be created by providing a value and unit name, or by providing
-// a string with a valued unit.
-console.log('create units')
-const a = unit(45, 'cm')
-const b = unit('0.1m')
-print(a) // 45 cm
-print(b) // 0.1 m
-console.log()
-
-// units can be added, subtracted, and multiplied or divided by numbers and by other units
-console.log('perform operations')
-print(add(a, b)) // 55 cm
-print(multiply(b, 2)) // 0.2 m
-print(divide(unit('1 m'), unit('1 s'))) // 1 m / s
-print(pow(unit('12 in'), 3)) // 1728 in^3
-console.log()
-
-// units can be converted to a specific type, or to a number
-console.log('convert to another type or to a number')
-print(b.to('cm')) // 10 cm Alternatively: to(b, 'cm')
-print(to(b, 'inch')) // 3.9370078740157 inch
-print(b.toNumber('cm')) // 10
-print(number(b, 'cm')) // 10
-console.log()
-
-// the expression parser supports units too
-console.log('parse expressions')
-print(evaluate('2 inch to cm')) // 5.08 cm
-print(evaluate('cos(45 deg)')) // 0.70710678118655
-print(evaluate('90 km/h to m/s')) // 25 m / s
-console.log()
-
-// convert a unit to a number
-// A second parameter with the unit for the exported number must be provided
-print(evaluate('number(5 cm, mm)')) // number, 50
-console.log()
-
-// simplify units
-console.log('simplify units')
-print(evaluate('100000 N / m^2')) // 100 kPa
-print(evaluate('9.81 m/s^2 * 100 kg * 40 m')) // 39.24 kJ
-console.log()
-
-// example engineering calculations
-console.log('compute molar volume of ideal gas at 65 Fahrenheit, 14.7 psi in L/mol')
-const Rg = unit('8.314 N m / (mol K)')
-const T = unit('65 degF')
-const P = unit('14.7 psi')
-const v = divide(multiply(Rg, T), P)
-console.log('gas constant (Rg) = ', format(Rg))
-console.log('P = ' + format(P))
-console.log('T = ' + format(T))
-console.log('v = Rg * T / P = ' + format(to(v, 'L/mol')))
-// 23.910432393453 L / mol
-console.log()
-
-console.log('compute speed of fluid flowing out of hole in a container')
-const g = unit('9.81 m / s^2')
-const h = unit('1 m')
-const v2 = pow(multiply(2, multiply(g, h)), 0.5) // Can also use sqrt
-console.log('g = ' + format(g))
-console.log('h = ' + format(h))
-console.log('v = (2 g h) ^ 0.5 = ' + format(v2))
-// 4.42944691807 m / s
-console.log()
-
-console.log('electrical power consumption:')
-const expr1 = '460 V * 20 A * 30 days to kWh'
-console.log(expr1 + ' = ' + evaluate(expr1)) // 6624 kWh
-console.log()
-
-console.log('circuit design:')
-const expr2 = '24 V / (6 mA)'
-console.log(expr2 + ' = ' + evaluate(expr2)) // 4 kohm
-console.log()
-
-console.log('operations on arrays:')
-const B = evaluate('[1, 0, 0] T')
-const v3 = evaluate('[0, 1, 0] m/s')
-const q = evaluate('1 C')
-const F = multiply(q, cross(v3, B))
-console.log('B (magnetic field strength) = ' + format(B)) // [1 T, 0 T, 0 T]
-console.log('v (particle velocity) = ' + format(v3)) // [0 m / s, 1 m / s, 0 m / s]
-console.log('q (particle charge) = ' + format(q)) // 1 C
-console.log('F (force) = q (v cross B) = ' + format(F)) // [0 N, 0 N, -1 N]
-
-/**
- * Helper function to output a value in the console. Value will be formatted.
- * @param {*} value
- */
-function print (value) {
- console.log(format(value))
-}
-
-/**
- * Helper function to format an output a value.
- * @param {*} value
- * @return {string} Returns the formatted value
- */
-function format (value) {
- const precision = 14
- return _format(value, precision)
-}
-
-```
-
-
-
diff --git a/googlea47c4a0b36d11021.html b/googlea47c4a0b36d11021.html
deleted file mode 100644
index 9ac6df3dd9..0000000000
--- a/googlea47c4a0b36d11021.html
+++ /dev/null
@@ -1 +0,0 @@
-google-site-verification: googlea47c4a0b36d11021.html
\ No newline at end of file
diff --git a/gulpfile.js b/gulpfile.js
deleted file mode 100644
index afb2dcc8f0..0000000000
--- a/gulpfile.js
+++ /dev/null
@@ -1,335 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-var zlib = require('zlib');
-var { globSync } = require('glob');
-var { rimraf } = require('rimraf');
-var gulp = require('gulp');
-var log = require('fancy-log');
-var replace = require('gulp-replace');
-var rename = require('gulp-rename');
-var header = require('gulp-header');
-var handlebars = require('handlebars');
-
-var DEP_MATHJS = './node_modules/mathjs'
-var DEP_MATHJS_SRC = './mathjs-src'
-var LIB_SRC = DEP_MATHJS + '/lib/browser/*';
-var LIB_DEST = './js/lib';
-var DOCS_SRC = DEP_MATHJS_SRC + '/docs/**/*.md';
-var DOCS_DEST = './docs';
-var EXAMPLES_SRC = DEP_MATHJS_SRC + '/examples/**/*';
-var EXAMPLES_DEST = './examples';
-var HISTORY_SRC = DEP_MATHJS_SRC + '/HISTORY.md';
-var HISTORY_DEST = '.';
-var MATHJS = LIB_DEST + '/math.js';
-var DOWNLOAD = './download.md';
-
-var MD_HEADER =
- '---\n' +
- 'layout: default\n' +
- '---\n' +
- '\n';
-
-var EXAMPLE_TEMPLATE = MD_HEADER +
- '# {{title}}\n\n' +
- '{{#each files}}' +
- 'File: [{{url}}]({{url}}){{#if_eq type "html"}} (click for a live demo){{/if_eq}}\n\n' +
- '```{{type}}\n' +
- '{{{code}}}' +
- '\n```\n\n' +
- '{{/each}}' +
- '\n\n';
-
-var INDEX_TEMPLATE = MD_HEADER +
- '# Examples\n\n' +
- '{{#each files}}' +
- '- [{{title}}]({{url}})\n' +
- '{{/each}}' +
- '\n' +
- '\n' +
- '# Browser examples\n\n' +
- '{{#each browserFiles}}' +
- '- [{{title}}]({{url}})\n' +
- '{{/each}}' +
- '\n' +
- '\n' +
- '# Advanced examples\n\n' +
- '{{#each advancedFiles}}' +
- '- [{{title}}]({{url}})\n' +
- '{{/each}}' +
- '\n' +
- '\n' +
- '\n\n';
-
-// source: https://stackoverflow.com/questions/15088215/handlebars-js-if-block-helper
-handlebars.registerHelper('if_eq', function(a, b, opts) {
- if(a === b)
- return opts.fn(this);
- else
- return opts.inverse(this);
-});
-
-// get version of math.js
-function version() {
- return require('mathjs/package.json').version;
-}
-
-// inject permalinks in markdown files in a gulp pipe
-var fn = function (header, level, title) {
- // for example:
- // header is '## My Header',
- // level is '##',
- // title is 'My Header'
- var tag = 'h' + level.length; // for example 'h2'
- var id = title.toLowerCase() // for example 'my-header'
- .replace(/[^\w\s]/g, '')
- .replace(/\s/g, '-');
- var link = '#'; // clickable link to header
-
- // returns for example '
-
-- Fix: #3482 mathjs throwing an error related to `BigInt` when loading in
- specific environments.
-- Fix: syntax section of function `numeric` (see #3448).
-- Fix: #3472 rename physical constant `coulomb` to `coulombConstant`. The old
- name is still available for backward compatibility.
-- Fix: support multiplication of arrays with units (#3456). Thanks @Delaney.
-
-
-
-- Feat: improve the performance of the `map` and `forEach` methods of
- `DenseMatrix` (#3446). Thanks @dvd101x.
-- Feat: improve the performance of `subset` (#3467). Thanks @dvd101x.
-- Feat: define embedded docs for `compile`, `evaluate`, `parse`, and `parser`,
- and add tests for the examples in embedded docs (#3413). Thanks @dvd101x.
-- Fix: #3450 support multiplication of valueless units by arbitrary types
- (#3454).
-- Fix: #3474 correctly parse `(lbf in)` (#3476). Thanks @costerwi.
-
-
-
-- Feat: improve the performance of function `flatten` (#3400). Thanks @dvd101x.
-- Feat: improve the performance of `map` and `forEach` (#3409).
- Thanks @dvd101x.
-- Feat: add LaTeX representation for fractions (#3434, #3419). Thanks @orelbn.
-- Fix: #3422 allow dot operators after symbol E (#3425).
-- Fix: issue in the `nthRoots` latex function template string (#3427).
- Thanks @aitee.
-- Fix: upgrade to the latest version of `@babel/runtime`.
-
-
-
-- Feat: #3041, #3340 rename `apply` to `mapSlices` (#3357). Function
- `apply` is still available but is now marked deprecated. Thanks @gwhitney.
-- Fix: #3247 don't override type-native floor/ceil within tolerance of value
- (#3369). Thanks @gwhitney.
-- Fix: #3360 add bigint support to matrix indices and ranges (#3361).
- Thanks @gwhitney.
-- Fix: #3115 type definitions for matrixFrom* (#3371). Thanks @Hudsxn
- and @gwhitney.
-
-
-
-- Fix: make derivative much faster (#3322). Thanks @paulftw.
-- Fix: #3317 export `Fraction` type from the `fraction.js` library instead of
- using a custom interface (#3330). Thanks @fchu.
-
-
-
-!!! BE CAREFUL: BREAKING CHANGES !!!
-
-- Feat: Upgrade to `fraction.js@5`, using `bigint` under the hood (#3283).
-- Feat: Implement support for `Unit` in functions `ceil`, `floor`, and `fix`.
- Possible breaking changes in the type definitions of arrays and matrices
- due to the introduction of generics (#3269). Thanks @orelbn.
-- Feat: Implement support for `log(x: Fraction, base: Fraction)`.
-- Fix: #3301 precedence of `%` (mod) being higher than `*` and `/` (#3311).
- Thanks @nkumawat34.
-- Fix: #3222 prevent `math.import(...)` from overriding units unless you
- specify `{ override: true }` (#3225).
-- Fix: #3219 let functions `dotDivide`, `dotPow`, `bitXor`, `xor`, `equal`,
- `larger`, `largerEq`, `smaller`, `smallerEq`, and `unequal` return a sparse
- matrix when the input is two sparse matrices (#3307). Thanks @Aakash-Rana.
-- Fix: Improve type definitions of arrays (#3306). Thanks @orelbn.
-
-
-
-- Fix: #3260 improve type definitions and documentation on the callback
- indices of `map`, `filter`, and `forEach`.
-- Fix: #3323 support functions in function `clone`.
-- Docs: fix a broken link in the documentation (#3316).
- Thanks @emmanuel-ferdman.
-
-
-
-- Feat: improve performance of functions `map`, `filter` and `forEach` (#3256).
- Thanks @dvd101x.
-- Feat: improve performance of the methods `map()` and `forEach()`
- of `DenseMatrix` (#3251). Thanks @Galm007.
-- Fix: #3253 cannot use identifiers containing special characters in function
- `derivative`.
-- Fix: improve the type definitions of `ConstantNode` to support all data
- types (#3257). Thanks @smith120bh.
-- Fix: #3259 function `symbolicEqual` missing in the TypeScript definitions.
-- Fix: #3246 function `leafCount` missing in the TypeScript definitions.
-- Fix: #3267 implicit multiplication with a negative number and unit `in`.
-- Docs: fix broken links on the Configuration page. Thanks @vassudanagunta.
-- Docs: document the syntax of `map` and `forEach` in the expression parser
- (#3272). Thanks @dvd101x.
-
-
-
-- Fix security vulnerability in the CLI and web API allowing to call functions
- `import`, `createUnit` and `reviver`, allowing to get access to the internal
- math namespace and allowing arbitrary code execution. Thanks @StarlightPWN.
-- Fix security vulnerability: when overwriting a `rawArgs` function with a
- non-`rawArgs` function, it was still called with raw arguments. This was both
- a functional issue and a security issue. Thanks @StarlightPWN.
-- Fix security vulnerability: ensure that `ObjectWrappingMap` cannot delete
- unsafe properties. Thanks @StarlightPWN.
-- Fix: not being able to use methods and properties on arrays inside the
- expression parser.
-
-
-
-- Feat: support multiple inputs in function `map` (#3228, #3196).
- Thanks @dvd101x.
-- Feat: add matrix datatypes in more cases (#3235). Thanks @dvd101x.
-- Feat: export util functions `isMap`, `isPartitionedMap`, and
- `isObjectWrappingMap`.
-- Fix: #3241 function `map` not always working with matrices (#3242).
- Thanks @dvd101x.
-- Fix: #3244 fix broken link to `ResultSet` in the docs about classes.
-- Docs: add a link to the documentation page about the syntax expression
- from the function `evaluate` (see #3238).
-- Docs: improve the documentation of `scope` and fix the example
- `custom_scope_objects.js` (#3150)
-- Docs: spelling fixes in the embedded docs (#3252). Thanks @dvd101x.
-
-
-
-- Fix: #3232 fix type definitions of function `format` to support notations
- `hex`, `bin`, and `oct`.
-- Fix: use more precise definitions for US liquid volume units (#3229).
- Thanks @Vistinum.
-- Fix: #2286 types static methods and members for Unit class (#3230).
- Thanks @orelbn.
-
-
-
-Breaking changes:
-
-- Change `isZero`, `isPositive`, and `isNegative` to respect `config.epsilon`
- (#3139, #2838). Thanks @dvd101x.
-- Change the behavior of the internal `nearlyEqual` to align with Python and
- Julia (#3152, #2838). Thanks @dvd101x.
-- Upgrade to `fraction.js@4.3.7`,
- see .
-- Dropped support for JavaScript engines that do not fully support ES6 or
- `bigint`, or are not actively maintained. ES2020 is now the minimum required
- EcmaScript version.
-
-Non-breaking changes:
-
-- Implemented support for `bigint` (#3207, #3207)
-- Implemented a new config option `config.numberFallback` needed for `bigint`
- (#3207).
-- Internal: refactored tooling to ES modules and upgraded all devDependencies.
-
-
-
-- Fix: serialization of Units without a value, see #1240.
-- Fix: outdated, incorrect documentation about the order of precedence for
- operator modulus `%`. See #3189.
-- Fix: #3197 improve `quantileSeq` type definitions (#3198). Thanks @domdomegg.
-
-
-
-- Fix #3192: function `isNaN` returns `false` for `NaN` units in a matrix or
- array (#3193). Thanks @lgerin.
-- Fix: #3180 fix type definitions of functions `add` and `multiply` to allow
- more than two arguments.
-- Docs: correct the docs about `traverse` returning void (#3177).
- Thanks @rohildshah.
-
-
-
-- Docs: implement an interactive version of the Lorenz example, and show the
- chart full screen (#3151). Thanks @dvd101x.
-- Fix #3172: simplify `"true and true"`.
-- Fix #3163: `toTex` wrongly returning `Infinity` for large BigNumbers.
-- Fix #3162: add license information about CSParse (#3164).
-- Fix #3175: cannot delete units using `math.Unit.deleteUnit`.
-- Fix: faster startup time of the CLI and REPL by loading the bundle.
-- Fix: remove using polyfill.io inside the example
- `pretty_printing_with_mathjax.html` (#3167). Thanks @SukkaW.
-
-
-
-- Feat: implement support for trailing commas in matrices (#3154, #2968).
- Thanks @dvd101x.
-- Feat: improve the performance of `multiply` a lot by adding matrix type
- inferencing (#3149). Thanks @RandomGamingDev.
-- Fix: #3100 function `round` not handling round-off errors (#3136).
- Thanks @BrianFugate.
-- Fix: `PartitionedMap` and `ObjectWrappingMap` missing a property
- `Symbol.iterator`, causing problems when trying `new Map(scope)` (#3156).
-- Fix: type definitions of function `mode` (#3153). Thanks @rich-martinez.
-- Docs: describe method `getAllAsMap` in the Parser docs (#3158, #3157).
- Thanks @dvd101x.
-
-
-
-- Improved the performance of custom defined functions in the expression
- parser (#3150).
-- Fix: #3143 cannot use `and` and `or` inside a function definition.
- Regression since `v12.1.0` (#3150).
-
-
-
-- Improved the typings of the arguments of `ArrayNode`, `FunctionNode`,
- `IndexNode`, `OperatorNode`, and `RelationalNode` (#3123). Thanks @sylee957.
-- Added a fully featured code editor example with CodeMirror and Katex (#3027).
- Thanks @dvd101x.
-- Fix: #3114 build warnings related to a number of wrong `/* #__PURE__ */`
- annotations.
-- Fix: #3142 support BigNumber values for the options of function `format`:
- `precision`, `wordSize`, `lowerExp`, `upperExp`. Support BigNumber values
- for the option `wordSize` in the functions `hex`, `bin`, and `oct`.
-- Fix: #3125 type definitions of function `hypot` (#3144).
- Thanks @silentmissile.
-- Fix: #3141 `help(config)` altering the actual `config` when evaluating the
- examples.
-- Docs: #3145 fix documentation about REPL, it does require a build step
- nowadays.
-
-
-
-- Feat: Extend function `round` with support for units (#2761, #3095).
-- Feat: Extend function `mod` with support for negative divisors in when
- using `BigNumber` or `Fraction` (#3087).
-- Fix: #3092 a typo in an error message when converting a string into a number.
-- Fix: #3094 function `derivative` mutates the input expression when it fails.
-
-
-
-Breaking changes:
-
-- Fix #2879, #2927, #3014: change the confusing interface of `eigs` (#3037),
- thanks @gwhitney.
- Before, functions `eigs` returned an object:
-
- ```
- { values: MathCollection; vectors: MathCollection }
- ```
-
- where `vectors` was a 2d matrix of which the columns contained the vectors.
- This is changed to `eigs` returning an object:
-
- ```
- {
- values: MathCollection
- eigenvectors: Array<{
- value: number | BigNumber
- vector: MathCollection
- }>
- }
- ```
-
- Where `eigenvectors` is an array containing an object with the corresponding
- eigenvalue and vector.
-- Refactored the TypeScript type definitions to make them work with a `NodeNext`
- module resolution (#3079, #2919).
- - Type `MathJsStatic` is renamed to `MathJsInstance`.
- - Type `FactoryDependencies` is deprecated, use `MathJsFactory` instead, and
- import dependency maps directly from the library.
-- Change the assignment operator of `.toTex()` output from `:=` to `=` (see
- #2980, #2987).
-- Drop official support for Node.js 14 and 16.
-
-Features:
-
-- Function `eigs` now has an option to turn off calculation of eigenvectors
- (#3057, #2180). Thanks @gwhitney.
-
-Fixes:
-
-- Find eigenvectors of defective matrices (#3037). Thanks @gwhitney.
-
-
-
-- Implemented function `subtractScalar` (#3081, #2643), thanks @vrushaket.
-- Fix #3073: function format not escaping control characters and double
- quotes (#3082).
-- Fix: function `clone` not throwing an error when passing an unsupported
- type like a function.
-- Fix: #2960 add type definition of function `symbolicEqual` (#3035),
- thanks @juancodeaudio.
-
-
-
-- Fix #3025: improve handling of matrices and error handling
- in function `corr` (#3030). Thanks @vrushaket.
-- Fix #3074: improve error message when using function `max` in `derivative`.
-- Fix #3073: fix parsing quotes inside a string.
-- Fix #2027: cannot use named operators like `to` or `mod` as property name.
-
-
-
-- Fix #2989: use one-based indices in `print` in the parser (#3009).
- Thanks @dvd101x.
-- Fix #2936: `mod` sometimes giving wrong results due to internal round-off
- errors (#3011). Thanks @praisennamonu1.
-- Internal refactor of `quantileSeq`, and fixed the embedded help (#3003).
- Thanks @dvd101x.
-- Updated dependencies and devDependencies.
-
-
-
-- Implement function `corr` to calculate the correlation between two matrices
- (#3015, #2624). Thanks @vrushaket.
-- Lock `fraction.js` at version `4.3.4` for now, see #3024, 3022,
- .
-
-
-
-- Upgrade to `fraction.js@4.3.4`, see #3022.
-- Fix #3020: `lruQueue` using the global `hasOwnProperty` which may be
- polluted.
-- Add support for prefixes for the unit `erg`, and restrict prefixes of the
- unit `joule` to only long prefixes like `kilo` and no short prefixes
- like `k` (#3019). Thanks @costerwi.
-- Add a new browser example `examples/browser/lorenz.html` that uses `solveODE`
- and plots the result in a chart (#3018). Thanks @dvd101x.
-
-
-
-- Extend function `quantileSeq` with support for a `dimension` (#3002).
- Thanks @dvd101x.
-- Implement #2735: Support indexing with an array of booleans, for
- example `a[[true, false, true]]` and `a[a > 2]` (#2994). Thanks @dvd101x.
-- Implement function `zeta` (#2950, #2975, #2904). Thanks @Bobingstern.
-- Fix #2990: `DenseMatrix` can mutate input arrays (#2991).
-
-
-
-- Implement function `solveODE` (#2958). Thanks @dvd101x.
-- Implement functions `zpk2tf` and `freqz` (#2988, #2969). Thanks @alykhaled.
-- Implement support for units in function `range` (#2997). Thanks @dvd101x.
-- Fix #2974: `simplify` puts plus and minus signs next to each other (#2981).
- Thanks @MaybePixem.
-- Fix #2973: fixes and improvements in the embedded docs (#2976).
- Thanks @dvd101x.
-- Fix #2996: two errors in the examples in the documentation about Expression
- trees.
-- Fix round-off errors near zero when converting temperatures (#2962).
- Thanks @costerwi.
-- Refactored function `range`, reducing the amount of code (#2995).
- Thanks @dvd101x.
-
-
-
-- Fix #2964: issue in function `distance` when calculate the distance from
- a point to a line (#2965). Thanks @Kiku-CN.
-- Fix `math.format` not working correctly for `engineering` notation when using
- BigNumbers and for `fixed` notation with `precision: 0` configured (#2956).
- Thanks @mgreminger.
-- Fix #2880: not possible to map cube root `cbrt`.
-- Fix #2938: make the syntax description of all functions consistent in the
- docs (#2941). Thanks @dvd101x.
-- Fix #2954: improve the TypeScript definitions the return type of functions
- `min` and `max` (#2955). Thanks @Maxim-Mazurok.
-- Fix #2959: typo in an example in the docs. Thanks @kunalagrwl.
-- Drop official support for Node.js 14, has reached end of life.
-
-
-
-- Extended functions `fraction`, `bignumber`, and `number` with support for
- units, see #2918 (#2926).
-- Implemented aliases `amp` and `amps` for unit `ampere` (#2917).
- Thanks @veggiesaurus.
-- Improve TypeScript definitions of function `gcd` (#2922). Thanks @brunoSnoww.
-- Fix #2923: improve docs of the function `distance` (#2924). Thanks @tmtron.
-
-
-
-- Implement #2567: accept array as parameter for function `gcd` (#2878).
- Thanks @jakubriegel.
-- Fix #2908: improvements in the docs and examples of functions
- `partitionSelect`, `diff`, `expm1`, `round`, `nthRoots`, `sign`,
- `rigthArithShift`, `setIsSubset`, `setSize`, and the docs about units.
- Thanks @tmtron.
-- Fix #2907: determinant of empty matrix should be 1.
-- Refactor index.d.ts by writing function declarations using a generic,
- reducing a lot of repetition (#2913). Thanks @brunoSnoww.
-
-
-
-- Implement broadcasting for the following functions and their corresponding
- operator: `add`, `dotDivide`, `dotMultiply`, `dotPow`, `gcd`, `lcm`, `mod`,
- `nthRoot`, `subtract`, `bitAnd`, `bitOr`, `bitXor`, `leftShift`,
- `rightArithShift`, `rightLogShift`, `and`, `or`, `xor`, `compare`,
- `compareText`, `equal`, `larger`, `largerEq`, `smaller`, `smallerEq`,
- `unequal`, `atan2` and `to` (#2895, #2753). Thanks @dvd101x.
-- Implement support for non-power-of-2 fft (#2900, #2577). Thanks @cyavictor88.
-- Fix #2888: update type definitions of function `unit` to allow creating a
- unit from a fraction or complex number.
-- Fix #2892: an error in the examples of the embedded help of function `sort`.
-- Fix #2891: functions `column` and `row` sometimes returning a scalar number.
-- Fix #2896: define the fourth argument of function `intersect` as optional
- in the TypeScript definitions. Thanks @wodndb.
-- Fix: quantileSeq not accepting a matrix as second argument `prob` (see #2902).
-- Fix broken examples in functions `to`, `distance`, `getMatrixDataType`,
- `subset`, and `max` (see #2902).
-
-
-
-- Add type definitions for function `rotationMatrix` (#2860).
- Thanks @brunoSnoww.
-- Add type signature for `lusolve(LUDecomposition, ...)` (#2864).
- Thanks @evanmiller.
-- Fix #2873: the rocket_trajectory_optimization.html example being partly
- broken. Thanks @dvd101x.
-- Fix #2871: coverage report broken (#2877). Thanks @bornova.
-- Fix #2883: update documentation for stat functions, describe missing syntax.
-- Fix #2884: fix examples in the embedded docs of function `pow` and some other
- functions.
-- Fix type definition of function `complex` for one numeric input (#2886),
- thanks @ariymarkowitz.
-- Fix type definitions of `map()` and `forEach()` (#2887), thanks @xiaohk.
-- Fix #2606: improve type definitions of `dotMultiply`, `dotPow` and
- `dotDivide` (#2890). Thanks @brunoSnoww.
-
-
-
-- Improve `simplify` rule matches in non-commutative contexts (#2841).
- Thanks @samueltlg.
-- Simplify: add rules and restructure tests for non-commutative contexts
- (#2847). Thanks @samueltlg.
-- Fix function `reshape` mutating the input in case of a matrix (see #2854).
-- Fix TypeScript types for `multiply()` with `number[]` and `number[][]`
- (#2852). Thanks @hfhchan.
-
-
-
-- Implemented more wildcards to describe rules for `simplify`, making it easier
- for example to describe unary minus (#1915). Thanks @thatcomputerguy0101.
-- Implemented functions `schur`, `sylvester`, and `lyap` (#2646).
- Thanks @egidioln.
-- Implemented function `polynomialRoot`, and use it in a benchmark (#2839).
- Thanks @gwhitney.
-- Fix #2825 partly: improve simplifying operations on constants in
- non-commutative contexts (#2827). Thanks @samueltlg.
-- Fix #2840: a bug in the docs and type definitions of `Node.traverse` and
- `Node.forEach`, they do return `void`.
-
-
-
-- Fix #2830: Prevent inserting zero values when creating a `SparseMatrix` from a
- `DenseMatrix` (#2836). Thanks @AlexandreAlvesDB.
-- Fix #2835: a regression in the type definitions of `FunctionNode`, introduced
- in `v11.3.2`. See #2733. Thanks @dsteve.
-
-
-
-- Fix #2809: code completion issues in some IDE's (#2812).
-- Fix #2818: throw an error when a function assignment has duplicate
- parameter names (#2819).
-- Update `decimal.js` to version `10.4.2`.
-
-
-
-- Allow creating new subclasses of `Node` in TypeScript (#2772).
- Note that this disables being able to narrow MathNodes by using the `.type`
- property. Use typeguards like `isOperatorNode(...)` instead (see #2810).
- Thanks @mattvague.
-- Fix #2793: `flatten()` cloning entries of array/Matrix (#2799).
-- Fix #2627: TypeScript definitions of `pinv` missing (#2804).
- Thanks @HanchaiN.
-- Update dependencies to `decimal.js@10.4.1`.
-
-
-
-- Implement function `isRelationalNode` (#2731). Thanks @isaacbyr.
-- Added missing types `'largerEq'` and `'or'` in `OperatorNodeMap` in the
- TypeScript definitions. Thanks @ajinkyac03.
-- Fixed typos in min func type defs (#2768). Thanks @mabdullahadeel.
-- Improved the TypeScript definitions for `pickRandom`. Thanks @mattvague.
-- Fixed documentation of unit `min` which means `minutes`, not `minim` (#2773).
- Thanks @jasonhornsby.
-
-
-
-- Add Unit constructor from value and pure (valueless) Unit (#2628).
- Thanks @costerwi
-- Fix #2144: `examples/advanced/custom_loading.js` was broken.
-- Fix JSON `replacer` function missing in the TypeScript definitions.
- Thanks @mattvague.
-- Update dependencies to `typed-function@4.1.0` and `decimal.js@10.4.0`.
-
-
-
-!!! BE CAREFUL: BREAKING CHANGES !!!
-
-Breaking changes:
-
-- Dropped official support for IE11.
-- Upgraded to `typed-function@3`, see [josdejong/typed-function/HISTORY.md](https://github.com/josdejong/typed-function/blob/develop/HISTORY.md#2022-05-12-version-300). Thanks @gwhitney. Most importantly:
- - Conversions now have preference over `any`.
- - The `this` variable is no longer bound to the typed function itself.
- - The properties `typed.types`, `typed.conversions`, and `typed.ignore`
- have been removed.
- - There are new static functions available like `typed.referTo`,
- `typed.referToSelf`, `typed.addTypes`, `typed.addConversions`.
-- Implement amended "Rule 2" for implicit multiplication (#2370, #2460):
- when having a division followed by an implicit multiplication, the division
- gets higher precedence over the implicit multiplication when (a) the
- numerator is a constant with optionally a prefix operator (`-`, `+`, `~`),
- and (b) the denominator is a constant. For example: formerly `-1 / 2 x` was
- interpreted as `-1 / (2 * x)` and now it is interpreted as `(-1 / 2) * x`.
- Thanks @gwhitney.
-- Drop elementwise matrix support for trigonometric functions, exp, log, gamma,
- square, sqrt, cube, and cbrt to prevent confusion with standard matrix
- functions (#2440, #2465). Instead, use `math.map(matrix, fn)`.
- Thanks @gwhitney.
-- Simplify: convert equivalent function calls into operators, for example,
- `add(2, x)` will now be simplified into `2 + x` (#2415, #2466).
- Thanks @gwhitney.
-- Removed the automatic conversion from `number` to `string` (#2482).
- Thanks @gwhitney.
-- Fix #2412: let function `diff` return an empty matrix when the input contains
- only one element (#2422).
-- Internal refactoring in the `simplifyCore` logic (#2490, #2484, #2459).
- The function `simplifyCore` will no longer (partially) merge constants, that
- behavior has been moved to `simplifyConstant`. The combination of
- `simplifyConstant` and `simplifyCore` is still close to the old behavior
- of `simplifyCore`, but there are some differences. To reproduce the same
- behavior as the old `simplifyCore`, you can use
- `math.simplify(expr, [math.simplifyCore, math.simplifyConstant])`.
- Thanks to the refactoring, `simplify` is more thorough in reducing constants.
- Thanks @gwhitney.
-- Disable support for splitting rest parameters in chained calculations
- (#2485, #2474). For example: `math.chain(3).max(4, 2).done()` will now throw
- an error rather than return `4`, because the rest parameter of
- `math.max(...number)` has been split between the contents of the chain and
- the arguments to the max call. Thanks @gwhitney.
-- Function `typeOf` now returns `function` (lowercase) for a function instead
- of `Function` (#2560). Thanks @gwhitney.
-
-Non-breaking changes:
-
-- Fix #2600: improve the TypeScript definitions of `simplify`.
- Thanks @laureen-m and @mattvague.
-- Fix #2607: improve type definition of `createUnit`. Thanks @egziko.
-- Fix #2608: clarify the docs on the need to configure a smaller `epsilon`
- when using BigNumbers.
-- Fix #2613: describe matrix methods `get` and `set` in the docs.
-- Fix link to `math.rationalize` in the docs (#2616). Thanks @nukisman.
-- Fix #2621: add TypeScript definitions for `count` (#2622). Thanks @Hansuku.
-- Improved TypeScript definitions of `multiply` (#2623). Thanks @Windrill.
-
-
-
-- Improve TypeScript definitions of `ParenthesisNode`. Thanks @mattvague.
-- Change the TypeScript definition of `MathNodeCommon['type']` into a less
- strict string, so it is possible to extend with new Node classes.
- Thanks @mattvague.
-- Improve TypeScript definitions of the `factory` function, thanks @mattvague.
-
-
-
-- Implementation of Fourier transform functions `fft` and `ifft` (#2540).
- Thanks @HanchaiN.
-- Fix TypeScript types not being listed in the exported fields (#2569).
- Thanks @mattvague.
-- Large improvements in TypeScript definitions for chained expressions (#2537).
- Thanks @mattvague.
-- Fix #2571: improve TypeScript definition of functions `clone` and `cloneDeep`
- (#2572). Thanks @mattvague.
-- Fix the first argument of `derivative` holding the expression not correctly
- being converted when using `.toTex()` (#2564). Thanks @mattvague.
-
-
-
-- Fix #2337: npm package containing examples and docs to solve security
- vulnerabilities being reported on the examples and their dependencies.
-- Fix core, construction, and some other functions missing in docs.
-- Drop official support for Node.js 12 which has reached its end of life.
-
-
-
-- Fix #2553: `@types/mocha` defined in `dependencies` instead of
- `devDependencies`, causing problems in projects that use a different version
- of this dependency. Thanks @Kolahzary.
-- Fix #2550: remove `examples/node_modules` folder from the npm package.
-- Fix #2528: improve contribution guidelines (#2548).
-- Document `SymbolNode.onUndefinedSymbol` and
- `FunctionNode.onUndefinedFunction`.
-
-
-
-- Fix #2526, #2529: improve TypeScript definitions of function `round`, `fix`,
- `floor`, `ceil`, and `nthRoot`, and improved the number only implementations
- of those functions (#2531, #2539). Thanks @simlaticak and @gwhitney.
-- Fix #2532: matrix index symbol `end` not working when used inside
- a sub-expression.
-- Fix #2524: In generating AUTHORS list, ignore a list of specific commits
- (e.g., to avoid spurious duplicates in list). (#2543)
-- Add type definitions of function `resolve` (#2536). Thanks @mattvague.
-
-
-
-- Implement #1563: function `pinv`, Moore–Penrose inverse (#2521).
- Thanks @HanchaiN.
-- Optimize function `det` for integers by switching to the Bareiss algorithm:
- no more round-off errors for integer input (#2516). Thanks @HanchaiN.
-- Implement #2463: allow negative integer powers of invertible square matrices
- (#2517). Thanks @HanchaiN.
-- Implement the `lgamma` function (defined as log(gamma(z))) for number and
- Complex types. Supersedes #320. (#2417). Thanks @yifanwww.
-- Fix #2523: update to the latest complex.js to improve `sin(z)` for small
- `im(z)` (#2525). Thanks @gwhitney.
-- Fix #2526: update TypeScript definition of `ceil` (#2531). Thanks @simlaticak
-- Change mocha reporter to 'dot' to avoid excessively long log files. (#2520)
-
-
-
-- Fix #2508: improve the precision of stirlingS2 (#2509). Thanks @gwhitney.
-- Fix #2514: implement optional argument `base` in the number implementation
- of function `log` (#2515). Thanks @gwhitney.
-- Improve the documentation on operator `;` (#2512). Thanks @gwhitney.
-
-
-
-- Fix #2499: different behavior for unit conversion "degC" and "K" (#2501).
- Also disables getting the sign for units with an offset, which is ambiguous.
- Thanks @gwhitney.
-- Fix #2503: fix an issue in `log()` for complex numbers in which the imaginary
- part is much larger in absolute value than the real part, fixed in
- `complex.js@2.1.0` (#2505), thanks @gwhitney, @infusion.
-- Fix #2493: unclear error message when an entity that is not a function
- is being called as a function (#2494). Thanks @gwhitney.
-- Some fixes in the docs on units (#2498). Thanks @dvd101x.
-- Add `forEach` example in embedded docs (#2507). Thanks @dvd101x.
-- Correct approx.deepEqual() to accept an epsilon argument giving the
- comparison tolerance. It was already being called this way, but was
- silently ignoring the tolerance. Thanks @yifanwww.
-
-
-
-- Improve TypeScript definitions for function `unit` (#2479).
- Thanks @SinanAkkoyun.
-- Add tests for type declarations (#2448). Thanks @samestep.
-- Further improvement to TypeScript definitions of `std` and `variance`
- (make dimension parameter optional, #2474). Thanks @NattapongSiri.
-- Next step (as per #2431) for full publication of "is" functions like
- `isMatrix` etc: Provide TypeScript definitions of "is" functions and
- make them type guards. (#2432). Thanks @ChristopherChudzicki.
-- Fix #2491: Multi line object expressions don't work with comments (#2492).
- Thanks @gwhitney.
-- Fix #2478: a bug in calculating the eigenvectors when dealing with complex
- numbers (#2496). Thanks @gwhitney.
-- Update project dependencies and devDependencies.
-
-
-
-- Fix #2461: make sure `simplifyCore` recurses over all binary nodes (#2462).
- Thanks @gwhitney.
-- Fix #2429: fix the TypeScript definitions of functions `std` and `variance`
- (#2455). Thanks @NattapongSiri.
-- Fix #1633: implement a `cumsum` function generating cumulative sums of a list
- of values or a matrix. (#1870). Thanks @hjonasson.
-- Upgrade to the latest version of `Fraction.js`, having more strict input,
- only accepting an integer numerator and denominator. See #2427.
-- Fix typo in documentation example for `format`. (#2468) Thanks @abranhe.
-- Write unit tests for all jsdoc examples. See #2452. Thanks @gwhitney.
-
-
-
-- Fix #1260: implement function `symbolicEqual` (#2424). Thanks @gwhitney.
-- Fix #2441, #2442: support passing a function as argument to functions created
- in the expression parser (#2443). Thanks @gwhitney.
-- Fix #2325: improve documentation of subset indices (#2446). Thanks @gwhitney.
-- Fix #2439: fix a bug in `complexEigs` in which real-valued norms were
- inadvertently being typed as complex numbers (#2445). Thanks @gwhitney.
-- Fix #2436: improve documentation and error message of function `map` (#2457).
- Thanks @gwhitney.
-
-
-
-- Implemented context options to control simplifications allowed in `simplify`,
- see #2399, #2391. Thanks @gwhitney.
-- Implemented function `leafCount` as a first simple measure of the complexity
- of an expression, see #2411, #2389. Thanks @gwhitney.
-- Fix #2413: improve `combinations` to return an integer result without rounding
- errors for larger values, see #2414. Thanks @gwhitney.
-- Fix #2385: function `rotate` missing in TypeScript definitions.
- Thanks @DIVYA-19.
-- Fix #2450: Add BigNumber to parameter type in `math.unit` and add TypeScript
- types for `Unit.simplify` and `Unit.units` (#2353). Thanks @joshhansen.
-- Fix #2383: detect infinite loops in `simplify` (#2405). Thanks @gwhitney.
-- Fix #1423: collect like factors and cancel like terms in sums (#2388).
- Thanks @gwhitney.
-
-
-
-- Improvements and fixes in function `simplify`, thanks @gwhitney:
- - Fix #2393: regression bug in `simplify('2-(x+1)')`.
- - Ad option `consoleDebug` to `simplify` to see what is going on.
-- Fix TypeScript definition of `ConfigOptions`, which was missing option
- `predictable`.
-
-
-
-- Implemented function `invmod`, see #2368, #1744. Thanks @thetazero.
-- Improvements and fixes in function `simplify`, thanks @gwhitney:
- - Fix #1179, #1290: improve collection of non-constant like terms (#2384).
- - Fix #2152: do not transform strings into numbers (#2372).
- - Fix #1913: implement support for array and object simplification (#2382).
-- Fix #2379: add embedded documentation for function `print`.
-- Remove broken example from the embedded documentation of function `forEach`.
-
-
-
-- Fix #2156: simplify expressions like `-1 / (-x)` to `1/x`. Thanks @ony3000.
-- Fix #2363: remove a redundant part of the regex to split a number.
-- Fix #2291: add support for fractions in function `intersect`.
- Thanks @thetazero.
-- Fix #2358: bug in `SparseMatrix` when replacing a subset of a matrix with
- a non-consecutive index. Thanks @Al-0.
-
-
-
-- Fix #1681: function `gamma` giving inaccurate complex results in some cases.
- Thanks @kmdrGroch.
-- Fixed a typo in an example, see #2366. Thanks @blackwindforce.
-
-
-
-!!! BE CAREFUL: BREAKING CHANGES IN THE TYPESCRIPT DEFINITIONS !!!
-
-- Improvements to the Typescript typings (commit fc5c202e).
- Thanks @joshhansen. First introduced in v9.5.1, but reverted because
- it contains breaking changes.
-
- Breaking changes: interface `MathNode` is now renamed to `MathNodeCommon`
- and the related interfaces are structured in a different way.
-
-- Fixed a typo in the TypeScript definition of toHTML. Thanks @TheToto.
-
-
-
-- Revert the improvements to the Typescript typings because they contain
- breaking changes. The improvements will be published in v10.0.0. See #2339.
-
-
-
-- Implemented support for calculations with percentage, see #2303.
- Thanks @rvramesh.
-- Fix #2319: make the API of `Parser.evaluate` consistent with `math.evaluate`:
- support a list with expressions as input.
-- Improved documentation of function `setCartesian`. Thanks @fieldfoxWim.
-
-
-
-- Fixed `ArrayNode.toTex()`: remove the row delimiter on the last row,
- see #2267. Thanks @davidtranhq.
-- Fix #2269: `intersect` not returning `null` for matrix input. Thanks @m93a.
-- Fix #2245: mathjs not working in IE11 anymore due to a missing polyfill for
- `Symbol`. The browser bundle now includes the necessary polyfills (it is
- larger now because of that, see also #2266). Thanks @m93a.
-- Update dependencies (`complex.js@2.0.15`, `decimal.js@10.3.1`)
-- Drop official support for node.js 10, which has reached end of life.
- See #2258.
-
-
-
-- Implemented iterative eigenvalue finder for `eigs`, making it much more
- robust. See #2179, #2237. Thanks @m93a.
-- Improved TypeScript definitions of function `parse`. Thanks @OpportunityLiu.
-
-
-
-- Implemented support to use objects with a `Map` interface as scope,
- see #2143, #2166. Thanks @jhugman.
-- Extend `eigs` to support general complex matrices, see #1741. Thanks @m93a.
-- DenseMatrix and SparseMatrix are now iterable, see #1184. Thanks @m93a.
-- Implemented utility functions `matrixFromRows`, `matrixFromColumns`, and
- `matrixFromFunction`, see #2155, #2153. Thanks @m93a.
-- Added TypeScript definitions to the project, making it redundant to install
- `@types/mathjs`, and making it easier to improve the definitions. See #2187,
- #2192. Thanks @CatsMiaow.
-- Upgraded dependencies
- - `complex.js@2.0.13` (fixing #2211). Thanks @infusion
- - `fraction.js@4.1.0` (`pow` now supporting rational exponents).
-- Fix #2174: function `pickRandom` having no name. Thanks @HK-SHAO.
-- Fix #2019: VSCode auto import keeps adding import { null } from 'mathjs'.
-- Fix #2185: Fix TypeScript definition of unit division, which can also return
- a number.
-- Fix #2123: add type definitions for functions `row` and `column`.
-- Fix some files not exposed in the package, see #2213. Thanks @javiermarinros.
-
-
-
-- Fix #2133: strongly improved the performance of `isPrime`, see #2139.
- Thanks @Yaffle.
-- Fix #2150: give a clear error "Error: Undefined function ..." instead when
- evaluating a non-existing function.
-- Fix #660: expose internal functions `FunctionNode.onUndefinedFunction(name)`
- and `SymbolNode.onUndefinedSymbol(name)`, allowing to override the behavior.
- By default, an Error is thrown.
-
-
-
-- Implemented support for parsing non decimal numbers with radix point,
- see #2122, #2121. Thanks @clnhlzmn.
-- Fix #2128: typo in docs of `luSolveAll` and `usolveAll`.
-
-
-
-- Implemented function `count` to count the total elements in a matrix,
- see #2085. Thanks @Josef37.
-- Fix #2096: cleanup old reference to external dependency `crypto`.
-- Some refactoring in the code to remove duplications, see #2093.
- Thanks @Josef37.
-
-
-
-- Extended function `reshape` with support for a wildcard `-1` to automatically
- calculate the remaining size, like `reshape([1, 2, 3, 4, 5, 6], [-1, 2])`
- which will output `[[0, 1], [2, 3], [4, 5]]`. See #2075. Thanks @Josef37.
-- Fix #2087: function `simplify` ignores second argument of `log`, for example
- in `simplify('log(e, 9)')` . Thanks @quentintruong.
-
-
-
-- Improved support for bin, hex, and oct literals. See #1996. Thanks @clnhlzmn.
- - **Breaking change**: parse literals with prefixes `0b`, `0c`, and `0x` are
- now unsigned by default. To parse them as signed, you have to specify a
- suffix specifying the word size such as `i16` or `i32`.
- - Function `format` now supports more notations: `bin`, 'hex', and `oct`,
- for example `format(255, {notation: "hex"})`.
- - The functions `format`, `bin`, `hex`, `oct` now allow specifying a wordSize,
- like `bin(10, 32)` and `format(10, {notation: "bin", wordSize: 32})`.
- - BigNumber support for the bin, hex, and oct literals.
-- Extended and improved the example rocket_trajectory_optimization.html.
- Thanks @Josef37.
-
-
-
-- Improved the performance of parsing and evaluating units a lot, see #2065.
- Thanks @flaviut.
-- Upgraded dependency `fraction.js` to `v4.0.13`.
-- Moved continuous integration testing from Travis CI to Github Workflow,
- see #2024, #2041. Thanks @harrysarson.
-
-
-
-- Implemented units `kilogramforce` (`kgf`). Thanks @rnd-debug.
-- Fix #2026: Implement a new option `fractionsLimit` for function `simplify`,
- defaulting to `Infinity`.
-- Improved the documentation of function `clone`. Thanks @redbar0n.
-
-
-
-- Fix #1979: missing "subset" dependency when using "mathjs/number" entry point.
-- Fix #2022: update pretty printing with MathJax example to the latest version
- of MathJax. Thanks @pkra.
-
-
-
-!!! BE CAREFUL: BREAKING CHANGES !!!
-
-- You can now use mathjs directly in node.js using ES modules without need for
- a transpiler (see #1928, #1941, #1962).
- Automatically loading either commonjs code or ES modules code is improved.
- All generated code is moved under `/lib`: the browser bundle is moved from
- `/dist` to `/lib/browser`, ES module files are moved to `/lib/esm`,
- and commonjs files are moved to `/lib/cjs`. Thanks @GreenImp.
-- Non-minified bundle `dist/math.js` is no longer provided. Either use the
- minified bundle, or create a bundle yourself.
-- Replaced random library `seed-random` with `seedrandom`, see #1955.
- Thanks @poppinlp.
-- Breaking changes in `pickRandom`, see #1990, #1976.
- - Will no longer return the input matrix when the given number is greater
- than the length of the provided possibles. Instead, the function always
- returns results with the requested number of picks.
- - Will now return a `Matrix` as output when input was a `Matrix`.
- - Introduced a new syntax:
-
- ```
- math.pickRandom(array, { weights, number, elementWise })
- ```
-
- - Introduced a new option `elementWise`, which is `true` by default.
- When setting `elementWise` to false, an array containing arrays will return
- random pick of arrays instead of the elements inside of the nested arrays.
-
-
-
-- Implemented function `rotate(w, theta)`. See #1992, #1160. Thanks @rnd-debug.
-- Implemented support for custom characters in Units via `Unit.isValidAlpha`.
- See #1663, #2000. Thanks @rnd-debug.
-
-
-
-- Function `pickRandom` now allows randomly picking elements from matrices
- with 2 or more dimensions instead of only from a vector, see #1974.
- Thanks @KonradLinkowski.
-
-
-
-- Implemented support for passing a precision in functions `ceil`, `floor`,
- and `fix`, similar to `round`, see #1967, #1901. Thanks @rnd-debug.
-- Implemented function `rotationMatrix`, see #1160, #1984. Thanks @rnd-debug.
-- Implement a clear error message when using `sqrtm` with a matrix having
- more than two dimensions. Thanks @KonradLinkowski.
-- Update dependency `decimal.js` to `10.2.1`.
-
-
-
-- Implemented functions `usolveAll` and `lsolveAll`, see #1916. Thanks @m93a.
-- Implemented support for units in functions `std` and `variance`, see #1950.
- Thanks @rnd-debug.
-- Implemented support for binary, octal, and hexadecimal notation in the
- expression parser, and implemented functions `bin`, `oct`, and `hex` for
- formatting. Thanks @clnhlzmn.
-- Fix #1964: inconsistent calculation of negative dividend modulo for
- `BigNumber` and `Fraction`. Thanks @ovk.
-
-
-
-- Implemented new function `diff`, see #1634, #1920. Thanks @Veeloxfire.
-- Implemented support for norm 2 for matrices in function `norm`.
- Thanks @rnd-debug.
-
-
-
-- Implement support for recursion (self-referencing) of typed-functions,
- new in `typed-function@2.0.0`. This fixes #1885: functions which where
- extended with a new data type did not always work. Thanks @nickewing.
-- Fix #1899: documentation on expression trees still using old namespace
- `math.expression.node.*` instead of `math.*`.
-
-
-
-- Fix #1882: have `DenseMatrix.resize` and `SparseMatrix.resize` accept
- `DenseMatrix` and `SparseMatrix` as inputs too, not only `Array`.
-- Fix functions `sum`, `prod`, `min`, and `max` not throwing a conversion error
- when passing a single string, like `sum("abc")`.
-
-
-
-- Fix #1844: clarify the documentation of function `eigs`. Thanks @Lazersmoke.
-- Fix #1855: Fix error in the documentation for `math.nthRoots(x)`.
-- Fix #1856: make the library robust against Object prototype pollution.
-
-
-
-Breaking changes:
-
-- Improvements in calculation of the `dot` product of complex values.
- The first argument is now conjugated. See #1761. Thanks @m93a.
-- Dropped official support for Node.js v8 which has reached end of life.
-- Removed all deprecation warnings introduced in v6.
- To upgrade smoothly from v5 to v7 or higher, upgrade to v6 first
- and resolve all deprecation warnings.
-
-
-
-- Fix #1834: value `Infinity` cannot be serialized and deserialized.
- This is solved now with a new `math.replacer` function used as
- `JSON.stringify(value, math.replacer)`.
-- Fix #1842: value `Infinity` not turned into the latex symbol `\\infty`.
-
-
-
-- Fix #1813: bug in engineering notation for numbers of function `format`,
- sometimes resulting in needless trailing zeros.
-- Fix #1808: methods `.toNumber()` and `.toNumeric()` not working on a
- unitless unit.
-- Fix #1645: not being able to use named operators `mod`, `and`, `not`, `or`,
- `xor`, `to`, `in` as object keys. Thanks @Veeloxfire.
-- Fix `eigs` not using `config.epsilon`.
-
-
-
-- Fix #1789: Function `eigs` not calculating with BigNumber precision
- when input contains BigNumbers.
-- Run the build script during npm `prepare`, so you can use the library
- directly when installing directly from git. See #1751. Thanks @cinderblock.
-
-
-
-- Implemented function `eigs`, see #1705, #542#1175. Thanks @arkajitmandal.
-- Fixed #1727: validate matrix size when creating a `DenseMatrix` using
- `fromJSON`.
-- Fixed `DenseMatrix.map` copying the size and datatype from the original
- matrix instead of checking the returned dimensions and type of the callback.
-- Add a caret to dependencies (like) `^1.2.3`) to allow downstream updates
- without having to await a new release of mathjs.
-
-
-
-- Fixed `IndexNode` using a hardcoded, one-based implementation of `index`,
- making it impossible to instantiate a zero-based version of the expression
- parser. See #782.
-
-
-
-- Fixed #1669: function 'qr' threw an error if the pivot was zero,
- thanks @kevinkelleher12 and @harrysarson.
-- Resolves #942: remove misleading assert in 'qr'. Thanks @harrysarson.
-- Work around a bug in complex.js where `sign(0)` returns complex NaN.
- Thanks @harrysarson.
-
-
-
-- Fixed #1640: function `mean` not working for units. Thanks @clintonc.
-- Fixed #1639: function `min` listed twice in the "See also" section of the
- embedded docs of function `std`.
-- Improved performance of `isPrime`, see #1641. Thanks @arguiot.
-
-
-
-- Fixed methods `map` and `clone` not copying the `dotNotation` property of
- `IndexNode`. Thanks @rianmcguire.
-- Fixed a typo in the documentation of `toHTML`. Thanks @maytanthegeek.
-- Fixed #1615: error in the docs of `isNumeric`.
-- Fixed #1628: Cannot call methods on empty strings or numbers with value `0`.
-
-
-
-- Improved performance of `combinationsWithRep`. Thanks @waseemyusuf.
-- Add unit aliases `bit` and `byte`.
-- Fix docs referring to `bit` and `byte` instead of `bits` and `bytes`.
-- Updated dependency `typed-function@1.1.1`.
-
-
-
-- Add `unpkg` and `jsdelivr` fields in package.json pointing to UMD build.
- Thanks @tmcw.
-- Fix #1550: nested user defined function not receiving variables of an
- outer user defined function.
-
-
-
-1. Full support for **ES modules**. Support for tree-shaking out of the box.
-
- Load all functions:
-
- ```js
- import * as math from 'mathjs'
- ```
-
- Use a few functions:
-
- ```js
- import { add, multiply } from 'mathjs'
- ```
-
- Load all functions with custom configuration:
-
- ```js
- import { create, all } from 'mathjs'
- const config = { number: 'BigNumber' }
- const math = create(all, config)
- ```
-
- Load a few functions with custom configuration:
-
- ```js
- import { create, addDependencies, multiplyDependencies } from 'mathjs'
- const config = { number: 'BigNumber' }
- const { add, multiply } = create({
- addDependencies,
- multiplyDependencies
- }, config)
- ```
-
-2. Support for **lightweight, number-only** implementations of all functions:
-
- ```
- import { add, multiply } from 'mathjs/number'
- ```
-
-3. New **dependency injection** solution used under the hood.
-
-
-
-- Node 6 is no longer supported.
-
-- Functions `config` and `import` are not available anymore in the global
- context:
-
- ```js
- // v5
- import * as mathjs from 'mathjs'
- mathjs.config(...) // error in v6.0.0
- mathjs.import(...) // error in v6.0.0
- ```
-
- Instead, create your own mathjs instance and pass config and imports
- there:
-
- ```js
- // v6
- import { create, all } from 'mathjs'
- const config = { number: 'BigNumber' }
- const mathjs = create(all, config)
- mathjs.import(...)
- ```
-
-- Renamed function `typeof` to `typeOf`, `var` to `variance`,
- and `eval` to `evaluate`. (the old function names are reserved keywords
- which can not be used as a variable name).
-- Deprecated the `Matrix.storage` function. Use `math.matrix` instead to create
- a matrix.
-- Deprecated function `math.expression.parse`, use `math.parse` instead.
- Was used before for example to customize supported characters by replacing
- `math.parse.isAlpha`.
-- Moved all classes like `math.type.Unit` and `math.expression.Parser` to
- `math.Unit` and `math.Parser` respectively.
-- Fixed #1428: transform iterating over replaced nodes. New behavior
- is that it stops iterating when a node is replaced.
-- Dropped support for renaming factory functions when importing them.
-- Dropped fake BigNumber support of function `erf`.
-- Removed all index.js files used to load specific functions instead of all, like:
-
- ```
- // v5
- // ... set up empty instance of mathjs, then load a set of functions:
- math.import(require('mathjs/lib/function/arithmetic'))
- ```
-
- Individual functions are now loaded simply like:
-
- ```js
- // v6
- import { add, multiply } from 'mathjs'
- ```
-
- To set a specific configuration on the functions:
-
- ```js
- // v6
- import { create, addDependencies, multiplyDependencies } from 'mathjs'
- const config = { number: 'BigNumber' }
- const math = create({ addDependencies, multiplyDependencies }, config)
- ```
-
- See example `advanced/custom_loading.js`.
-
-- Updated the values of all physical units to their latest official values.
- See #1529. Thanks @ericman314.
-
-
-
-- Implemented units `t`, `tonne`, `bel`, `decibel`, `dB`, and prefixes
- for `candela`. Thanks @mcvladthegoat.
-- Fixed `epsilon` setting being applied globally to Complex numbers.
-- Fix `math.simplify('add(2, 3)')` throwing an error.
-- Fix #1530: number formatting first applied `lowerExp` and `upperExp`
- and after that rounded the value instead of the other way around.
-- Fix #1473: remove `'use strict'` in every file, not needed anymore.
-
-
-
-- Fix #1515, #1516, #1517: broken package due to a naming conflict in
- the build folder of a util file `typeOf.js` and `typeof.js`.
- Solved by properly cleaning all build folders before building.
-
-
-
-- Fix #1512: format using notation `engineering` can give wrong results
- when the value has less significant digits than the number of digits in
- the output.
-
-
-
-- Fix `lib/header.js` not having filled in date and version. Thanks @kevjin.
-- Upgraded dependency `decimal.js@10.2.0`, fixing an issue on node.js 12.
-
-
-
-- Implemented functions `row` and `column` (see #1413). Thanks @SzechuanSage.
-- Fixed #1459: `engineering` notation of function `format` not available
- for `BigNumber`.
-- Fixed #1465: `node.toHTML()` not correct for unary operators like
- `factorial`.
-
-
-
-- Implemented new function `apply`. Thanks @bnlcas.
-- Implemented passing an optional `dimension` argument to `std` and `var`.
- Thanks @bnlcas.
-
-
-
-- Implemented support for `pow()` in `derivative`. Thanks @sam-19.
-- Gracefully handle round-off errors in fix, ceil, floor, and range
- (Fixes #1429, see also #1434, #1432). Thanks @ericman314.
-
-
-
-- Fixed #1401: methods `map` and `forEach` of `SparseMatrix` not working
- correctly when indexes are unordered.
-- Fixed #1404: inconsistent rounding of negative numbers.
-- Upgrade tiny-emitter to v2.1.0 (#1397).
-
-
-
-- Fixed `math.format` not working for BigNumbers with a precision above
- 1025 digits (see #1385). Thanks @ericman314.
-- Fixed incorrect LaTeX output of `RelationalNode`. Thanks @rianmcguire.
-- Fixed a bug the methods `map`, `forEach`, `traverse`, and `transform`
- of `FunctionNode`.
-
-
-
-- Extended sum.js to accept a dimension input to calculate the sum over a
- specific axis. Thanks @bnlcas.
-- Fix #1328: objects can't be written multi-line. Thanks @GHolk.
-- Remove side effects caused by `Unit.format` and `Unit.toString`,
- making changes to the unit on execution. Thanks @ericman314.
-
-
-
-- Fixed #1293: non-unicode characters in `escape-latex` giving issues in some
- specific cases. Thanks @dangmai.
-- Fixed incorrect LaTeX output of function `bitNot`, see #1299. Thanks @FSMaxB.
-- Fixed #1304: function `pow` not supporting inputs `pow(Unit, BigNumber)`.
-- Upgraded dependencies (`escape-latex@1.2.0`)
-
-
-
-- Implemented support for chained conditionals like `10 < x <= 50`.
- Thanks @ericman314.
-- Add an example showing a proof of concept of using `BigInt` in mathjs.
-- Fixed #1269: Bugfix for BigNumber divided by unit. Thanks @ericman314.
-- Fixed #1240: allow units having just a value and no unit.
- Thanks @ericman314.
-
-
-
-- Fixed a typo in the docs of `parse`. Thanks @mathiasvr.
-- Fixed #1222: a typo in the docs of `subset`.
-- Fixed #1236: `quantileSeq` has inconsistent return.
-- Fixed #1237: norm sometimes returning a complex number instead of
- number.
-- Upgraded dependencies (`fraction.js@4.0.9`)
-- Upgraded devDependencies (`babel@7`, `karma-webpack@3.0.4`,
- `nyc@13.0.1`, `standard@12.0.0`, `uglify-js@3.4.9`, `webpack@4.17.2`)
-
-
-
-- Function `isNumeric` now recognizes more types.
-- Fixed #1214: functions `sqrt`, `max`, `min`, `var`, `std`, `mode`, `mad`,
- `median`, and `partitionSelect` not neatly handling `NaN` inputs. In some
- cases (`median`, `mad`, and `partitionSelect`) this resulted in an infinite
- loop.
-- Upgraded dependencies (`escape-latex@1.1.1`)
-- Upgraded devDependencies (`webpack@4.17.0`)
-
-
-
-- Implemented support for strings enclosed in single quotes.
- Thanks @jean-emmanuel.
-- Implemented function `getMatrixDataType`. Thanks @JasonShin.
-- Implemented new `options` argument in `simplify`. Thanks @paulobuchsbaum.
-- Bug fixes in `rationalize`, see #1173. Thanks @paulobuchsbaum.
-
-
-
-- Strongly improved the performance of functions `factorial` for numbers.
- This improves performance of functions `gamma`, `permutation`, and
- `combination` too. See #1170. Thanks @honeybar.
-- Strongly improved the performance of function `reshape`, thanks to a
- friend of @honeybar.
-
-
-
-- Fixed many functions (for example `add` and `subtract`) not working
- with matrices having a `datatype` defined.
-- Fixed #1147: bug in `format` with `engineering` notation in outputting
- the correct number of significant figures. Thanks @ericman314.
-- Fixed #1162: transform functions not being cleaned up when overriding
- it by importing a factory function with the same name.
-- Fixed broken links in the documentation. Thanks @stropitek.
-- Refactored the code of `parse` into a functional approach.
- Thanks @harrysarson.
-- Changed `decimal.js` import to ES6. Thanks @weinshel.
-
-
-
-!!! BE CAREFUL: BREAKING CHANGES !!!
-
-- Implemented complex conjugate transpose `math.ctranspose`. See #1097.
- Thanks @jackschmidt.
-- Changed the behavior of `A'` (transpose) in the expression parser to
- calculate the complex conjugate transpose. See #1097. Thanks @jackschmidt.
-- Added support for `complex({abs: 1, arg: 1})`, and improved the docs on
- complex numbers. Thanks @ssaket.
-- Renamed `eye` to `identity`, see #1054.
-- Math.js code can now contain ES6. The ES6 source code is moved from `lib`
- to `src`, and `lib` now contains the compiled ES5 code.
-- Upgraded dependencies:
- - `decimal.js` from `9.0.1` to `10.0.1`
- - Upgraded dev dependencies
-- Changed code style to , run linter on `npm test`.
- See #1110.
-- Dropped support for bower. Use npm or an other package manages instead.
-- Dropped support for (non-primitive) instances of `Number`, `Boolean`, and
- `String` from functions `clone` and `typeof`.
-- Dropped official support for IE9 (probably still works, but it's not tested).
-- Fixed #851: More consistent behavior of sqrt, nthRoot, and pow.
- Thanks @dakotablair.
-- Fixed #1103: Calling `toTex` on node that contains `derivative` causing
- an exception. Thanks @joelhoover.
-
-
-
-- Drastically improved the performance of `det`. Thanks @ericman314.
-- Fixed #1065, #1121: Fixed wrong documentation of function
- `compareNatural` and clarified the behavior for strings.
-- Fixed #1122 a regression in function `inv` (since `v4.4.1`).
- Thanks @ericman314.
-
-
-
-- Implemented matrix exponential `math.expm`. Thanks @ericman314.
-- Fixed #1101: math.js bundle not working when loading in a WebWorker.
-- Upgraded dependencies
- - `complex.js` from `v2.0.2` to `v2.0.10`.
- - `fraction.js` from `v4.0.4` to `v4.0.8`.
-- Upgraded devDependencies (`mocha`, `uglify-js`, `webpack`).
-
-
-
-- Fixed calculating the Frobenius norm of complex matrices correctly,
- see #1098. Thanks @jackschmidt.
-- Fixed #1076: cannot use mathjs in React VR by updating to
- `escape-latex@1.0.3`.
-
-
-
-- Fixed #1082: implemented support for unit plurals `decades`, `centuries`,
- and `millennia`.
-- Fixed #1083: units `decade` and `watt` having a wrong name when stringifying.
- Thanks @ericman314.
-
-
-
-- Extended function `math.print` with support for arrays and matrices.
- Thanks @jean-emmanuel.
-- Fixed #1077: Serialization/deserialization to JSON with reviver not being
- supported by nodes.
-- Fixed #1016: Extended `math.typeof` with support for `ResultSet` and nodes
- like `SymbolNode`.
-- Fixed #1072: Added support for long and short prefixes for the unit `bar`
- (i.e. `millibar` and `mbar`).
-
-
-
-!!! BE CAREFUL: BREAKING CHANGES !!!
-
-Breaking changes (see also #682):
-
-- **New expression compiler**
-
- The compiler of the expression parser is replaced with one that doesn't use
- `eval` internally. See #1019. This means:
-
- - a slightly improved performance on most browsers.
- - less risk of security exploits.
- - the code of the new compiler is easier to understand, maintain, and debug.
-
- Breaking change here: When using custom nodes in the expression parser,
- the syntax of `_compile` has changed. This is an undocumented feature though.
-
-- **Parsed expressions**
-
- - The class `ConstantNode` is changed such that it just holds a value
- instead of holding a stringified value and it's type.
- `ConstantNode(valueStr, valueType`) is now `ConstantNode(value)`
- Stringification uses `math.format`, which may result in differently
- formatted numeric output.
-
- - The constants `true`, `false`, `null`, `undefined`, `NaN`, `Infinity`,
- and `uninitialized` are now parsed as ConstantNodes instead of
- SymbolNodes in the expression parser. See #833.
-
-- **Implicit multiplication**
-
- - Changed the behavior of implicit multiplication to have higher
- precedence than explicit multiplication and division, except in
- a number of specific cases. This gives a more natural behavior
- for implicit multiplications. For example `24h / 6h` now returns `4`,
- whilst `1/2 kg` evaluates to `0.5 kg`. Thanks @ericman314. See: #792.
- Detailed documentation: .
-
- - Immediately invoking a function returned by a function like `partialAdd(2)(3)`
- is no longer supported, instead these expressions are evaluated as
- an implicit multiplication `partialAdd(2) * (3)`. See #1035.
-
-- **String formatting**
-
- - In function `math.format`, the options `{exponential: {lower: number, upper: number}}`
- (where `lower` and `upper` are values) are replaced with `{lowerExp: number, upperExp: number}`
- (where `lowerExp` and `upperExp` are exponents). See #676. For example:
-
- ```js
- math.format(2000, {exponential: {lower: 1e-2, upper: 1e2}})
- ```
-
- is now:
-
- ```js
- math.format(2000, {lowerExp: -2, upperExp: 2})
- ```
-
- - In function `math.format`, the option `notation: 'fixed'` no longer rounds to
- zero digits when no precision is specified: it leaves the digits as is.
- See #676.
-
-- **String comparison**
-
- Changed the behavior of relational functions (`compare`, `equal`,
- `equalScalar`, `larger`, `largerEq`, `smaller`, `smallerEq`, `unequal`)
- to compare strings by their numeric value they contain instead of
- alphabetically. This also impacts functions `deepEqual`, `sort`, `min`,
- `max`, `median`, and `partitionSelect`. Use `compareNatural` if you
- need to sort an array with text. See #680.
-
-- **Angle units**
-
- Changed `rad`, `deg`, and `grad` to have short prefixes,
- and introduced `radian`, `degree`, and `gradian` and their plurals
- having long prefixes. See #749.
-
-- **Null**
-
- - `null` is no longer implicitly casted to a number `0`, so input like
- `math.add(2, null)` is no longer supported. See #830, #353.
-
- - Dropped constant `uninitialized`, which was used to initialize
- leave new entries undefined when resizing a matrix is removed.
- Use `undefined` instead to indicate entries that are not explicitly
- set. See #833.
-
-- **New typed-function library**
-
- - The `typed-function` library used to check the input types
- of functions is completely rewritten and doesn't use `eval` under
- the hood anymore. This means a reduced security risk, and easier
- to debug code. The API is the same, but error messages may differ
- a bit. Performance is comparable but may differ in specific
- use cases and browsers.
-
-Non breaking changes:
-
-- Thanks to the new expression compiler and `typed-function` implementation,
- mathjs doesn't use JavaScript's `eval` anymore under the hood.
- This allows using mathjs in environments with security restrictions.
- See #401.
-- Implemented additional methods `isUnary()` and `isBinary()` on
- `OperatorNode`. See #1025.
-- Improved error messages for statistical functions.
-- Upgraded devDependencies.
-- Fixed #1014: `derivative` silently dropping additional arguments
- from operator nodes with more than two arguments.
-
-
-
-- Upgraded to `typed-function@0.10.7` (bug-fix release).
-- Fixed option `implicit` not being copied from an `OperatorNode`
- when applying function `map`. Thanks @HarrySarson.
-- Fixed #995: spaces and underscores not property being escaped
- in `toTex()`. Thanks @FSMaxB.
-
-
-
-- Implement support for 3 or more arguments for operators `+` and `*` in
- `derivative`. Thanks @HarrySarson. See #1002.
-- Fixed `simplify` evalution of `simplify` of functions with more than two
- arguments wrongly: `simplify('f(x, y, z)') evaluated to`f(f(x, y), z)`
- instead of `f(x, y, z)`. Thanks @joelhoover.
-- Fixed `simplify` throwing an error in some cases when simplifying unknown
- functions, for example `simplify('f(4)')`. Thanks @joelhoover.
-- Fixed #1013: `simplify` wrongly simplifing some expressions containing unary
- minus, like `0 - -x`. Thanks @joelhoover.
-- Fixed an error in an example in the documentation of `xor`. Thanks @denisx.
-
-
-
-- Extended functions `distance` and `intersect` with support for BigNumbers.
- Thanks @ovk.
-- Improvements in function `simplify`: added a rule that allows combining
- of like terms in embedded quantities. Thanks @joelhoover.
-
-
-
-- Implemented function `rationalize`. Thanks @paulobuchsbaum.
-- Upgraded dependencies:
-
- ```
- decimal.js 7.2.3 → 9.0.1 (no breaking changes affecting mathjs)
- fraction.js 4.0.2 → 4.0.4
- tiny-emitter 2.0.0 → 2.0.2
- ```
-
-- Upgraded dev dependencies.
-- Fixed #975: a wrong example in the docs of lusolve.
-- Fixed #983: `pickRandom` returning an array instead of single value
- when input was an array with just one value. Clarified docs.
-- Fixed #969: preven issues with yarn autoclean by renaming an
- interally used folder "docs" to "embeddedDocs".
-
-
-
-- Improved `simplify` for nested exponentiations. Thanks @IvanVergiliev.
-- Fixed a security issue in `typed-function` allowing arbitrary code execution
- in the JavaScript engine by creating a typed function with JavaScript code
- in the name. Thanks Masato Kinugawa.
-- Fixed a security issue where forbidden properties like constructor could be
- replaced by using unicode characters when creating an object. No known exploit,
- but could possibly allow arbitrary code execution. Thanks Masato Kinugawa.
-
-
-
-- Fixed #948, #949: function `simplify` returning wrong results or
- running into an infinite recursive loop. Thanks @ericman314.
-- Fixed many small issues in the embedded docs. Thanks @Schnark.
-
-
-
-- Fixed #934: Wrong simplification of unary minus. Thanks @firepick1.
-- Fixed #933: function `simplify` reordering operations. Thanks @firepick1.
-- Fixed #930: function `isNaN` returning wrong result for complex
- numbers having just one of their parts (re/im) being `NaN`.
-- Fixed #929: `FibonacciHeap.isEmpty` returning wrong result.
-
-
-
-- For security reasons, type checking is now done in a more strict
- way using functions like `isComplex(x)` instead of duck type checking
- like `x && x.isComplex === true`.
-- Fixed #915: No access to property "name".
-- Fixed #901: Simplify units when calling `unit.toNumeric()`.
- Thanks @AlexanderBeyn.
-- Fixed `toString` of a parsed expression tree containing an
- immediately invoked function assignment not being wrapped in
- parenthesis (for example `(f(x) = x^2)(4)`).
-
-
-
-- Significant performance improvements in `math.simplify`.
- Thanks @firepick1.
-- Improved API for `math.simplify`, optionally pass a scope with
- variables which are resolved, see #907. Thanks @firepick1.
-- Fixed #912: math.js didn't work on IE10 anymore (regression
- since 3.15.0).
-
-
-
-- Added support for the dollar character `$` in symbol names (see #895).
-- Allow objects with prototypes as scope again in the expression parser,
- this was disabled for security reasons some time ago. See #888, #899.
- Thanks @ThomasBrierley.
-- Fixed #846: Issues in the functions `map`, `forEach`, and `filter`
- when used in the expression parser:
- - Not being able to use a function assignment as inline expression
- for the callback function.
- - Not being able to pass an inline expression as callback for `map`
- and `forEach`.
- - Index and original array/matrix not passed in `map` and `filter`.
-
-
-
-- Disabled function `chain` inside the expression parser for security
- reasons (it's not needed there anyway).
-- Fixed #856: function `subset` not returning non-primitive scalars
- from Arrays correctly. (like `math.eval('arr[1]', {arr: [math.bignumber(2)]})`.
-- Fixed #861: physical constants not available in the expression parser.
-
-
-
-- Command line application can now evaluate inline expressions
- like `mathjs 1+2`. Thanks @slavaGanzin.
-- Function `derivative` now supports `abs`. Thanks @tetslee.
-- Function `simplify` now supports BigNumbers. Thanks @tetslee.
-- Prevent against endless loops in `simplify`. Thanks @tetslee.
-- Fixed #813: function `simplify` converting small numbers to inexact
- Fractions. Thanks @tetslee.
-- Fixed #838: Function `simplify` now supports constants like `e`.
- Thanks @tetslee.
-
-
-
-- More security measures in the expression parser.
- WARNING: the behavior of the expression parser is now more strict,
- some undocumented features may not work any longer.
- - Accessing and assigning properties is now only allowed on plain
- objects, not on classes, arrays, and functions anymore.
- - Accessing methods is restricted to a set of known, safe methods.
-
-
-
-- Implemented method Unit.toSI() to convert a unit to base SI units.
- Thanks @ericman314.
-- Fixed #821, #822: security vulnerabilities in the expression parser.
- Thanks @comex and @xfix.
-
-
-
-- Fixed `xgcd` for negative values. Thanks @litmit.
-- Fixed #807: function transform of existing functions not being removed when
- overriding such a function.
-
-
-
-- Implemented function `reshape`. Thanks @patgrasso and @ericman314.
-- Implemented configuration option `seedRandom` for deterministic random
- numbers. Thanks @morsecodist.
-- Small fixes in the docs. Thanks @HarrySarson.
-- Dropped support for component package manager (which became deprecated about
- one and a half year ago).
-
-
-
-- Fixed #789: Math.js not supporting conversion of `string` to `BigNumber`,
- `Fraction`, or `Complex` number.
-- Fixed #790: Expression parser did not pass function arguments of enclosing
- functions via `scope` to functions having `rawArgs = true`.
-- Small fixes in the docs. Thanks @HarrySarson.
-
-
-
-- Implemented support for algebra: powerful new functions `simplify` and
- `derivative`. Thanks @ericman314, @tetslee, and @BigFav.
-- Implemented Kronecker Product `kron`. Thanks @adamisntdead.
-- Reverted `FunctionNode` not accepting a string as function name anymore.
-- Fixed #765: `FunctionAssignmentNode.toString()` returning a string
- incompatible with the function assignment syntax.
-
-
-
-- Implemented function `mad` (median absolute deviation). Thanks @ruhleder.
-- Fixed #762: expression parser failing to invoke a function returned
- by a function.
-
-
-
-- Functions `add` and `multiply` now accept more than two arguments. See #739.
-- `OperatorNode` now supports more than two arguments. See #739. Thanks @FSMaxB.
-- Implemented a method `Node.cloneDeep` for the expression nodes. See #745.
-- Fixed a bug in `Node.clone()` not cloning implicit multiplication correctly.
- Thanks @FSMaxB.
-- Fixed #737: Improved algorithm determining the best prefix for units.
- It will now retain the original unit like `1 cm` when close enough,
- instead of returning `10 mm`. Thanks @ericman314.
-- Fixed #732: Allow letter-like unicode characters like Ohm `\u2126`.
-- Fixed #749: Units `rad`, `deg`, and `grad` can now have prefixes like `millirad`.
-- Some fixes in the docs and comments of examples. Thanks @HarrySarson.
-
-
-
-- Implemented method `Node.equals(other)` for all nodes of the expression parser.
-- Implemented BigNumber support in function `arg()`.
-- Command Line Interface loads faster.
-- Implicit conversions between Fractions and BigNumbers throw a neat error now
- (See #710).
-
-
-
-- Implemented function `erf()`. THanks @patgrasso.
-- Extended function `cross()` to support n-d vectors. Thanks @patgrasso.
-- Extended function `pickRandom` with the option to pick multiple values from
- an array and give the values weights: `pickRandom(possibles, number, weights)`.
- Thanks @woylie.
-- Parser now exposes test functions like `isAlpha` which can be replaced in
- order to adjust the allowed characters in variables names (See #715).
-- Fixed #727: Parser not throwing an error for invalid implicit multiplications
- like `-2 2` and `2^3 4` (right after the second value of an operator).
-- Fixed #688: Describe allowed variable names in the docs.
-
-
-
-- Fixed numbers ending with a decimal mark (like `2.`) not being supported by
- the parser, solved the underlying ambiguity in the parser. See #707, #711.
-
-
-
-- Comments of expressions are are now stored in the parsed nodes. See #690.
-- Fixed function `print` not accepting an Object with formatting options as
- third parameter Thanks @ThomasBrierley.
-- Fixed #707: The expression parser no longer accepts numbers ending with a dot
- like `2.`.
-
-
-
-- Implemented support for custom units using `createUnit`. Thanks @ericman314.
-- Implemented function `splitUnits`. Thanks @ericman314.
-- Implemented function `isPrime`. Thanks @MathBunny.
-
-
-
-- Implemented function `isNaN`.
-- Function `math.filter` now passes three arguments to the callback function:
- value, index, and array.
-- Removed the check on the number of arguments from functions defined in the
- expression parser (see #665).
-- Fixed #665: functions `map`, `forEach`, and `filter` now invoke callbacks
- which are a typed-function with the correct number of arguments.
-
-
-
-- Implemented #644: method `Parser.getAll()` to retrieve all defined variables.
-- Upgraded dependencies (decimal.js@5.0.8, fraction.js@3.3.1,
- typed-function@0.10.4).
-- Fixed #601: Issue with unnamed typed-functions by upgrading to
- typed-function v0.10.4.
-- Fixed #636: More strict `toTex` templates, reckon with number of arguments.
-- Fixed #641: Bug in expression parser parsing implicit multiplication with
- wrong precedence in specific cases.
-- Fixed #645: Added documentation about `engineering` notation of function
- `math.format`.
-
-
-
-- Using ES6 Math functions like `Math.sinh`, `Math.cbrt`, `Math.sign`, etc when
- available.
-- Fixed #631: unit aliases `weeks`, `months`, and `years` where missing.
-- Fixed #632: problem with escaped backslashes at the end of strings.
-- Fixed #635: `Node.toString` options where not passed to function arguments.
-- Fixed #629: expression parser throws an error when passing a number with
- decimal exponent instead of parsing them as implicit multiplication.
-- Fixed #484, #555: inaccuracy of `math.sinh` for values between -1 and 1.
-- Fixed #625: Unit `in` (`inch`) not always working due to ambiguity with
- the operator `a in b` (alias of `a to b`).
-
-
-
-- Fixed #621: a bug in parsing implicit multiplications like `(2)(3)+4`.
-- Fixed #623: `nthRoot` of zero with a negative root returned `0` instead of
- `Infinity`.
-- Throw an error when functions `min`, `max`, `mean`, or `median` are invoked
- with multiple matrices as arguments (see #598).
-
-
-
-- Hide multiplication operator by default when outputting `toTex` and `toString`
- for implicit multiplications. Implemented and option to output the operator.
-- Implemented unit `kip` and alias `kips`. Thanks @hgupta9.
-- Added support for prefixes for units `mol` and `mole`. Thanks @stu-blair.
-- Restored support for implicit multiplications like `2(3+4)` and `(2+3)(4+5)`.
-- Some improvements in the docs.
-- Added automatic conversions from `boolean` and `null` to `Fraction`,
- and conversions from `Fraction` to `Complex`.
-
-
-
-- More restricted support for implicit multiplication in the expression
- parser: `(...)(...)` is now evaluated as a function invocation,
- and `[...][...]` as a matrix subset.
-- Matrix multiplication no longer squeezes scalar outputs to a scalar value,
- but leaves them as they are: a vector or matrix containing a single value.
- See #529.
-- Assignments in the expression parser now return the assigned value rather
- than the created or updated object (see #533). Example:
-
- ```
- A = eye(3)
- A[1,1] = 2 # this assignment now returns 2 instead of A
- ```
-
-- Expression parser now supports objects. This involves a refactoring and
- extension in expression nodes:
- - Implemented new node `ObjectNode`.
- - Refactored `AssignmentNode`, `UpdateNode`, and `IndexNode` are refactored
- into `AccessorNode`, `AssignmentNode`, and `IndexNode` having a different API.
-- Upgraded the used BigNumber library `decimal.js` to v5. Replaced the
- trigonometric functions of math.js with those provided in decimal.js v5.
- This can give slightly different behavior qua round-off errors.
-- Replaced the internal `Complex.js` class with the `complex.js` library
- created by @infusion.
-- Entries in a matrix (typically numbers, BigNumbers, Units, etc) are now
- considered immutable, they are no longer copied when performing operations on
- the entries, improving performance.
-- Implemented nearly equal comparison for relational functions (`equal`,
- `larger`, `smaller`, etc.) when using BigNumbers.
-- Changed the casing of the configuration options `matrix` (`Array` or `Matrix`)
- and `number` (`number`, `BigNumber`, `Fraction`) such that they now match
- the type returned by `math.typeof`. Wrong casing gives a console warning but
- will still work.
-- Changed the default config value for `epsilon` from `1e-14` to `1e-12`,
- see #561.
-
-
-
-- Extended function `pow` to return the real root for cubic roots of negative
- numbers. See #525, #482, #567.
-- Implemented support for JSON objects in the expression parser and the
- function `math.format`.
-- Function `math.fraction` now supports `BigNumber`, and function
- `math.bignumber` now supports `Fraction`.
-- Expression parser now allows function and/or variable assignments inside
- accessors and conditionals, like `A[x=2]` or `a > 2 ? b="ok" : b="fail"`.
-- Command line interface:
- - Outputs the variable name of assignments.
- - Fixed not rounding BigNumbers to 14 digits like numbers.
- - Fixed non-working autocompletion of user defined variables.
-- Reorganized and extended docs, added docs on classes and more. Thanks @hgupta9.
-- Added new units `acre`, `hectare`, `torr`, `bar`, `mmHg`, `mmH2O`, `cmH2O`,
- and added new aliases `acres`, `hectares`, `sqfeet`, `sqyard`, `sqmile`,
- `sqmiles`, `mmhg`, `mmh2o`, `cmh2o`. Thanks @hgupta9.
-- Fixed a bug in the toString method of an IndexNode.
-- Fixed angle units `deg`, `rad`, `grad`, `cycle`, `arcsec`, and `arcmin` not
- being defined as BigNumbers when configuring to use BigNumbers.
-
-
-
-- Added more unit aliases for time: `secs`, `mins`, `hr`, `hrs`. See #551.
-- Added support for doing operations with mixed `Fractions` and `BigNumbers`.
-- Fixed #540: `math.intersect()` returning null in some cases. Thanks @void42.
-- Fixed #546: Cannot import BigNumber, Fraction, Matrix, Array.
- Thanks @brettjurgens.
-
-
-
-- Implemented (complex) units `VA` and `VAR`.
-- Implemented time units for weeks, months, years, decades, centuries, and
- millennia. Thanks @owenversteeg.
-- Implemented new notation `engineering` in function `math.format`.
- Thanks @johnmarinelli.
-- Fixed #523: In some circumstances, matrix subset returned a scalar instead
- of the correct subset.
-- Fixed #536: A bug in an internal method used for sparse matrices.
-
-
-
-- Implemented support for numeric types `Fraction` and `BigNumber` in units.
-- Implemented new method `toNumeric` for units.
-- Implemented new units `arcsec`, `arcsecond`, `arcmin`, `arcminute`.
- Thanks @devdevdata222.
-- Implemented new unit `Herts` (`Hz`). Thanks @SwamWithTurtles.
-- Fixed #485: Scoping issue with variables both used globally as well as in a
- function definition.
-- Fixed: Function `number` didn't support `Fraction` as input.
-
-
-
-- Fixed #502: Issue with `format` in some JavaScript engines.
-- Fixed #503: Removed trailing commas and the use of keyword `import` as
- property, as this gives issues with old JavaScript engines.
-
-
-
-- Fixed #480: `nthRoot` not working on Internet Explorer (up to IE11).
-- Fixed #490: `nthRoot` returning an error for negative values like
- `nthRoot(-2, 3)`.
-- Fixed #489: an issue with initializing a sparse matrix without data.
- Thanks @Retsam.
-- Fixed: #493: function `combinations` did not throw an exception for
- non-integer values of `k`.
-- Fixed: function `import` did not override typed functions when the option
- override was set true.
-- Fixed: added functions `math.sparse` and `math.index` to the reference docs,
- they where missing.
-- Fixed: removed memoization from `gamma` and `factorial` functions, this
- could blow up memory.
-
-
-
-- Added support in the expression parser for mathematical alphanumeric symbols
- in the expression parser: unicode range \u{1D400} to \u{1D7FF} excluding
- invalid code points.
-- Extended function `distance` with more signatures. Thanks @kv-kunalvyas.
-- Fixed a bug in functions `sin` and `cos`, which gave wrong results for
- BigNumber integer values around multiples of tau (i.e. `sin(bignumber(7))`).
-- Fixed value of unit `stone`. Thanks @Esvandiary for finding the error.
-
-
-
-- Implemented function `distance`. Thanks @devanp92.
-- Implemented support for Fractions in function `lcm`. Thanks @infusion.
-- Implemented function `cbrt` for numbers, complex numbers, BigNumbers, Units.
-- Implemented function `hypot`.
-- Upgraded to fraction.js v3.0.0.
-- Fixed #450: issue with non sorted index in sparse matrices.
-- Fixed #463, #322: inconsistent handling of implicit multiplication.
-- Fixed #444: factorial of infinity not returning infinity.
-
-
-
-- Units with powers (like `m^2` and `s^-1`) now output with the best prefix.
-- Implemented support for units to `abs`, `cube`, `sign`, `sqrt`, `square`.
- Thanks @ericman314.
-- Implemented function `catalan` (Combinatorics). Thanks @devanp92.
-- Improved the `canDefineProperty` check to return false in case of IE8, which
- has a broken implementation of `defineProperty`. Thanks @golmansax.
-- Fixed function `to` not working in case of a simplified unit.
-- Fixed #437: an issue with row swapping in `lup`, also affecting `lusolve`.
-
-
-
-- Fixed wrong values of the physical constants `speedOfLight`, `molarMassC12`,
- and `magneticFluxQuantum`. Thanks @ericman314 for finding two of them.
-
-
-
-- Implemented derived units (like `110 km/h in m/s`). Thanks @ericman314.
-- Implemented support for electric units. Thanks @ericman314.
-- Implemented about 50 physical constants like `speedOfLight`, `gravity`, etc.
-- Implemented function `kldivergence` (Kullback-Leibler divergence).
- Thanks @saromanov.
-- Implemented function `mode`. Thanks @kv-kunalvyas.
-- Added support for unicode characters in the expression parser: greek letters
- and latin letters with accents. See #265.
-- Internal functions `Unit.parse` and `Complex.parse` now throw an Error
- instead of returning null when passing invalid input.
-
-
-
-- Large internal refactoring:
- - performance improvements.
- - allows to create custom bundles
- - functions are composed using `typed-function` and are extensible
-- Implemented support for fractions, powered by the library `fraction.js`.
-- Implemented matrix LU decomposition with partial pivoting and a LU based
- linear equations solver (functions `lup` and `lusolve`). Thanks @rjbaucells.
-- Implemented a new configuration option `predictable`, which can be set to
- true in order to ensure predictable function output types.
-- Implemented function `intersect`. Thanks @kv-kunalvyas.
-- Implemented support for adding `toTex` properties to custom functions.
- Thanks @FSMaxB.
-- Implemented support for complex values to `nthRoot`. Thanks @gangachris.
-- Implemented util functions `isInteger`, `isNegative`, `isNumeric`,
- `isPositive`, and `isZero`.
-
-
-
-- String input is now converted to numbers by default for all functions.
-- Adding two strings will no longer concatenate them, but will convert the
- strings to numbers and add them.
-- Function `index` does no longer accept an array `[start, end, step]`, but
- instead accepts an array with arbitrary index values. It also accepts
- a `Range` object as input.
-- Function `typeof` no longer returns lower case names, but now returns lower
- case names for primitives (like `number`, `boolean`, `string`), and
- upper-camel-case for non-primitives (like `Array`, `Complex`, `Function`).
-- Function `import` no longer supports a module name as argument. Instead,
- modules can be loaded using require: `math.import(require('module-name'))`.
-- Function `import` has a new option `silent` to ignore errors, and throws
- errors on duplicates by default.
-- Method `Node.compile()` no longer needs `math` to be passed as argument.
-- Reintroduced method `Node.eval([scope])`.
-- Function `sum` now returns zero when input is an empty array. Thanks @FSMAxB.
-- The size of Arrays is no longer validated. Matrices will validate this on
- creation.
-
-
-
-- Fixed #397: Inaccuracies in nthRoot for very large values, and wrong results
- for very small values. (backported from v2)
-- Fixed #405: Parser throws error when defining a function in a multiline
- expression.
-
-
-
-- Implemented function `quantileSeq` and `partitionSelect`. Thanks @BigFav.
-- Implemented functions `stirlingS2`, `bellNumbers`, `composition`, and
- `multinomial`. Thanks @devanp92.
-- Improved the performance of `median` (see #373). Thanks @BigFav.
-- Extended the command line interface with a `mode` option to output either
- the expressions result, string representation, or tex representation.
- Thanks @FSMaxB.
-- Fixed #309: Function median mutating the input matrix. Thanks @FSMaxB.
-- Fixed `Node.transform` not recursing over replaced parts of the
- node tree (see #349).
-- Fixed #381: issue in docs of `randomInt`.
-
-
-
-- Improvements in `toTex`. Thanks @FSMaxB.
-- Fixed #328: `abs(0 + 0i)` evaluated to `NaN`.
-- Fixed not being able to override lazy loaded constants.
-
-
-
-- Fixed #313: parsed functions did not handle recursive calls correctly.
-- Fixed #251: binary prefix and SI prefix incorrectly used for byte. Now
- following SI standards (`1 KiB == 1024 B`, `1 kB == 1000 B`).
-- Performance improvements in parsed functions.
-
-
-
-- Added unit `stone` (6.35 kg).
-- Implemented support for sparse matrices. Thanks @rjbaucells.
-- Implemented BigNumber support for function `atan2`. Thanks @BigFav.
-- Implemented support for custom LaTeX representations. Thanks @FSMaxB.
-- Improvements and bug fixes in outputting parentheses in `Node.toString` and
- `Node.toTex` functions. Thanks @FSMaxB.
-- Fixed #291: function `format` sometimes returning exponential notation when
- it should return a fixed notation.
-
-
-
-- Implemented trigonometric functions:
- `acosh`, `acoth`, `acsch`, `asech`, `asinh`, `atanh`, `acot`, `acsc`, `asec`.
- Thanks @BigFav.
-- Added BigNumber support for functions: `cot`, `csc`, `sec`, `coth`,
- `csch`, `sech`. Thanks @BigFav.
-- Implemented support for serialization and deserialization of math.js data
- types.
-- Fixed the calculation of `norm()` and `abs()` for large complex numbers.
- Thanks @rjbaucells.
-- Fixed #281: improved formatting complex numbers. Round the real or imaginary
- part to zero when the difference is larger than the configured precision.
-
-
-
-- Implemented BigNumber implementations of most trigonometric functions: `sin`,
- `cos`, `tan`, `asin`, `acos`, `atan`, `cosh`, `sinh`, `tanh`. Thanks @BigFav.
-- Implemented function `trace`. Thanks @pcorey.
-- Faster loading of BigNumber configuration with a high precision by lazy
- loading constants like `pi` and `e`.
-- Fixed constants `NaN` and `Infinity` not being BigNumber objects when
- BigNumbers are configured.
-- Fixed missing parentheses in the `toTex` representation of function
- `permutations`.
-- Some minor fixes in the docs. Thanks @KenanY.
-
-
-
-- Support for bitwise operations `bitAnd`, `bitNot`, `bitOr`, `bitXor`,
- `leftShift`, `rightArithShift`, and `rightLogShift`. Thanks @BigFav.
-- Support for boolean operations `and`, `not`, `or`, `xor`. Thanks @BigFav.
-- Support for `gamma` function. Thanks @BigFav.
-- Converting a unit without value will now result in a unit *with* value,
- i.e. `inch in cm` will return `2.54 cm` instead of `cm`.
-- Improved accuracy of `sinh` and complex `cos` and `sin`. Thanks @pavpanchekha.
-- Renamed function `select` to `chain`. The old function `select` will remain
- functional until math.js v2.0.
-- Upgraded to decimal.js v4.0.1 (BigNumber library).
-
-
-
-- Fixed Unit divided by Number returning zero.
-- Fixed BigNumber downgrading to Number for a negative base in `pow`.
-- Fixed some typos in error messaging (thanks @andy0130tw) and docs.
-
-
-
-- Implemented functions `dot` (dot product), `cross` (cross product), and
- `nthRoot`.
-- Officially opened up the API of expression trees:
- - Documented the API.
- - Implemented recursive functions `clone`, `map`, `forEach`, `traverse`,
- `transform`, and `filter` for expression trees.
- - Parameter `index` in the callbacks of `map` and `forEach` are now cloned
- for every callback.
- - Some internal refactoring inside nodes to make the API consistent:
- - Renamed `params` to `args` and vice versa to make things consistent.
- - Renamed `Block.nodes` to `Block.blocks`.
- - `FunctionNode` now has a `name: string` instead of a `symbol: SymbolNode`.
- - Changed constructor of `RangeNode` to
- `new RangeNode(start: Node, end: Node [, step: Node])`.
- - Nodes for a `BlockNode` must now be passed via the constructor instead
- of via a function `add`.
-- Fixed `2e` giving a syntax error instead of being parsed as `2 * e`.
-
-
-
-- Disabled array notation for ranges in a matrix index in the expression parser
- (it is confusing and redundant there).
-- Fixed a regression in the build of function subset not being able to return
- a scalar.
-- Fixed some missing docs and broken links in the docs.
-
-
-
-- Implemented a function `filter(x, test)`.
-- Removed `math.distribution` for now, needs some rethinking.
-- `math.number` can convert units to numbers (requires a second argument)
-- Fixed some precedence issues with the range and conversion operators.
-- Fixed an zero-based issue when getting a matrix subset using an index
- containing a matrix.
-
-
-
-- Implemented functions `sort(x [, compare])` and `flatten(x)`.
-- Implemented support for `null` in all functions.
-- Implemented support for "rawArgs" functions in the expression parser. Raw
- functions are invoked with unevaluated parameters (nodes).
-- Expressions in the expression parser can now be spread over multiple lines,
- like '2 +\n3'.
-- Changed default value of the option `wrap` of function `math.import` to false.
-- Changed the default value for new entries in a resized matrix when to zero.
- To leave new entries uninitialized, use the new constant `math.uninitialized`
- as default value.
-- Renamed transform property from `__transform__` to `transform`, and documented
- the transform feature.
-- Fixed a bug in `math.import` not applying options when passing a module name.
-- A returned matrix subset is now only squeezed when the `index` consists of
- scalar values, and no longer for ranges resolving into a single value.
-
-
-
-- A new instance of math.js can no longer be created like `math([options])`,
- to prevent side effects from math being a function instead of an object.
- Instead, use the function `math.create([options])` to create a new instance.
-- Implemented `BigNumber` support for all constants: `pi`, `tau`, `e`, `phi`,
- `E`, `LN2`, `LN10`, `LOG2E`, `LOG10E`, `PI`, `SQRT1_2`, and `SQRT2`.
-- Implemented `BigNumber` support for functions `gcd`, `xgcd`, and `lcm`.
-- Fixed function `gxcd` returning an Array when math.js was configured
- as `{matrix: 'matrix'}`.
-- Multi-line expressions now return a `ResultSet` instead of an `Array`.
-- Implemented transforms (used right now to transform one-based indices to
- zero-based for expressions).
-- When used inside the expression parser, functions `concat`, `min`, `max`,
- and `mean` expect an one-based dimension number.
-- Functions `map` and `forEach` invoke the callback with one-based indices
- when used from within the expression parser.
-- When adding or removing dimensions when resizing a matrix, the dimensions
- are added/removed from the inner side (right) instead of outer side (left).
-- Improved index out of range errors.
-- Fixed function `concat` not accepting a `BigNumber` for parameter `dim`.
-- Function `squeeze` now squeezes both inner and outer singleton dimensions.
-- Output of getting a matrix subset is not automatically squeezed anymore
- except for scalar output.
-- Renamed `FunctionNode` to `FunctionAssignmentNode`, and renamed `ParamsNode`
- to `FunctionNode` for more clarity.
-- Fixed broken auto completion in CLI.
-- Some minor fixes.
-
-
-
-- The library now immediately returns a default instance of mathjs, there is
- no need to instantiate math.js in a separate step unless one ones to set
- configuration options:
-
- // instead of:
- var mathjs = require('mathjs'), // load math.js
- math = mathjs(); // create an instance
-
- // just do:
- var math = require('mathjs');
-- Implemented support for implicit multiplication, like `math.eval('2a', {a:3})`
- and `math.eval('(2+3)(1-3)')`. This changes behavior of matrix indexes as
- well: an expression like `[...][...]` is not evaluated as taking a subset of
- the first matrix, but as an implicit multiplication of two matrices.
-- Removed utility function `ifElse`. This function is redundant now the
- expression parser has a conditional operator `a ? b : c`.
-- Fixed a bug with multiplying a number with a temperature,
- like `math.eval('10 * celsius')`.
-- Fixed a bug with symbols having value `undefined` not being evaluated.
-
-
-
-- Added constant `null`.
-- Functions `equal` and `unequal` support `null` and `undefined` now.
-- Function `typeof` now recognizes regular expressions as well.
-- Objects `Complex`, `Unit`, and `Help` now return their string representation
- when calling `.valueOf()`.
-- Changed the default number of significant digits for BigNumbers from 20 to 64.
-- Changed the behavior of the conditional operator (a ? b : c) to lazy
- evaluating.
-- Fixed imported, wrapped functions not accepting `null` and `undefined` as
- function arguments.
-
-
-
-- Renamed some functions (everything now has a logical, camel case name):
- - Renamed functions `edivide`, `emultiply`, and `epow` to `dotDivide`,
- `dotMultiply`, and `dotPow` respectively.
- - Renamed functions `smallereq` and `largereq` to `smallerEq` and `largerEq`.
- - Renamed function `unary` to `unaryMinus` and added support for strings.
-- `end` is now a reserved keyword which cannot be used as function or symbol
- name in the expression parser, and is not allowed in the scope against which
- an expression is evaluated.
-- Implemented function `unaryPlus` and unary plus operator.
-- Implemented function `deepEqual` for matrix comparisons.
-- Added constant `phi`, the golden ratio (`phi = 1.618...`).
-- Added constant `version`, returning the version number of math.js as string.
-- Added unit `drop` (`gtt`).
-- Fixed not being able to load math.js using AMD/require.js.
-- Changed signature of `math.parse(expr, nodes)` to `math.parse(expr, options)`
- where `options: {nodes: Object.}`
-- Removed matrix support from conditional function `ifElse`.
-- Removed automatic assignment of expression results to variable `ans`.
- This functionality can be restored by pre- or postprocessing every evaluation,
- something like:
-
- function evalWithAns (expr, scope) {
- var ans = math.eval(expr, scope);
- if (scope) {
- scope.ans = ans;
- }
- return ans;
- }
-
-
-
-- Implemented support to export expressions to LaTeX. Thanks Niels Heisterkamp
- (@nheisterkamp).
-- Output of matrix multiplication is now consistently squeezed.
-- Added reference documentation in the section /docs/reference.
-- Fixed a bug in multiplying units without value with a number (like `5 * cm`).
-- Fixed a bug in multiplying two matrices containing vectors (worked fine for
- arrays).
-- Fixed random functions not accepting Matrix as input, and always returning
- a Matrix as output.
-
-
-
-- Removed `crypto` library from the bundle.
-- Deprecated functions `Parser.parse` and `Parser.compile`. Use
- `math.parse` and `math.compile` instead.
-- Fixed function `add` not adding strings and matrices element wise.
-- Fixed parser not being able to evaluate an exponent followed by a unary minus
- like `2^-3`, and a transpose followed by an index like `[3]'[1]`.
-
-
-
-- Switched to module `decimal.js` for BigNumber support, instead of
- `bignumber.js`.
-- Implemented support for polar coordinates to the `Complex` datatype.
- Thanks Finn Pauls (@finnp).
-- Implemented BigNumber support for functions `exp`, `log`, and `log10`.
-- Implemented conditional operator `a ? b : c` in expression parser.
-- Improved floating point comparison: the functions now check whether values
- are nearly equal, against a configured maximum relative difference `epsilon`.
- Thanks Rogelio J. Baucells (@rjbaucells).
-- Implemented function `norm`. Thanks Rogelio J. Baucells (@rjbaucells).
-- Improved function `ifElse`, is now specified for special data types too.
-- Improved function `det`. Thanks Bryan Cuccioli (@bcuccioli).
-- Implemented `BigNumber` support for functions `det` and `diag`.
-- Added unit alias `lbs` (pound mass).
-- Changed configuration option `decimals` to `precision` (applies to BigNumbers
- only).
-- Fixed support for element-wise comparisons between a string and a matrix.
-- Fixed: expression parser now trows IndexErrors with one-based indices instead
- of zero-based.
-- Minor bug fixes.
-
-
-
-- Added unit `feet`.
-- Implemented function `compile` (shortcut for parsing and then compiling).
-- Improved performance of function `pow` for matrices. Thanks @hamadu.
-- Fixed broken auto completion in the command line interface.
-- Fixed an error in function `combinations` for large numbers, and
- improved performance of both functions `combinations` and `permutations`.
-
-
-
-- Changed matrix index notation of expression parser from round brackets to
- square brackets, for example `A[1, 1:3]` instead of `A(1, 1:3)`.
-- Removed need to use the `function` keyword for function assignments in the
- expression parser, you can define a function now like `f(x) = x^2`.
-- Implemented a compilation step in the expression parser: expressions are
- compiled into JavaScript, giving much better performance (easily 10x as fast).
-- Renamed unit conversion function and operator `in` to `to`. Operator `in` is
- still available in the expression parser as an alias for `to`. Added unit
- `in`, an abbreviation for `inch`. Thanks Elijah Insua (@tmpvar).
-- Added plurals and aliases for units.
-- Implemented an argument `includeEnd` for function `range` (false by default).
-- Ranges in the expression parser now support big numbers.
-- Implemented functions `permutations` and `combinations`.
- Thanks Daniel Levin (@daniel-levin).
-- Added lower case abbreviation `l` for unit litre.
-
-
-
-- Renamed and flattened configuration settings:
- - `number.defaultType` is now `number`.
- - `number.precision` is now `decimals`.
- - `matrix.defaultType` is now `matrix`.
-- Function `multiply` now consistently outputs a complex number on complex input.
-- Fixed `mod` and `in` not working as function (only as operator).
-- Fixed support for old browsers (IE8 and older), compatible when using es5-shim.
-- Fixed support for Java's ScriptEngine.
-
-
-
-- Implemented BigNumber support for arbitrary precision calculations.
- Added settings `number.defaultType` and `number.precision` to configure
- big numbers.
-- Documentation is extended.
-- Removed utility functions `isScalar`, `toScalar`, `isVector`, `toVector`
- from `Matrix` and `Range`. Use `math.squeeze` and `math.size` instead.
-- Implemented functions `get` and `set` on `Matrix`, for easier and faster
- retrieval/replacement of elements in a matrix.
-- Implemented function `resize`, handling matrices, scalars, and strings.
-- Functions `ones` and `zeros` now return an empty matrix instead of a
- number 1 or 0 when no arguments are provided.
-- Implemented functions `min` and `max` for `Range` and `Index`.
-- Resizing matrices now leaves new elements undefined by default instead of
- filling them with zeros. Function `resize` now has an extra optional
- parameter `defaultValue`.
-- Range operator `:` in expression parser has been given a higher precedence.
-- Functions don't allow arguments of unknown type anymore.
-- Options be set when constructing a math.js instance or using the new function
- `config(options`. Options are no longer accessible via `math.options`.
-- Renamed `scientific` notation to `exponential` in function `format`.
-- Function `format` outputs exponential notation with positive exponents now
- always with `+` sign, so outputs `2.1e+3` instead of `2.1e3`.
-- Fixed function `squeeze` not being able squeeze into a scalar.
-- Some fixes and performance improvements in the `resize` and `subset`
- functions.
-- Function `size` now adheres to the option `matrix.defaultType` for scalar
- input.
-- Minor bug fixes.
-
-
-
-- Math.js must be instantiated now, static calls are no longer supported. Usage:
- - node.js: `var math = require('mathjs')();`
- - browser: `var math = mathjs();`
-- Implemented support for multiplying vectors with matrices.
-- Improved number formatting:
- - Function `format` now support various options: precision, different
- notations (`fixed`, `scientific`, `auto`), and more.
- - Numbers are no longer rounded to 5 digits by default when formatted.
- - Implemented a function `format` for `Matrix`, `Complex`, `Unit`, `Range`,
- and `Selector` to format using options.
- - Function `format` does only stringify values now, and has a new parameter
- `precision` to round to a specific number of digits.
- - Removed option `math.options.precision`,
- use `math.format(value [, precision])` instead.
- - Fixed formatting numbers as scientific notation in some cases returning
- a zero digit left from the decimal point. (like "0.33333e8" rather than
- "3.3333e7"). Thanks @husayt.
-- Implemented a function `print` to interpolate values in a template string,
- this functionality was moved from the function `format`.
-- Implemented statistics function `mean`. Thanks Guillermo Indalecio Fernandez
- (@guillermobox).
-- Extended and changed `max` and `min` for multi dimensional matrices: they now
- return the maximum and minimum of the flattened array. An optional second
- argument `dim` allows to calculate the `max` or `min` for specified dimension.
-- Renamed option `math.options.matrix.default` to
- `math.options.matrix.defaultType`.
-- Removed support for comparing complex numbers in functions `smaller`,
- `smallereq`, `larger`, `largereq`. Complex numbers cannot be ordered.
-
-
-
-- Introduced an option `math.options.matrix.default` which can have values
- `matrix` (default) or `array`. This option is used by the functions `eye`,
- `ones`, `range`, and `zeros`, to determine the type of matrix output.
-- Getting a subset of a matrix will automatically squeeze the resulting subset,
- setting a subset of a matrix will automatically unsqueeze the given subset.
-- Removed concatenation of nested arrays in the expression parser.
- You can now input nested arrays like in JavaScript. Matrices can be
- concatenated using the function `concat`.
-- The matrix syntax `[...]` in the expression parser now creates 1 dimensional
- matrices by default. `math.eval('[1,2,3,4]')` returns a matrix with
- size `[4]`, `math.eval('[1,2;3,4]')` returns a matrix with size `[2,2]`.
-- Documentation is restructured and extended.
-- Fixed non working operator `mod` (modulus operator).
-
-
-
-- Implemented support for booleans in all relevant functions.
-- Implemented functions `map` and `forEach`. Thanks Sebastien Piquemal (@sebpic).
-- All construction functions can be used to convert the type of variables,
- also element-wise for all elements in an Array or Matrix.
-- Changed matrix indexes of the expression parser to one-based with the
- upper-bound included, similar to most math applications. Note that on a
- JavaScript level, math.js uses zero-based indexes with excluded upper-bound.
-- Removed support for scalars in the function `subset`, it now only supports
- Array, Matrix, and String.
-- Removed the functions `get` and `set` from a selector, they are a duplicate
- of the function `subset`.
-- Replaced functions `get` and `set` of `Matrix` with a single function
- `subset`.
-- Some moving around with code and namespaces:
- - Renamed namespace `math.expr` to `math.expression` (contains Scope, Parser,
- node objects).
- - Renamed namespace `math.docs` to `math.expression.docs`.
- - Moved `math.expr.Selector` to `math.chaining.Selector`.
-- Fixed some edge cases in functions `lcm` and `xgcd`.
-
-
-
-- Implemented functions `random([min, max])`, `randomInt([min, max])`,
- `pickRandom(array)`. Thanks Sebastien Piquemal (@sebpic).
-- Implemented function `distribution(name)`, generating a distribution object
- with functions `random`, `randomInt`, `pickRandom` for different
- distributions. Currently supporting `uniform` and `normal`.
-- Changed the behavior of `range` to exclude the upper bound, so `range(1, 4)`
- now returns `[1, 2, 3]` instead of `[1, 2, 3, 4]`.
-- Changed the syntax of `range`, which is now `range(start, end [, step])`
- instead of `range(start, [step, ] end)`.
-- Changed the behavior of `ones` and `zeros` to geometric dimensions, for
- example `ones(3)` returns a vector with length 3, filled with ones, and
- `ones(3,3)` returns a 2D array with size [3, 3].
-- Changed the return type of `ones` and `zeros`: they now return an Array when
- arguments are Numbers or an Array, and returns a Matrix when the argument
- is a Matrix.
-- Change matrix index notation in parser from round brackets to square brackets,
- for example `A[0, 0:3]`.
-- Removed the feature introduced in v0.10.0 to automatically convert a complex
- value with an imaginary part equal to zero to a number.
-- Fixed zeros being formatted as null. Thanks @TimKraft.
-
-
-
-- Changed math.js from one-based to zero-based indexes.
- - Getting and setting matrix subset is now zero-based.
- - The dimension argument in function `concat` is now zero-based.
-- Improvements in the string output of function help.
-- Added constants `true` and `false`.
-- Added constructor function `boolean`.
-- Fixed function `select` not accepting `0` as input.
- Thanks Elijah Manor (@elijahmanor).
-- Parser now supports multiple unary minus operators after each other.
-- Fixed not accepting empty matrices like `[[], []]`.
-- Some fixes in the end user documentation.
-
-
-
-- For complex calculations, all functions now automatically replace results
- having an imaginary part of zero with a Number. (`2i * 2i` now returns a
- Number `-4` instead of a Complex `-4 + 0i`).
-- Implemented support for injecting custom node handlers in the parser. Can be
- used for example to implement a node handler for plotting a graph.
-- Implemented end user documentation and a new `help` function.
-- Functions `size` and `squeeze` now return a Matrix instead of an Array as
- output on Matrix input.
-- Added a constant tau (2 * pi). Thanks Zak Zibrat (@palimpsests).
-- Renamed function `unaryminus` to `unary`.
-- Fixed a bug in determining node dependencies in function assignments.
-
-
-
-- Implemented element-wise functions and operators: `emultiply` (`x .* y`),
- `edivide` (`x ./ y`), `epow` (`x .^ y`).
-- Added constants `Infinity` and `NaN`.
-- Removed support for Workspace to keep the library focused on its core task.
-- Fixed a bug in the Complex constructor, not accepting NaN values.
-- Fixed division by zero in case of pure complex values.
-- Fixed a bug in function multiply multiplying a pure complex value with
- Infinity.
-
-
-
-- Implemented function `math.parse(expr [,scope])`. Optional parameter scope can
- be a plain JavaScript Object containing variables.
-- Extended function `math.expr(expr [, scope])` with an additional parameter
- `scope`, similar to `parse`. Example: `math.eval('x^a', {x:3, a:2});`.
-- Implemented function `subset`, to get or set a subset from a matrix, string,
- or other data types.
-- Implemented construction functions number and string (mainly useful inside
- the parser).
-- Improved function `det`. Thanks Bryan Cuccioli (@bcuccioli).
-- Moved the parse code from prototype math.expr.Parser to function math.parse,
- simplified Parser a little bit.
-- Strongly simplified the code of Scope and Workspace.
-- Fixed function mod for negative numerators, and added error messages in case
- of wrong input.
-
-
-
-- Extended the import function and some other minor improvements.
-- Fixed a bug in merging one dimensional vectors into a matrix.
-- Fixed a bug in function subtract, when subtracting a complex number from a
- real number.
-
-
-
-- Implemented a command line interface. When math.js is installed globally via
- npm, the application is available on your system as 'mathjs'.
-- Implemented `end` keyword for index operator, and added support for implicit
- start and end (expressions like `a(2,:)` and `b(2:end,3:end-1)` are supported
- now).
-- Function math.eval is more flexible now: it supports variables and multi-line
- expressions.
-- Removed the read-only option from Parser and Scope.
-- Fixed non-working unequal operator != in the parser.
-- Fixed a bug in resizing matrices when replacing a subset.
-- Fixed a bug in updating a subset of a non-existing variable.
-- Minor bug fixes.
-
-
-
-- Improvements in the parser:
- - Added support for chained arguments.
- - Added support for chained variable assignments.
- - Added a function remove(name) to remove a variable from the parsers scope.
- - Renamed nodes for more consistency and to resolve naming conflicts.
- - Improved stringification of an expression tree.
- - Some simplifications in the code.
- - Minor bug fixes.
-- Fixed a bug in the parser, returning NaN instead of throwing an error for a
- number with multiple decimal separators like `2.3.4`.
-- Fixed a bug in Workspace.insertAfter.
-- Fixed: math.js now works on IE 6-8 too.
-
-
-
-- Implemented method `math.eval`, which uses a readonly parser to evaluate
- expressions.
-- Implemented method `xgcd` (extended eucledian algorithm). Thanks Bart Kiers
- (@bkiers).
-- Improved math.format, which now rounds values to a maximum number of digits
- instead of decimals (default is 5 digits, for example `math.format(math.pi)`
- returns `3.1416`).
-- Added examples.
-- Changed methods square and cube to evaluate matrices element wise (consistent
- with all other methods).
-- Changed second parameter of method import to an object with options.
-- Fixed method math.typeof on IE.
-- Minor bug fixes and improvements.
-
-
-
-- Implemented chained operations via method math.select(). For example
- `math.select(3).add(4).subtract(2).done()` will return `5`.
-- Implemented methods gcd and lcm.
-- Implemented method `Unit.in(unit)`, which creates a clone of the unit with a
- fixed representation. For example `math.unit('5.08 cm').in('inch')` will
- return a unit which string representation always is in inch, thus `2 inch`.
- `Unit.in(unit)` is the same as method `math.in(x, unit)`.
-- Implemented `Unit.toNumber(unit)`, which returns the value of the unit when
- represented with given unit. For example
- `math.unit('5.08 cm').toNumber('inch')` returns the number `2`, as the
- representation of the unit in inches has 2 as value.
-- Improved: method `math.in(x, unit)` now supports a string as second parameter,
- for example `math.in(math.unit('5.08 cm'), 'inch')`.
-- Split the end user documentation of the parser functions from the source
- files.
-- Removed function help and the built-in documentation from the core library.
-- Fixed constant i being defined as -1i instead of 1i.
-- Minor bug fixes.
-
-
-
-- Implemented data types Matrix and Range.
-- Implemented matrix methods clone, concat, det, diag, eye, inv, ones, size,
- squeeze, transpose, zeros.
-- Implemented range operator `:`, and transpose operator `'` in parser.
-- Changed: created construction methods for easy object creation for all data
- types and for the parser. For example, a complex value is now created
- with `math.complex(2, 3)` instead of `new math.Complex(2, 3)`, and a parser
- is now created with `math.parser()` instead of `new math.parser.Parser()`.
-- Changed: moved all data types under the namespace math.type, and moved the
- Parser, Workspace, etc. under the namespace math.expr.
-- Changed: changed operator precedence of the power operator:
- - it is now right associative instead of left associative like most scripting
- languages. So `2^3^4` is now calculated as `2^(3^4)`.
- - it has now higher precedence than unary minus most languages, thus `-3^2` is
- now calculated as `-(3^2)`.
-- Changed: renamed the parsers method 'put' into 'set'.
-- Fixed: method 'in' did not check for units to have the same base.
-
-
-
-- Implemented Array support for all methods.
-- Implemented Array support in the Parser.
-- Implemented method format.
-- Implemented parser for units, math.Unit.parse(str).
-- Improved parser for complex values math.Complex.parse(str);
-- Improved method help: it now evaluates the examples.
-- Fixed: a scoping issue with the Parser when defining functions.
-- Fixed: method 'typeof' was not working well with minified and mangled code.
-- Fixed: errors in determining the best prefix for a unit.
-
-
-
-- All constants of Math implemented, plus the imaginary unit i.
-- Data types Complex and Unit implemented.
-- First set of functions implemented.
-
-
-
-- First publish of the mathjs package. (package is still empty)
diff --git a/index.md b/index.md
deleted file mode 100644
index bc22c23548..0000000000
--- a/index.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-layout: default
-title: Home
----
-
-
An extensive math library for JavaScript and Node.js #
-
-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. Powerful and easy to use.
-
-
-
-- Supports numbers, big numbers, bigint, complex numbers, fractions, units, strings, arrays, and matrices.
-- Is compatible with JavaScript's built-in Math library.
-- Contains a flexible expression parser.
-- Does symbolic computation.
-- Comes with a large set of built-in functions and constants.
-- Can be used as a command line application as well.
-- Runs on any JavaScript engine.
-- Is easily extensible.
-- Open source.
-
-
-
- 
- 
-