Math.js

https://mathjs.org/docs/index.html
Admin
Math.js is an extensive math library for JavaScript and Node.js. It provides a flexible expression...
Tokens:128,417
Snippets:870
Trust Score:9.5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install math.js via npm

Source: https://mathjs.org/docs/index.html/getting_started

Instructions to install the math.js library using the npm package manager, a common method for Node.js projects and front-end build systems.

```bash
npm install mathjs
```

--------------------------------

### Basic math.js usage: functions, expressions, and chaining

Source: https://mathjs.org/docs/index.html/getting_started

Comprehensive examples showcasing various ways to use math.js, including direct function calls with constants, evaluating mathematical expressions from strings, and performing chained operations for sequential calculations.

```javascript
// functions and constants
math.round(math.e, 3)                // 2.718
math.atan2(3, -3) / math.pi          // 0.75
math.log(10000, 10)                  // 4
math.sqrt(-4)                        // 2i
math.pow([[-1, 2], [3, 1]], 2)       // [[7, 0], [0, 7]]

// expressions
math.evaluate('12 / (2.3 + 0.7)')    // 4
math.evaluate('12.7 cm to inch')     // 5 inch
math.evaluate('sin(45 deg) ^ 2')     // 0.5
math.evaluate('9 / 3 + 2i')          // 3 + 2i
math.evaluate('det([-1, 2; 3, 1])')  // -7

// chained operations
math.chain(3)
    .add(4)
    .multiply(2)
    .done() // 14
```

--------------------------------

### Load math.js in Node.js using CommonJS

Source: https://mathjs.org/docs/index.html/getting_started

Example of loading and using math.js functions in a Node.js environment with the CommonJS module system, typical for server-side JavaScript applications.

```javascript
const { sqrt } = require('mathjs')

console.log(sqrt(-4).toString()) // 2i
```

--------------------------------

### JavaScript Examples for math.help Usage

Source: https://mathjs.org/docs/index.html/reference/functions/help

Illustrative JavaScript examples demonstrating how to use the `math.help` function to get documentation for specific functions like 'sin' or `math.add`, and how to output the help information as a string or a JSON object.

```javascript
console.log(math.help('sin').toString())
console.log(math.help(math.add).toString())
console.log(math.help(math.add).toJSON())
```

--------------------------------

### Load and use math.js in a web browser

Source: https://mathjs.org/docs/index.html/getting_started

Demonstrates how to include math.js as a regular JavaScript file in an HTML document and access its global 'math' variable for calculations directly within the browser environment.

```html
<!DOCTYPE HTML>
<html>
<head>
  <script src="math.js" type="text/javascript"></script>
</head>
<body>
  <script type="text/javascript">
    console.log(math.sqrt(-4).toString()) // 2i
  </script>
</body>
</html>
```

--------------------------------

### Create a configurable math.js instance with ES modules

Source: https://mathjs.org/docs/index.html/getting_started

Illustrates how to create a custom math.js instance using 'create' and 'all' for configuration and importing external functions, maintaining full functionality including complex number support.

```javascript
import { create, all } from 'mathjs'

const config = { }
const math = create(all, config)

console.log(math.sqrt(-4).toString()) // 2i
```

--------------------------------

### Load math.js functions using ES modules

Source: https://mathjs.org/docs/index.html/getting_started

Demonstrates importing a specific function (sqrt) from the full math.js library using ES module syntax and its basic usage, including support for complex numbers.

```javascript
import { sqrt } from 'mathjs'

console.log(sqrt(-4).toString()) // 2i
```

--------------------------------

### Load number-only math.js functions using ES modules

Source: https://mathjs.org/docs/index.html/getting_started

Shows how to import lightweight, number-only implementations of math.js functions for performance or specific use cases where complex number support is not required, resulting in NaN for non-real results.

```javascript
import { sqrt } from 'mathjs/number'

console.log(sqrt(4).toString()) // 2
console.log(sqrt(-4).toString()) // NaN
```

--------------------------------

### Examples of math.solveODE Usage

Source: https://mathjs.org/docs/index.html/reference/functions/solveODE

Illustrative examples demonstrating how to use the `math.solveODE` function with different initial conditions and optional parameters.

```JavaScript
function func(t, y) {return y}
const tspan = [0, 4]
const y0 = 1
math.solveODE(func, tspan, y0)
math.solveODE(func, tspan, [1, 2])
math.solveODE(func, tspan, y0, { method:"RK23", maxStep:0.1 })
```

--------------------------------

### math.createUnit Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/createUnit

Practical examples demonstrating how to use `math.createUnit` to define various custom units. Examples include creating a simple unit, a unit with a definition and aliases, a unit from a string definition, and a unit based on an existing math.js unit object.

