mathjs

property index

index: IndexNode;

property isAccessorNode

isAccessorNode: true;

property name

name: string;

property object

object: TObject;

property type

type: 'AccessorNode';

construct signature

new <TObject extends MathNode = MathNode>(
    object: TObject,
    index: IndexNode
): AccessorNode<TObject>;

property isArrayNode

isArrayNode: true;

property items

items: [...TItems];

property type

type: 'ArrayNode';

construct signature

new <TItems extends MathNode[] = MathNode[]>(
    items: [...TItems]
): ArrayNode<TItems>;

property index

index: IndexNode | null;

property isAssignmentNode

isAssignmentNode: true;

property name

name: string;

property object

object: SymbolNode | AccessorNode;

property type

type: 'AssignmentNode';

property value

value: TValue;

construct signature

new <TValue extends MathNode = MathNode>(
    object: SymbolNode,
    value: TValue
): AssignmentNode<TValue>;

construct signature

new <TValue extends MathNode = MathNode>(
    object: SymbolNode | AccessorNode,
    index: IndexNode,
    value: TValue
): AssignmentNode<TValue>;

property dimensions

dimensions: number[];

property key

key: string;

property blocks

blocks: Array<{ node: TNode; visible: boolean }>;

property isBlockNode

isBlockNode: true;

property type

type: 'BlockNode';

construct signature

new <TNode extends MathNode = MathNode>(
    arr: Array<{ node: TNode } | { node: TNode; visible: boolean }>
): BlockNode;

property im

im: number;

property re

re: number;

method clone

clone: () => Complex;

method compare

compare: (a: Complex, b: Complex) => number;

method equals

equals: (other: Complex) => boolean;

method format

format: (precision?: number) => string;

method fromJSON

fromJSON: (json: object) => Complex;

method fromPolar

fromPolar: { (polar: object): Complex; (r: number, phi: number): Complex };

method toJSON

toJSON: () => object;

method toPolar

toPolar: () => PolarCoordinates;

method toString

toString: () => string;

property condition

condition: TCond;

property falseExpr

falseExpr: TFalseNode;

property isConditionalNode

isConditionalNode: boolean;

property trueExpr

trueExpr: TTrueNode;

property type

type: 'ConditionalNode';

construct signature

new <
    TCond extends MathNode = MathNode,
    TTrueNode extends MathNode = MathNode,
    TFalseNode extends MathNode = MathNode
>(
    condition: TCond,
    trueExpr: TTrueNode,
    falseExpr: TFalseNode
): ConditionalNode;

property absTol

absTol?: number;

property epsilon

epsilon?: number;

• Deprecated

  Use relTol and absTol instead

property matrix

matrix?: 'Matrix' | 'Array';

property number

number?: 'number' | 'BigNumber' | 'bigint' | 'Fraction';

property numberFallback

numberFallback?: 'number' | 'BigNumber';

property precision

precision?: number;

property predictable

predictable?: boolean;

property randomSeed

randomSeed?: string | null;

property relTol

relTol?: number;

property isConstantNode

isConstantNode: true;

property type

type: 'ConstantNode';

property value

value: TValue;

construct signature

new <TValue extends string | number = string>(
    value: TValue
): ConstantNode<TValue>;

property aliases

aliases?: string[];

property offset

offset?: number;

property override

override?: boolean;

property prefixes

prefixes?: 'none' | 'short' | 'long' | 'binary_short' | 'binary_long';

method pickRandom

pickRandom: (array: any) => any;

method random

random: (size: any, min?: any, max?: any) => any;

method randomInt

randomInt: (min: any, max?: any) => any;

method evaluate

evaluate: (scope?: any) => any;

index signature

[key: string]: FactoryFunction<any> | FactoryFunctionMap;

property fraction

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.

property lowerExp

lowerExp?: number | BigNumber;

• Exponent determining the lower boundary for formatting a value with an exponent when notation='auto. Default value is -3.

property notation

notation?:
    | 'fixed'
    | 'exponential'
    | 'engineering'
    | 'auto'
    | 'hex'
    | 'bin'
    | 'oct';

• 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' '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'.

property precision

precision?: number | BigNumber;

• A number between 0 and 16 to round the digits of the number. In case of notations 'exponential' and 'auto', precision defines the total number of significant digits returned and is undefined by default. In case of notation 'fixed', precision defines the number of significant digits after the decimal point, and is 0 by default.

property upperExp

upperExp?: number | BigNumber;

• Exponent determining the upper boundary for formatting a value with an exponent when notation='auto. Default value is 5.

property wordSize

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.

property d

d: number;

property n

n: number;

property s

s: number;

property a

a: number;

property b

b: number;

property expr

expr: TExpr;

property isFunctionAssignmentNode

isFunctionAssignmentNode: true;

property name

name: string;

property params

params: string[];

property type

type: 'FunctionAssignmentNode';

construct signature

new <TExpr extends MathNode = MathNode>(
    name: string,
    params: string[],
    expr: TExpr
): FunctionAssignmentNode<TExpr>;

property args

args: [...TArgs];

property fn

fn: TFn;

property isFunctionNode

isFunctionNode: true;