```javascript
math.createUnit('foo')
math.createUnit('knot', {definition: '0.514444444 m/s', aliases: ['knots', 'kt', 'kts']})
math.createUnit('mph', '1 mile/hour')
math.createUnit('km', math.unit(1000, 'm'))
```

--------------------------------

### RangeNode JavaScript Examples

Source: https://mathjs.org/docs/index.html/expressions/expression_trees

Provides JavaScript examples demonstrating how to create `RangeNode` instances. Examples include parsing range strings using `math.parse` and direct instantiation using the `new math.RangeNode()` constructor with `ConstantNode` arguments.

```JavaScript
const node1 = math.parse('1:10')
const node2 = math.parse('0:2:10')

const zero = new math.ConstantNode(0)
const one = new math.ConstantNode(1)
const two = new math.ConstantNode(2)
const ten = new math.ConstantNode(10)

const node3 = new math.RangeNode(one, ten)
const node4 = new math.RangeNode(zero, ten, two)
```

--------------------------------

### JavaScript Example: Basic Matrix Operations with math.js

Source: https://mathjs.org/docs/index.html/reference/functions/matrix

This example demonstrates how to create a matrix using `math.matrix()`, retrieve its dimensions with `size()`, resize it using `resize()`, view its underlying array representation with `valueOf()`, and access a specific element using `get()`.

```javascript
let m = math.matrix([[1, 2], [3, 4]])
m.size()                        // Array [2, 2]
m.resize([3, 2], 5)
m.valueOf()                     // Array [[1, 2], [3, 4], [5, 5]]
m.get([1, 0])                    // number 3
```

--------------------------------

### JavaScript Examples for math.sparse Matrix Operations

Source: https://mathjs.org/docs/index.html/reference/functions/sparse

Illustrative JavaScript examples demonstrating how to create, resize, and access elements of sparse matrices using the `math.sparse` function and its associated methods like `size()`, `resize()`, `valueOf()`, and `get()`.

```JavaScript
let m = math.sparse([[1, 2], [3, 4]])
m.size()                        // Array [2, 2]
m.resize([3, 2], 5)
m.valueOf()                     // Array [[1, 2], [3, 4], [5, 5]]
m.get([1, 0])                    // number 3
let v = math.sparse([0, 0, 1])
v.size()                        // Array [3, 1]
v.get([2, 0])                   // number 1
```

--------------------------------

### math.smallerEq Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/smallerEq

Practical examples demonstrating the application of the `math.smallerEq` function, showing its comparison logic with different numerical expressions.

```javascript
math.smaller(1 + 2, 3)        // returns false
math.smallerEq(1 + 2, 3)      // returns true
```

--------------------------------

### JavaScript Examples: Get and Replace Subsets with math.subset

Source: https://mathjs.org/docs/index.html/reference/functions/subset

Illustrative JavaScript examples demonstrating how to use `math.subset` to retrieve specific elements or sub-arrays from a matrix/array and how to replace parts of a matrix/array with new values. Includes examples using `math.index` and `math.range`.

```JavaScript
// get a subset
const d = [[1, 2], [3, 4]]
math.subset(d, math.index(1, 0))             // returns 3
math.subset(d, math.index([0, 1], 1))        // returns [[2], [4]]
math.subset(d, math.index([false, true], 0)) // returns [[3]]

// replace a subset
const e = []
const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 0, 6]]
const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 0, 6], [0, 7, 0]]
math.subset(g, math.index([false, true], 1), 8)          // returns [[5, 0, 6], [0, 8, 0]]

// get submatrix using ranges
const M = [
  [1,2,3],
  [4,5,6],
  [7,8,9]
]
math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1, 2, 3], [4, 5, 6]]
```

--------------------------------

### math.catalan Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/catalan

Illustrative examples demonstrating how to use the `math.catalan` function with different integer inputs and their expected outputs.

```JavaScript
math.catalan(3) // returns 5
math.catalan(8) // returns 1430
```

--------------------------------

### Example Usage of math.combinationsWithRep

Source: https://mathjs.org/docs/index.html/reference/functions/combinationsWithRep

A practical example demonstrating how to use the `math.combinationsWithRep` function to calculate the number of combinations with replacement.

```javascript
math.combinationsWithRep(7, 5) // returns 462
```

--------------------------------

### JavaScript Examples for math.xgcd

Source: https://mathjs.org/docs/index.html/reference/functions/xgcd

Illustrative examples demonstrating the usage of the `math.xgcd` function with various integer inputs and their expected outputs. These examples show how to call the function and interpret its results, including a comparison with `math.gcd`.

```JavaScript
math.xgcd(8, 12)             // returns [4, -1, 1]
math.gcd(8, 12)              // returns 4
math.xgcd(36163, 21199)      // returns [1247, -7, 12]
```

--------------------------------

### math.js hypot Function Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/hypot

Practical examples demonstrating the application of the `math.hypot` function with various inputs, showcasing its behavior and expected outputs.

```JavaScript
math.hypot(3, 4)      // 5
math.hypot(3, 4, 5)   // 7.0710678118654755
math.hypot([3, 4, 5]) // 7.0710678118654755
math.hypot(-2)        // 2
```

--------------------------------

### JavaScript Example for math.lyap

Source: https://mathjs.org/docs/index.html/reference/functions/lyap

An example demonstrating how to use the `math.lyap` function in JavaScript with sample matrices A and Q to calculate the solution matrix P.

```javascript
const A = [[-2, 0], [1, -4]]
const Q = [[3, 1], [1, 3]]
const P = math.lyap(A, Q)
```

--------------------------------

### Creating and Using math.js Range Objects

Source: https://mathjs.org/docs/index.html/reference/classes/matrixrange

Demonstrates how to instantiate a `Range` object with different parameters (start, end, optional step) and basic operations like iteration (`forEach`), transformation (`map`), and conversion to an array (`toArray`). Includes examples of positive and negative steps for range creation.

```JavaScript
const range = new Range(start, end)
const range = new Range(start, end, step)
```

```JavaScript
range.forEach(function (x) {
    console.log(x)
})
range.map(function (x) {
    return math.sin(x)
})
range.toArray()
```

```JavaScript
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]
```

--------------------------------

### JavaScript Examples for math.symbolicEqual Usage

Source: https://mathjs.org/docs/index.html/reference/functions/symbolicEqual

Practical JavaScript examples demonstrating how to use the `math.symbolicEqual` function to check for symbolic equality between different mathematical expressions. These examples illustrate both basic usage and how to apply custom simplification contexts to influence the comparison results.

```JavaScript
math.symbolicEqual('x*y', 'y*x') // Returns true
math.symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}}) // Returns false
math.symbolicEqual('x/y', '(y*x^(-1))^(-1)') // Returns true
math.symbolicEqual('abs(x)','x') // Returns false
math.symbolicEqual('abs(x)','x', simplify.positiveContext) // Returns true
```

--------------------------------

### JavaScript examples for math.polynomialRoot

Source: https://mathjs.org/docs/index.html/reference/functions/polynomialRoot

Illustrates the usage of `math.polynomialRoot` with various examples for linear, quadratic, and cubic polynomials, including cases with real and complex coefficients.

```javascript
// linear
math.polynomialRoot(6, 3)                                        // [-2]
math.polynomialRoot(math.complex(6,3), 3)                        // [-2 - i]
math.polynomialRoot(math.complex(6,3), math.complex(2,1))        // [-3 + 0i]
// quadratic
math.polynomialRoot(2, -3, 1)                                    // [2, 1]
math.polynomialRoot(8, 8, 2)                                     // [-2]
math.polynomialRoot(-2, 0, 1)                                    // [1.4142135623730951, -1.4142135623730951]
math.polynomialRoot(2, -2, 1)                                    // [1 + i, 1 - i]
math.polynomialRoot(math.complex(1,3), math.complex(-3, -2), 1)  // [2 + i, 1 + i]
// cubic
math.polynomialRoot(-6, 11, -6, 1)                               // [1, 3, 2]
math.polynomialRoot(-8, 0, 0, 1)                                 // [-1 - 1.7320508075688774i, 2, -1 + 1.7320508075688774i]
math.polynomialRoot(0, 8, 8, 2)                                  // [0, -2]
math.polynomialRoot(1, 1, 1, 1)                                  // [-1 + 0i, 0 - i, 0 + i]
```

--------------------------------

### math.js setIsSubset Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/setIsSubset

Practical JavaScript examples demonstrating how to use the `math.setIsSubset` function. These examples illustrate different scenarios with array inputs and show the resulting boolean output, clarifying its behavior for both true and false subset conditions.

```javascript
math.setIsSubset([1, 2], [3, 4, 5, 6])        // returns false
math.setIsSubset([3, 4], [3, 4, 5, 6])        // returns true
```

--------------------------------

### math.nthRoot Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/nthRoot

Illustrative examples demonstrating how to use the math.js `nthRoot` function with different inputs. These examples show calculations for square roots and cube roots, including a comparison with the dedicated `sqrt` function.

```javascript
math.nthRoot(9, 2)    // returns 3 (since 3^2 == 9)
math.sqrt(9)          // returns 3 (since 3^2 == 9)
math.nthRoot(64, 3)   // returns 4 (since 4^3 == 64)
```

--------------------------------

### Example Usage of math.cosh in JavaScript