property type

type: 'FunctionNode';

property onUndefinedFunction

onUndefinedFunction: (name: string) => any;

construct signature

new <TFn = SymbolNode, TArgs extends MathNode[] = MathNode[]>(
    fn: TFn,
    args: [...TArgs]
): FunctionNode<TFn, TArgs>;

method toJSON

toJSON: () => string;

method toString

toString: () => string;

index signature

[key: string]: any;

property override

override?: boolean;

property silent

silent?: boolean;

property wrap

wrap?: boolean;

property dimensions

dimensions: [...TDims];

property dotNotation

dotNotation: boolean;

property isIndexNode

isIndexNode: true;

property type

type: 'IndexNode';

construct signature

new <TDims extends MathNode[] = MathNode[]>(dimensions: [...TDims]): IndexNode;

construct signature

new <TDims extends MathNode[] = MathNode[]>(
    dimensions: [...TDims],
    dotNotation: boolean
): IndexNode<TDims>;

property L

L: MathCollection;

property p

p: number[];

property U

U: MathCollection;

method abs

abs: <T extends MathType>(this: MathJsChain<T>) => MathJsChain<T>;

• Calculate the absolute value of a number. For matrices, the function is evaluated element wise.

method acos

acos: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse cosine of a value. For matrices, the function is evaluated element wise.

method acosh

acosh: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• 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.

method acot

acot: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse cotangent of a value. For matrices, the function is evaluated element wise.

method acoth

acoth: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse hyperbolic tangent of a value, defined as acoth(x) = (ln((x+1)/x) + ln(x/(x-1))) / 2. For matrices, the function is evaluated element wise.

method acsc

acsc: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse cosecant of a value. For matrices, the function is evaluated element wise.

method acsch

acsch: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse hyperbolic cosecant of a value, defined as acsch(x) = ln(1/x + sqrt(1/x^2 + 1)). For matrices, the function is evaluated element wise.

method add

add: {
    <T extends MathType>(this: MathJsChain<T>, y: T): MathJsChain<T>;
    (this: MathJsChain<MathType>, y: MathType): MathJsChain<MathType>;
};

• Add two values, x + y. For matrices, the function is evaluated element wise.

  Parameter y

  Second value to add

method and

and: (
    this: MathJsChain<
        number | BigNumber | bigint | Complex | Unit | MathCollection
    >,
    y: number | BigNumber | bigint | Complex | Unit | MathCollection
) => MathJsChain<boolean | MathCollection>;

• Logical and. Test whether two values are both defined with a nonzero/nonempty value. For matrices, the function is evaluated element wise.

  Parameter y

  Second value to and

method apply

apply: <T extends MathCollection>(
    this: MathJsChain<T>,
    dim: number,
    callback: (array: Array<MathType> | Matrix) => number
) => MathJsChain<T>;

• Apply a function that maps an array to a scalar along a given axis of the matrix or array. Returns a new matrix or array with one less dimension than the input.

  Parameter dim

  The dimension along which the callback is applied

  Parameter callback

  The callback function that is applied. This Function should take an array or 1-d matrix as an input and return a number.

  Returns

  The residual matrix with the function applied over some dimension.

method arg

arg: {
    (this: MathJsChain<number | Complex>): MathJsChain<number>;
    (this: MathJsChain<BigNumber | Complex>): MathJsChain<BigNumber>;
    (this: MathJsChain<MathArray>): MathJsChain<MathArray>;
    (this: MathJsChain<Matrix>): MathJsChain<Matrix>;
};

• 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.

method asec

asec: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse secant of a value. For matrices, the function is evaluated element wise.

method asech

asech: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the hyperbolic arcsecant of a value, defined as asech(x) = ln(sqrt(1/x^2 - 1) + 1/x). For matrices, the function is evaluated element wise.

method asin

asin: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse sine of a value. For matrices, the function is evaluated element wise.

method asinh

asinh: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the hyperbolic arcsine of a value, defined as asinh(x) = ln(x + sqrt(x^2 + 1)). For matrices, the function is evaluated element wise.

method atan

atan: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the inverse tangent of a value. For matrices, the function is evaluated element wise.

method atan2

atan2: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>,
    x: number
) => MathJsChain<T>;

• 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.

method atanh

atanh: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the hyperbolic arctangent of a value, defined as atanh(x) = ln((1 + x)/(1 - x)) / 2. For matrices, the function is evaluated element wise.

method bellNumbers

bellNumbers: {
    (this: MathJsChain<number>): MathJsChain<number>;
    (this: MathJsChain<BigNumber>): MathJsChain<BigNumber>;
};

• 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

method bigint

bigint: {
    (
        this: MathJsChain<
            number | string | Fraction | BigNumber | bigint | boolean | null
        >
    ): MathJsChain<bigint>;
    <T extends MathCollection>(this: MathJsChain<T>): MathJsChain<T>;
};

• Create a bigint, which can store integers with arbitrary precision. When a matrix is provided, all elements will be converted to bigint.

method bignumber