Source: https://mathjs.org/docs/index.html/reference/functions/cosh

A practical example demonstrating how to use the `math.cosh` function in JavaScript and its expected output.

```javascript
math.cosh(0.5)       // returns number 1.1276259652063807
```

--------------------------------

### Examples of math.zeta Function Usage

Source: https://mathjs.org/docs/index.html/reference/functions/zeta

Provides practical examples demonstrating how to use the `math.zeta` function with various numeric and complex inputs, illustrating the expected output values.

```javascript
math.zeta(5)       // returns 1.0369277551433895
math.zeta(-0.5)    // returns -0.2078862249773449
math.zeta(math.i)  // returns 0.0033002236853253153 - 0.4181554491413212i
```

--------------------------------

### JavaScript Examples for math.larger Function

Source: https://mathjs.org/docs/index.html/reference/functions/larger

Illustrative JavaScript examples demonstrating the usage of the `math.larger` function with various numerical and unit values. These examples show how to compare numbers directly and how to use `math.unit` for unit-based comparisons, highlighting the function's behavior.

```JavaScript
math.larger(2, 3)             // returns false
math.larger(5, 2 + 2)         // returns true

const a = math.unit('5 cm')
const b = math.unit('2 inch')
math.larger(a, b)             // returns false
```

--------------------------------

### JavaScript Examples for math.bitAnd Usage

Source: https://mathjs.org/docs/index.html/reference/functions/bitAnd

Illustrates the application of the `math.bitAnd` function with concrete examples, demonstrating its behavior with scalar numbers and array inputs in JavaScript.

```javascript
math.bitAnd(53, 131)               // returns number 1

math.bitAnd([1, 12, 31], 42)       // returns Array [0, 8, 10]
```

--------------------------------

### math.min Function Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/min

Practical JavaScript examples demonstrating how to use the `math.min` function with different types of inputs, including individual numbers, one-dimensional arrays, and multidimensional arrays with dimension-specific minimum calculations. A related `math.max` example is also included for context.

```JavaScript
math.min(2, 1, 4, 3)                  // returns 1
math.min([2, 1, 4, 3])                // returns 1

// minimum over a specified dimension (zero-based)
math.min([[2, 5], [4, 3], [1, 7]], 0) // returns [1, 3]
math.min([[2, 5], [4, 3], [1, 7]], 1) // returns [2, 3, 1]

math.max(2.7, 7.1, -4.5, 2.0, 4.1)    // returns 7.1
math.min(2.7, 7.1, -4.5, 2.0, 4.1)    // returns -4.5
```

--------------------------------

### math.freqz Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/freqz

Illustrative examples demonstrating how to use the `math.freqz` function with different inputs, showing both specifying the number of points and providing a custom frequency vector.

```JavaScript
math.freqz([1, 2], [1, 2, 3], 4) // returns { h: [0.5 + 0i, 0.4768589245763655 + 0.2861153547458193i, 0.25000000000000006 + 0.75i, -0.770976571635189 + 0.4625859429811135i], w: [0, 0.7853981633974483, 1.5707963267948966, 2.356194490192345 ] }
math.freqz([1, 2], [1, 2, 3], [0, 1]) // returns { h: [0.5 + 0i, 0.45436781 + 0.38598051i], w: [0, 1] }
```

--------------------------------

### JavaScript Examples for math.kron Function

Source: https://mathjs.org/docs/index.html/reference/functions/kron

Illustrative examples demonstrating the usage of the `math.kron` function to compute the Kronecker product of matrices and vectors in JavaScript. These examples show how to apply the function to 2D matrices and 1D vectors, along with their expected outputs.

```javascript
math.kron([[1, 0], [0, 1]], [[1, 2], [3, 4]])
// returns [ [ 1, 2, 0, 0 ], [ 3, 4, 0, 0 ], [ 0, 0, 1, 2 ], [ 0, 0, 3, 4 ] ]

math.kron([1,1], [2,3,4])
// returns [ [ 2, 3, 4, 2, 3, 4 ] ]
```

--------------------------------

### SymbolNode JavaScript Examples

Source: https://mathjs.org/docs/index.html/expressions/expression_trees

Provides JavaScript examples for creating `SymbolNode` instances. Demonstrates how to parse a symbol string using `math.parse` and how to directly instantiate a `SymbolNode` with a given name.

```JavaScript
const node = math.parse('x')

const x = new math.SymbolNode('x')
```

--------------------------------

### math.js csc() Function Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/csc

Demonstrates how to use the `csc` function and its equivalence to `1/sin(x)` in math.js with practical examples.

```JavaScript
math.csc(2)      // returns number 1.099750170294617
1 / math.sin(2)  // returns number 1.099750170294617
```

--------------------------------

### JavaScript Examples for math.mode function

Source: https://mathjs.org/docs/index.html/reference/functions/mode

Illustrative examples demonstrating the usage of the `math.mode` function with various input types and showing its output, including cases with single and multiple modes.

```JavaScript
math.mode(2, 1, 4, 3, 1)                            // returns [1]
math.mode([1, 2.7, 3.2, 4, 2.7])                    // returns [2.7]
math.mode(1, 4, 6, 1, 6)                             // returns [1, 6]
math.mode('a','a','b','c')                           // returns ["a"]
math.mode(1, 1.5, 'abc')                             // returns [1, 1.5, "abc"]
```

--------------------------------

### math.matrixFromRows Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/matrixFromRows

Practical examples demonstrating how to use the `math.matrixFromRows` function with different input formats, including explicit arrays and array spreading.

```JavaScript
math.matrixFromRows([1, 2, 3], [[4],[5],[6]])
math.matrixFromRows(...vectors)
```

--------------------------------

### JavaScript Examples for math.median function

Source: https://mathjs.org/docs/index.html/reference/functions/median

Provides practical JavaScript examples demonstrating how to use the `math.median` function with both individual numeric arguments and array inputs, showing the expected output for each case.

```JavaScript
math.median(5, 2, 7)        // returns 5
math.median([3, -1, 5, 7])  // returns 4
```

--------------------------------

### JavaScript Example for math.sinh

Source: https://mathjs.org/docs/index.html/reference/functions/sinh

An example demonstrating the usage of the `math.sinh` function in JavaScript, showing a typical numeric input and its corresponding calculated output.

```JavaScript
math.sinh(0.5)       // returns number 0.5210953054937474
```

--------------------------------

### Initialize Math.js with all functions

Source: https://mathjs.org/docs/index.html/custom_bundling

Demonstrates how to create a Math.js instance including all available functionality by passing the `all` object to `create`. This is the standard way to get a full Math.js build.

```JavaScript
import { create, all } from 'mathjs'

const math = create(all)
```

--------------------------------

### Examples of math.squeeze in JavaScript

Source: https://mathjs.org/docs/index.html/reference/functions/squeeze

Practical JavaScript examples demonstrating how to use the 'math.squeeze' function with various matrix and array inputs, illustrating its behavior in removing singleton dimensions.

```JavaScript
math.squeeze([3])           // returns 3
math.squeeze([[3]])         // returns 3

const A = math.zeros(3, 1)    // returns [[0], [0], [0]] (size 3x1)
math.squeeze(A)             // returns [0, 0, 0] (size 3)

const B = math.zeros(1, 3)    // returns [[0, 0, 0]] (size 1x3)
math.squeeze(B)             // returns [0, 0, 0] (size 3)

// only inner and outer dimensions are removed
const C = math.zeros(2, 1, 3) // returns [[[0, 0, 0]], [[0, 0, 0]]] (size 2x1x3)
math.squeeze(C)             // returns [[[0, 0, 0]], [[0, 0, 0]]] (size 2x1x3)
```

--------------------------------

### Initialize math.js Instance and Prepare for Import

Source: https://mathjs.org/docs/index.html/core/extension

This snippet demonstrates the initial setup of a math.js instance by importing `create` and `all` from the library. It then shows the basic structure for calling the `math.import` function, indicating where custom functions or variables would be added to extend the library's capabilities.

```javascript
import { create, all } from 'mathjs'

const math = create(all)

math.import(/* ... */)
```

--------------------------------

### Install External Libraries via npm

Source: https://mathjs.org/docs/index.html/core/extension

These commands show how to install external JavaScript libraries, specifically `numbers.js` and `numeric.js`, using the Node Package Manager (npm). These libraries are prerequisites for integrating their functionalities into a math.js instance, as demonstrated in subsequent examples.

```bash
$ npm install numbers
$ npm install numeric
```

--------------------------------

### Install math.js Globally via npm

Source: https://mathjs.org/docs/index.html/command_line_interface

Instructions on how to install the math.js library globally using npm, enabling command-line access. This typically requires admin rights.

```Bash
$ npm install -g mathjs
```

--------------------------------

### JavaScript Example: Get a Row from a Matrix using math.row

Source: https://mathjs.org/docs/index.html/reference/functions/row

Demonstrates how to use the `math.row` function in JavaScript to extract a specific row from a 2D array.

```javascript
// get a row
const d = [[1, 2], [3, 4]]
math.row(d, 1) // returns [[3, 4]]
```

--------------------------------

### JavaScript Example: Get a Column from a Matrix

Source: https://mathjs.org/docs/index.html/reference/functions/column

Illustrates how to use the `math.column` function in JavaScript to extract a specific column from a 2D array, showing the input and expected output.