bignumber: {
    (
        this: MathJsChain<
            | number
            | string
            | Fraction
            | BigNumber
            | bigint
            | Unit
            | boolean
            | null
        >
    ): MathJsChain<BigNumber>;
    <T extends MathCollection>(this: MathJsChain<T>): MathJsChain<T>;
};

• Create a BigNumber, which can store numbers with arbitrary precision. When a matrix is provided, all elements will be converted to BigNumber.

method bitAnd

bitAnd: <T extends number | bigint | MathCollection | BigNumber>(
    this: MathJsChain<T>,
    y: number | BigNumber | bigint | MathCollection
) => MathJsChain<NoLiteralType<T>>;

• Bitwise AND two values, x & y. For matrices, the function is evaluated element wise.

  Parameter y

  Second value to and

method bitNot

bitNot: <T extends number | bigint | MathCollection | BigNumber>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Bitwise NOT value, ~x. For matrices, the function is evaluated element wise. For units, the function is evaluated on the best prefix base.

method bitOr

bitOr: <T extends number | bigint | MathCollection | BigNumber>(
    this: MathJsChain<T>,
    y: T
) => MathJsChain<T>;

• 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 y

  Second value to or

method bitXor

bitXor: <T extends number | bigint | MathCollection | BigNumber>(
    this: MathJsChain<T>,
    y: number | BigNumber | bigint | MathCollection
) => MathJsChain<NoLiteralType<T>>;

• Bitwise XOR two values, x ^ y. For matrices, the function is evaluated element wise.

  Parameter y

  Second value to xor

method boolean

boolean: {
    (this: MathJsChain<string | number | boolean | null>): MathJsChain<boolean>;
    (this: MathJsChain<MathCollection>): MathJsChain<MathCollection>;
};

• 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.

method catalan

catalan: {
    (this: MathJsChain<number>): MathJsChain<number>;
    (this: MathJsChain<BigNumber>): MathJsChain<BigNumber>;
};

• The Catalan Numbers enumerate combinatorial structures of many different types. catalan only takes integer arguments. The following condition must be enforced: n >= 0

method cbrt

cbrt: <T extends number | BigNumber | Unit | Complex>(
    this: MathJsChain<T>,
    allRoots?: boolean
) => MathJsChain<T>;

• Calculate the cubic root of a value. For matrices, the function is evaluated element wise.

  Parameter allRoots

  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.

method ceil

ceil: <T extends MathCollection | MathNumericType>(
    this: MathJsChain<T>,
    n?: number | BigNumber | MathCollection
) => MathJsChain<T>;

• 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 n

  Number of decimals Default value: 0.

method clone

clone: <TValue>(this: MathJsChain<TValue>) => MathJsChain<TValue>;

• Clone an object.

method combinations

combinations: <T extends number | BigNumber>(
    n: MathJsChain<T>,
    k: number | BigNumber
) => MathJsChain<NoLiteralType<T>>;

• 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 k

  Number of objects in the subset

method compare

compare: (
    this: MathJsChain<MathType | string>,
    y: MathType | string
) => MathJsChain<number | BigNumber | Fraction | MathCollection>;

• 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 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.

  Parameter y

  Second value to compare

method compareNatural

compareNatural: (this: MathJsChain<any>, y: any) => MathJsChain<number>;

• 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.

  Parameter y

  Second value to compare

method compareText

compareText: (
    this: MathJsChain<string | MathCollection>,
    y: string | MathCollection
) => MathJsChain<number | MathCollection>;

• 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.

  Parameter y

  Second string to compare

method compile

compile: (this: MathJsChain<MathExpression>) => MathJsChain<EvalFunction>;

• Parse and compile an expression. Returns a an object with a function evaluate([scope]) to evaluate the compiled expression.

method complex

complex: {
    (
        this: MathJsChain<Complex | string | PolarCoordinates>,
        im?: number
    ): MathJsChain<Complex>;
    (this: MathJsChain<MathCollection>): MathJsChain<MathCollection>;
};

• Create a complex value or convert a value to a complex value.

  Parameter im

  Argument specifying the imaginary part of the complex number

method composition

composition: <T extends number | BigNumber>(
    this: MathJsChain<T>,
    k: number | BigNumber
) => MathJsChain<NoLiteralType<T>>;

• The composition counts of n into k parts. Composition only takes integer arguments. The following condition must be enforced: k <= n.

  Parameter k

  Number of objects in the subset

method concat

concat: (
    this: MathJsChain<Array<MathCollection | number | BigNumber>>
) => MathJsChain<MathCollection>;

• Concatenate two or more matrices. dim: number is a zero-based dimension over which to concatenate the matrices. By default the last dimension of the matrices.

method conj

conj: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<NoLiteralType<T>>;

• 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.

method cos

cos: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the cosine of a value. For matrices, the function is evaluated element wise.

method cosh

cosh: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the hyperbolic cosine of a value, defined as cosh(x) = 1/2 * (exp(x) + exp(-x)). For matrices, the function is evaluated element wise.

method cot

cot: <T extends number | MathCollection | BigNumber | Complex>(
    this: MathJsChain<T>
) => MathJsChain<T>;

• Calculate the cotangent of a value. cot(x) is defined as 1 / tan(x). For matrices, the function is evaluated element wise.