```JavaScript
// get a column
const d = [[1, 2], [3, 4]]
math.column(d, 1) // returns [[2], [4]]
```

--------------------------------

### math.unequal Function Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/unequal

Practical JavaScript examples demonstrating the application of the `math.unequal` function for comparing different types of values, including numbers, units, and arrays, and illustrating its behavior with `null`.

```javascript
math.unequal(2 + 2, 3)       // returns true
math.unequal(2 + 2, 4)       // returns false

const a = math.unit('50 cm')
const b = math.unit('5 m')
math.unequal(a, b)           // returns false

const c = [2, 5, 1]
const d = [2, 7, 1]

math.unequal(c, d)           // returns [false, true, false]
math.deepEqual(c, d)         // returns false

math.unequal(0, null)        // returns true
```

--------------------------------

### Node.js math.js Configuration Examples

Source: https://mathjs.org/docs/index.html/core/configuration

This example shows how to configure math.js specifically for a Node.js environment, demonstrating how to switch between 'Array' and 'Matrix' output for ranges, and how to create an instance configured for 'BigNumber' with custom precision.

```JavaScript
import { create, all } from 'mathjs'

const config = {
  matrix: 'Array' // Choose 'Matrix' (default) or 'Array'
}
const math = create(all, config)

// range will output an Array
math.range(0, 4) // Array [0, 1, 2, 3]

// change the configuration from Arrays to Matrices
math.config({
  matrix: 'Matrix' // Choose 'Matrix' (default) or 'Array'
})

// range will output a Matrix
math.range(0, 4) // Matrix [0, 1, 2, 3]

// create an instance of math.js with BigNumber configuration
const bigmath = create(all, {
  number: 'BigNumber', // Choose 'number' (default), 'BigNumber', or 'Fraction'
  precision: 32        // 64 by default, only applicable for BigNumbers
})

// parser will parse numbers as BigNumber now:
bigmath.evaluate('1 / 3') // BigNumber, 0.33333333333333333333333333333333
```

--------------------------------

### math.js Unit: Get Value Type

Source: https://mathjs.org/docs/index.html/datatypes/units

Retrieves the string name indicating the data type of the current value held by the Unit object. Examples of returned types include 'number' or 'BigNumber', reflecting the internal representation.

```APIDOC
unit.valType()
```

--------------------------------

### JavaScript Examples for math.unit Function Usage

Source: https://mathjs.org/docs/index.html/reference/functions/unit

Demonstrates practical usage of the `math.unit` function in JavaScript, showing how to initialize units with different inputs (e.g., a number and a string, or just a string) and how to perform unit conversions.

```JavaScript
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
```

--------------------------------

### Interactive math.js CLI Examples

Source: https://mathjs.org/docs/index.html/command_line_interface

Demonstrates various mathematical expressions and unit conversions executed interactively within the math.js command-line prompt.

```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
```

--------------------------------

### Examples of math.derivative Usage

Source: https://mathjs.org/docs/index.html/reference/functions/derivative

Illustrative examples demonstrating how to use the `math.derivative` function with various expressions and options, including evaluating the results and using parsed nodes.

```JavaScript
math.derivative('x^2', 'x')                     // Node '2 * x'
math.derivative('x^2', 'x', {simplify: false})  // Node '2 * 1 * x ^ (2 - 1)'
math.derivative('sin(2x)', 'x'))                // Node '2 * cos(2 * x)'
math.derivative('2*x', 'x').evaluate()          // number 2
math.derivative('x^2', 'x').evaluate({x: 4})    // number 8
const f = math.parse('x^2')
const x = math.parse('x')
math.derivative(f, x)                           // Node {2 * x}
```

--------------------------------

### math.js CLI Script and Stream Handling

Source: https://mathjs.org/docs/index.html/command_line_interface

Examples of using the math.js command-line tool to open a prompt, execute script files, redirect output, and process input 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
```

--------------------------------

### Get and Set Single Matrix Values in math.js

Source: https://mathjs.org/docs/index.html/datatypes/matrices

This JavaScript example illustrates the `matrix.get()` and `matrix.set()` methods for accessing and modifying individual elements within a math.js matrix. It highlights that `set()` mutates the original matrix and can automatically resize it, with an option to specify a `defaultValue` for new elements.

```JavaScript
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
```

--------------------------------

### Get and Replace Matrix Subsets with math.js

Source: https://mathjs.org/docs/index.html/datatypes/matrices

This JavaScript example demonstrates how to use `math.subset` with `math.index` to extract or modify portions of arrays and matrices. It shows various indexing patterns, including single elements, ranges, and multi-dimensional subsets, and illustrates both returning a subset and replacing a subset (on a clone or in-place).

```JavaScript
// 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]]
```

--------------------------------

### Basic math.js Integration and Configuration in Browser

Source: https://mathjs.org/docs/index.html/core/configuration

This HTML snippet illustrates the fundamental steps to include and utilize the math.js library in a web browser. It covers initial setup, dynamically changing the output format from Matrix to Array, and creating a new math.js instance configured to handle BigNumbers with a specified precision.

```HTML
<!DOCTYPE HTML>
<html>
<head>
  <script src="math.js" type="text/javascript"></script>
</head>
<body>
  <script type="text/javascript">
    // the default instance of math.js is available as 'math'

    // range will output a Matrix
    math.range(0, 4)          // Matrix [0, 1, 2, 3]

    // change the configuration of math from Matrices to Arrays
    math.config({
      matrix: 'Array'         // Choose 'Matrix' (default) or 'Array'
    })

    // range will output an Array
    math.range(0, 4)          // Array [0, 1, 2, 3]

    // create a new instance of math.js with bignumber configuration
    const bigmath = math.create({
      number: 'BigNumber',    // Choose 'number' (default), 'BigNumber', or 'Fraction'
      precision: 32           // 64 by default, only applicable for BigNumbers
    })

    // parser will parse numbers as BigNumber now:
    bigmath.evaluate('1 / 3') // BigNumber, 0.33333333333333333333333333333333
  </script>
</body>
</html>
```

```JavaScript
// the default instance of math.js is available as 'math'

// range will output a Matrix
math.range(0, 4)          // Matrix [0, 1, 2, 3]

// change the configuration of math from Matrices to Arrays
math.config({
  matrix: 'Array'         // Choose 'Matrix' (default) or 'Array'
})

// range will output an Array
math.range(0, 4)          // Array [0, 1, 2, 3]

// create a new instance of math.js with bignumber configuration
const bigmath = math.create({
  number: 'BigNumber',    // Choose 'number' (default), 'BigNumber', or 'Fraction'
  precision: 32           // 64 by default, only applicable for BigNumbers
})

// parser will parse numbers as BigNumber now:
bigmath.evaluate('1 / 3') // BigNumber, 0.33333333333333333333333333333333
```

--------------------------------

### Combine Custom Functions with Direct Function Node LaTeX Handler

Source: https://mathjs.org/docs/index.html/expressions/customization

Demonstrates integrating custom functions with a direct callback handler for `toTex` to provide specific LaTeX output for user-defined functions like 'binomial' when encountered as a `FunctionNode`. The example shows the full setup and application.

```javascript
const customFunctions = {
  binomial: function (n, k) {
    //calculate n choose k
    // (do some stuff)
    return result
  }
}

function customLaTeX(node, options) {
  if ((node.type === 'FunctionNode') && (node.name === 'binomial')) {
      return '\\binom{' + node.args[0].toTex(options) + '}{' + node.args[1].toTex(options) + '}'
  }
}

math.import(customFunctions)
const expression = math.parse('binomial(2,1)')
const latex = expression.toTex({handler: customLaTeX})
// latex now contains "\\binom{2}{1}"
```

--------------------------------

### JavaScript Examples for math.index Usage

Source: https://mathjs.org/docs/index.html/reference/functions/index

Practical JavaScript examples demonstrating the application of `math.index`. The first example shows how to use `math.index` with `math.subset` to extract a sub-array from a one-dimensional array. The second example illustrates accessing a specific element within a `math.matrix` using `math.index`.

```JavaScript
const b = [1, 2, 3, 4, 5]
math.subset(b, math.index([1, 2, 3]))     // returns [2, 3, 4]

const a = math.matrix([[1, 2], [3, 4]])
a.subset(math.index(0, 1))             // returns 2
```

--------------------------------

### Initialize math.js with Configuration and Read Current Settings

Source: https://mathjs.org/docs/index.html/core/configuration

This snippet demonstrates how to create a math.js instance with an initial configuration object, read the currently applied configuration, and then dynamically change a specific setting like the number type.

```JavaScript
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'
})
```

--------------------------------

### math.resize JavaScript Examples

Source: https://mathjs.org/docs/index.html/reference/functions/resize

Illustrates various use cases of the `math.resize` function in JavaScript, showing how to resize arrays, numbers, and strings with different parameters and expected outputs.

```javascript
math.resize([1, 2, 3, 4, 5], [3]) // returns Array  [1, 2, 3]
math.resize([1, 2, 3], [5], 0)    // returns Array  [1, 2, 3, 0, 0]
math.resize(2, [2, 3], 0)         // returns Matrix [[2, 0, 0], [0, 0, 0]]
math.resize("hello", [8], "!")    // returns string 'hello!!!'
```

--------------------------------

### math.or Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/or

Illustrative examples demonstrating how to use the `math.or` function with various input types, including scalar numbers and arrays. These examples show how the function evaluates to a boolean for scalars and element-wise for arrays.

```javascript
math.or(2, 4)   // returns true

a = [2, 5, 0]
b = [0, 22, 0]
c = 0

math.or(a, b)   // returns [true, true, false]
math.or(b, c)   // returns [false, true, false]
```

--------------------------------

### JavaScript Examples for math.zeros

Source: https://mathjs.org/docs/index.html/reference/functions/zeros

Illustrative JavaScript examples demonstrating the usage of the `math.zeros` function with different arguments and expected outputs, including creating empty arrays, 1D arrays, 2D matrices, and using existing matrix sizes.

```javascript
math.zeros()                   // returns []
math.zeros(3)                  // returns [0, 0, 0]
math.zeros(3, 2)               // returns [[0, 0], [0, 0], [0, 0]]
math.zeros(3, 'dense')         // returns [0, 0, 0]

const A = [[1, 2, 3], [4, 5, 6]]
math.zeros(math.size(A))       // returns [[0, 0, 0], [0, 0, 0]]
```

--------------------------------

### math.js REPL for Debugging

Source: https://mathjs.org/docs/index.html/command_line_interface

How to start the math.js REPL (Read-Eval-Print Loop) for debugging, demonstrating parsing an expression and inspecting its structure.

```Bash
$ ./bin/repl.js
> math.parse('1+1')
{ op: '+',
  fn: 'add',
  args:
   [ { value: '1', valueType: 'number' },
     { value: '1', valueType: 'number' } ] }
>
```

--------------------------------

### math.js coth Function Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/coth

Illustrative JavaScript examples demonstrating how to use the `math.coth` function to calculate the hyperbolic cotangent of a number. The examples also show its mathematical equivalence to `1 / math.tanh(x)`.

```javascript
// coth(x) = 1 / tanh(x)
math.coth(2)         // returns 1.0373147207275482
1 / math.tanh(2)     // returns 1.0373147207275482
```

--------------------------------

### math.log2 Function Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/log2

Illustrates practical examples of using the `math.log2` function in math.js. These examples demonstrate how to calculate the base-2 logarithm for different numeric inputs and show its relationship with other math.js functions like `math.pow`.

```javascript
math.log2(0.03125)           // returns -5
math.log2(16)                // returns 4
math.log2(16) / math.log2(2) // returns 4
math.pow(2, 4)               // returns 16
```

--------------------------------

### math.prod Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/prod

These examples demonstrate how to use the `math.prod` function with different types of inputs. They illustrate its application with individual scalar values, arrays of numbers, and multi-dimensional matrices, showing the resulting product in each case.

```javascript
math.multiply(2, 3)           // returns 6
math.prod(2, 3)               // returns 6
math.prod(2, 3, 4)            // returns 24
math.prod([2, 3, 4])          // returns 24
math.prod([[2, 5], [4, 3]])   // returns 120
```

--------------------------------

### JavaScript Examples for math.rightLogShift

Source: https://mathjs.org/docs/index.html/reference/functions/rightLogShift

Illustrative examples demonstrating the usage of `math.rightLogShift` with single numbers and arrays.

```JavaScript
math.rightLogShift(4, 2)               // returns number 1

math.rightLogShift([16, 32, 64], 4)    // returns Array [1, 2, 4]
```

--------------------------------

### Create Math.js instance with specific functions

Source: https://mathjs.org/docs/index.html/custom_bundling

Shows how to create a Math.js instance with only a subset of functions (e.g., `fraction`, `add`, `divide`, `format`) by importing their respective dependency collections and passing them to the `create` function. This significantly reduces bundle size. Includes an example of using the created functions.

```JavaScript
// 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"
```

--------------------------------

### math.max Function Usage Examples

Source: https://mathjs.org/docs/index.html/reference/functions/max

Practical examples demonstrating how to use the `math.max` function with different inputs, including scalar values, one-dimensional arrays, and multidimensional arrays with dimension-specific maximum calculations. An example of `math.min` is also included for comparison.

```JavaScript
math.max(2, 1, 4, 3)                  // returns 4
math.max([2, 1, 4, 3])                // returns 4

// maximum over a specified dimension (zero-based)
math.max([[2, 5], [4, 3], [1, 7]], 0) // returns [4, 7]
math.max([[2, 5], [4, 3], [1, 7]], 1) // returns [5, 4, 7]

math.max(2.7, 7.1, -4.5, 2.0, 4.1)    // returns 7.1
math.min(2.7, 7.1, -4.5, 2.0, 4.1)    // returns -4.5
```
Tokens:
Raw