mathjs
Version:
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 dif
1,350 lines (1,228 loc) • 192 kB
TypeScript
import { Decimal } from 'decimal.js';
declare const math: math.MathJsStatic;
export as namespace math;
export = math;
type NoLiteralType<T> =
T extends number ? number :
T extends string ? string :
T extends boolean ? boolean :
T;
declare namespace math {
type MathArray = number[] | number[][];
type MathType = number | BigNumber | Fraction | Complex | Unit | MathArray | Matrix;
type MathExpression = string | string[] | MathArray | Matrix;
type FactoryFunction<T> = (scope: any) => T;
// FactoryFunctionMap can be nested; all nested objects will be flattened
interface FactoryFunctionMap {
[key: string]: FactoryFunction<any> | FactoryFunctionMap;
}
/** Available options for parse */
interface ParseOptions {
/** a set of custom nodes */
nodes?: Record<string, MathNode>;
}
/**
* 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.
*
* Syntax:
*
* math.parse(expr)
* math.parse(expr, options)
* math.parse([expr1, expr2, expr3, ...])
* math.parse([expr1, expr2, expr3, ...], options)
*
* Example:
*
* const node1 = math.parse('sqrt(3^2 + 4^2)')
* node1.compile().evaluate() // 5
*
* let scope = {a:3, b:4}
* const node2 = math.parse('a * b') // 12
* const code2 = node2.compile()
* code2.evaluate(scope) // 12
* scope.a = 5
* code2.evaluate(scope) // 20
*
* const nodes = math.parse(['a = 3', 'b = 4', 'a * b'])
* nodes[2].compile().evaluate() // 12
*
* See also:
*
* evaluate, compile
*/
interface ParseFunction {
/**
* Parse an expression. Returns a node tree, which can be evaluated by
* invoking node.evaluate();
*
* @param expr Expression to be parsed
* @param options Available options
* @returns A node
*/
(expr: MathExpression, options?: ParseOptions): MathNode;
/**
* Parse an expression. Returns a node tree, which can be evaluated by
* invoking node.evaluate();
*
* @param exprs Expressions to be parsed
* @param options Available options
* @returns An array of nodes
*/
(exprs: MathExpression[], options?: ParseOptions): MathNode[];
/**
* Checks whether the current character `c` is a valid alpha character:
*
* - 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 mathematical alphanumeric symbol Unicode: \u{1D400} - \u{1D7FF} excluding invalid code points
*
* The previous and next characters are needed to determine whether
* this character is part of a unicode surrogate pair.
*
* @param c Current character in the expression
* @param cPrev Previous character
* @param cNext Next character
*/
isAlpha(c: string, cPrev: string, cNext: string): boolean;
/**
* Test whether a character is a valid latin, greek, or letter-like character
*
* @param c
*/
isValidLatinOrGreek(c: string): boolean;
/**
* Test whether two given 16 bit characters form a surrogate pair of a
* unicode math symbol.
*
* https://unicode-table.com/en/
* https://www.wikiwand.com/en/Mathematical_operators_and_symbols_in_Unicode
*
* Note: In ES6 will be unicode aware:
* https://stackoverflow.com/questions/280712/javascript-unicode-regexes
* https://mathiasbynens.be/notes/es6-unicode-regex
*
* @param high
* @param low
*/
isValidMathSymbol(high: string, low: string): boolean;
/**
* Check whether given character c is a white space character: space, tab, or enter
*
* @param c
* @param nestingLevel
*/
isWhitespace(c: string, nestingLevel: number): boolean;
/**
* Test whether the character c is a decimal mark (dot).
* This is the case when it's not the start of a delimiter '.*', './', or '.^'
*
* @param c
* @param cNext
*/
isDecimalMark(c: string, cNext: string): boolean;
/**
* checks if the given char c is a digit or dot
*
* @param c a string with one character
*/
isDigitDot(c: string): boolean;
/**
* checks if the given char c is a digit
*
* @param c a string with one character
*/
isDigit(c: string): boolean;
/**
* checks if the given char c is a hex digit
*
* @param c a string with one character
*/
isHexDigit(c: string): boolean;
}
interface AccessorNode extends MathNodeCommon {
type: 'AccessorNode';
isAccessorNode: true;
object: MathNode;
index: IndexNode;
name: string;
}
interface AccessorNodeCtor {
new(object: MathNode, index: IndexNode): AccessorNode;
}
interface ArrayNode extends MathNodeCommon {
type: 'ArrayNode';
isArrayNode: true;
items: MathNode[];
}
interface ArrayNodeCtor {
new(items: MathNode[]): ArrayNode;
}
interface AssignmentNode extends MathNodeCommon {
type: 'AssignmentNode';
isAssignmentNode: true;
object: SymbolNode | AccessorNode;
index: IndexNode | null;
value: MathNode;
name: string;
}
interface AssignmentNodeCtor {
new(object: SymbolNode, value: MathNode): AssignmentNode;
new(object: SymbolNode | AccessorNode, index: IndexNode, value: MathNode): AssignmentNode;
}
interface BlockNode extends MathNodeCommon {
type: 'BlockNode';
isBlockNode: true;
blocks: Array<{node: MathNode, visible: boolean}>;
}
interface BlockNodeCtor {
new(arr: Array<{node: MathNode} | {node: MathNode, visible: boolean}>): BlockNode;
}
interface ConditionalNode extends MathNodeCommon {
type: 'ConditionalNode';
isConditionalNode: boolean;
condition: MathNode;
trueExpr: MathNode;
falseExpr: MathNode;
}
interface ConditionalNodeCtor {
new(condition: MathNode, trueExpr: MathNode, falseExpr: MathNode): ConditionalNode;
}
interface ConstantNode extends MathNodeCommon {
type: 'ConstantNode';
isConstantNode: true;
value: any;
}
interface ConstantNodeCtor {
new(constant: number): ConstantNode;
}
interface FunctionAssignmentNode extends MathNodeCommon {
type: 'FunctionAssignmentNode';
isFunctionAssignmentNode: true;
name: string;
params: string[];
expr: MathNode;
}
interface FunctionAssignmentNodeCtor {
new(name: string, params: string[], expr: MathNode): FunctionAssignmentNode;
}
interface FunctionNode extends MathNodeCommon {
type: 'FunctionNode';
isFunctionNode: true;
fn: SymbolNode;
args: MathNode[];
}
interface FunctionNodeCtor {
new(fn: MathNode | string, args: MathNode[]): FunctionNode;
}
interface IndexNode extends MathNodeCommon {
type: 'IndexNode';
isIndexNode: true;
dimensions: MathNode[];
dotNotation: boolean;
}
interface IndexNodeCtor {
new(dimensions: MathNode[]): IndexNode;
new(dimensions: MathNode[], dotNotation: boolean): IndexNode;
}
interface ObjectNode extends MathNodeCommon {
type: 'ObjectNode';
isObjectNode: true;
properties: Record<string, MathNode>;
}
interface ObjectNodeCtor {
new(properties: Record<string, MathNode>): ObjectNode;
}
interface OperatorNode extends MathNodeCommon {
type: 'OperatorNode';
isOperatorNode: true;
op: string;
fn: string;
args: MathNode[];
implicit: boolean;
isUnary(): boolean;
isBinary(): boolean;
}
interface OperatorNodeCtor {
new(op: string, fn: string, args: MathNode[], implicit?: boolean): OperatorNode;
}
interface ParenthesisNode extends MathNodeCommon {
type: 'ParenthesisNode';
isParenthesisNode: true;
content: MathNode;
}
interface ParenthesisNodeCtor {
new(content: MathNode): ParenthesisNode;
}
interface RangeNode extends MathNodeCommon {
type: 'RangeNode';
isRangeNode: true;
start: MathNode;
end: MathNode;
step: MathNode | null;
}
interface RangeNodeCtor {
new(start: MathNode, end: MathNode, step?: MathNode): RangeNode;
}
interface RelationalNode extends MathNodeCommon {
type: 'RelationalNode';
isRelationalNode: true;
conditionals: string[];
params: MathNode[];
}
interface RelationalNodeCtor {
new(conditionals: string[], params: MathNode[]): RelationalNode;
}
interface SymbolNode extends MathNodeCommon {
type: 'SymbolNode';
isSymbolNode: true;
name: string;
}
interface SymbolNodeCtor {
new(name: string): SymbolNode;
}
type MathNode = AccessorNode | ArrayNode | AssignmentNode | BlockNode | ConditionalNode | ConstantNode |
FunctionAssignmentNode | FunctionNode | IndexNode | ObjectNode | OperatorNode | ParenthesisNode | RangeNode |
RelationalNode | SymbolNode;
type MathJsFunctionName = keyof MathJsStatic;
interface MathJsStatic extends FactoryDependencies {
e: number;
pi: number;
i: number;
Infinity: number;
LN2: number;
LN10: number;
LOG2E: number;
LOG10E: number;
NaN: number;
phi: number;
SQRT1_2: number;
SQRT2: number;
tau: number;
// Class-like constructors
AccessorNode: AccessorNodeCtor;
ArrayNode: ArrayNodeCtor;
AssignmentNode: AssignmentNodeCtor;
BlockNode: BlockNodeCtor;
ConditionalNode: ConditionalNodeCtor;
ConstantNode: ConstantNodeCtor;
FunctionAssignmentNode: FunctionAssignmentNodeCtor;
FunctionNode: FunctionNodeCtor;
IndexNode: IndexNodeCtor;
ObjectNode: ObjectNodeCtor;
OperatorNode: OperatorNodeCtor;
ParenthesisNode: ParenthesisNodeCtor;
RangeNode: RangeNodeCtor;
RelationalNode: RelationalNodeCtor;
SymbolNode: SymbolNodeCtor;
/**
* If null were to be included in this interface, it would be
* auto-suggested as an import in VSCode. This causes issues because
* `null` is not a valid label.
*
* @see https://github.com/josdejong/mathjs/issues/2019
*/
// null: number;
uninitialized: any;
version: string;
expression: MathNode;
json: MathJsJson;
/*************************************************************************
* Core functions
************************************************************************/
/**
* Set configuration options for math.js, and get current options. Will
* emit a ‘config’ event, with arguments (curr, prev, changes).
* @param options 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.
* @returns Returns the current configuration
*/
config: (options: ConfigOptions) => ConfigOptions;
/**
* 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.
* @param name Optional name for the typed-function
* @param signatures Object with one or multiple function signatures
* @returns The created typed-function.
*/
typed: (name: string, signatures: Record<string, (...args: any[]) => any>) => (...args: any[]) => any;
/*************************************************************************
* Construction functions
************************************************************************/
/**
* Create a BigNumber, which can store numbers with arbitrary precision.
* When a matrix is provided, all elements will be converted to
* BigNumber.
* @param x Value for the big number, 0 by default.
* @returns The created bignumber
*/
bignumber(x?: number | string | Fraction | BigNumber | MathArray | Matrix | boolean | Fraction | null): BigNumber;
/**
* 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.
* @param x A value of any type
* @returns The boolean value
*/
boolean(x: string | number | boolean | MathArray | Matrix | null): boolean | MathArray | Matrix;
/**
* 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.
* @param value A value of any type on which to start a chained
* operation.
* @returns The created chain
*/
chain(value?: any): MathJsChain;
/**
* Create a complex value or convert a value to a complex value.
* @param args Arguments specifying the real and imaginary part of the
* complex number
* @returns Returns a complex value
*/
complex(arg?: Complex | string | PolarCoordinates): Complex;
complex(arg?: MathArray | Matrix): MathArray | Matrix;
/**
* @param re Argument specifying the real part of the complex number
* @param im Argument specifying the imaginary part of the complex
* number
* @returns Returns a complex value
*/
complex(re: number, im: number): Complex;
/**
* Create a user-defined unit and register it with the Unit type.
* @param name The name of the new unit. Must be unique. Example: ‘knot’
* @param definition Definition of the unit in terms of existing units.
* For example, ‘0.514444444 m / s’.
* @param options (optional) An object containing any of the following
* properties:</br>- prefixes {string} “none”, “short”, “long”,
* “binary_short”, or “binary_long”. The default is “none”.</br>-
* aliases {Array} Array of strings. Example: [‘knots’, ‘kt’,
* ‘kts’]</br>- offset {Numeric} An offset to apply when converting from
* the unit. For example, the offset for celsius is 273.15. Default is
* 0.
* @returns The new unit
*/
createUnit(name: string, definition?: string | UnitDefinition, options?: CreateUnitOptions): Unit;
/**
* Create a user-defined unit and register it with the Unit type.
* @param units Definition of the unit
* @param options
* @returns The new unit
*/
createUnit(units: Record<string, string | UnitDefinition>, options?: CreateUnitOptions): Unit;
/**
* Create a fraction convert a value to a fraction.
* @param args Arguments specifying the numerator and denominator of the
* fraction
* @returns Returns a fraction
*/
fraction(args: Fraction | MathArray | Matrix): Fraction | MathArray | Matrix;
/**
* @param numerator Argument specifying the numerator of the fraction
* @param denominator Argument specifying the denominator of the
* fraction
* @returns Returns a fraction
*/
fraction(
numerator: number | string | MathArray | Matrix,
denominator?: number | string | MathArray | Matrix
): Fraction | MathArray | Matrix;
/**
* 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.
* @param ranges Zero or more ranges or numbers.
* @returns Returns the created index
*/
index(...ranges: any[]): Index;
/**
* Create a Matrix. The function creates a new math.type.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'.
* @param format The Matrix storage format
* @returns The created Matrix
*/
matrix(format?: 'sparse' | 'dense'): Matrix;
/**
* @param data A multi dimensional array
* @param format The Matrix storage format
* @param dataType The Matrix data type
* @returns The created Matrix
*/
matrix(data: MathArray | Matrix, format?: 'sparse' | 'dense', dataType?: string): Matrix;
/**
* Create a number or convert a string, boolean, or unit to a number.
* When value is a matrix, all elements will be converted to number.
* @param value Value to be converted
* @returns The created number
*/
number(value?: string | number | BigNumber | Fraction | boolean | MathArray | Matrix | Unit | null): number | MathArray | Matrix;
/**
* @param value Value to be converted
* @param valuelessUnit A valueless unit, used to convert a unit to a
* number
* @returns The created number
*/
number(unit: Unit, valuelessUnit: Unit | string): number;
/**
* Create a Sparse Matrix. The function creates a new math.type.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.
* @param data A two dimensional array
* @param dataType Sparse Matrix data type
* @returns The created matrix
*/
sparse(data?: MathArray | Matrix, dataType?: string): Matrix;
/**
* Split a unit in an array of units whose sum is equal to the original
* unit.
* @param unit A unit to be split
* @param parts An array of strings or valueless units
* @returns An array of units
*/
splitUnit(unit: Unit, parts: Unit[]): Unit[];
/**
* Create a string or convert any object into a string. Elements of
* Arrays and Matrices are processed element wise.
* @param value A value to convert to a string
* @returns The created string
*/
string(value: MathType | null): string | MathArray | Matrix;
/**
* Create a unit. Depending on the passed arguments, the function will
* create and return a new math.type.Unit object. When a matrix is
* provided, all elements will be converted to units.
* @param unit The unit to be created
* @returns The created unit
*/
unit(unit: string): Unit;
/**
* @param value The value of the unit to be created
* @param unit The unit to be created
* @returns The created unit
*/
unit(value: number | MathArray | Matrix, unit: string): Unit;
/*************************************************************************
* Expression functions
************************************************************************/
/**
* Parse and compile an expression. Returns a an object with a function
* evaluate([scope]) to evaluate the compiled expression.
* @param expr The expression to be compiled
* @returns An object with the compiled expression
*/
compile(expr: MathExpression): EvalFunction;
/**
* @param exprs The expressions to be compiled
* @returns An array of objects with the compiled expressions
*/
compile(exprs: MathExpression[]): EvalFunction[];
/**
* Evaluate an expression.
* @param expr The expression to be evaluated
* @param scope Scope to read/write variables
* @returns The result of the expression
*/
evaluate(expr: MathExpression | MathExpression[] | Matrix, scope?: object): any;
/**
* Retrieve help on a function or data type. Help files are retrieved
* from the documentation in math.expression.docs.
* @param search A function or function name for which to get help
* @returns A help object
*/
help(search: () => any): Help;
/**
* Parse an expression. Returns a node tree, which can be evaluated by
* invoking node.evaluate();
*/
parse: ParseFunction;
/**
* Create a parser. The function creates a new math.expression.Parser
* object.
* @returns A Parser object
*/
parser(): Parser;
/*************************************************************************
* Algebra functions
************************************************************************/
/**
* @param expr The expression to differentiate
* @param variable The variable over which to differentiate
* @param options There is one option available, simplify, which is true
* by default. When false, output will not be simplified.
* @returns The derivative of expr
*/
derivative(expr: MathNode | string, variable: MathNode | string, options?: { simplify: boolean }): MathNode;
/**
* Solves the linear equation system by forwards substitution. Matrix
* must be a lower triangular matrix.
* @param L A N x N matrix or array (L)
* @param b A column vector with the b values
* @returns A column vector with the linear system solution (x)
*/
lsolve(L: Matrix | MathArray, b: Matrix | MathArray): Matrix | MathArray;
/**
* 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
* @param A A two dimensional matrix or array for which to get the LUP
* decomposition.
* @returns The lower triangular matrix, the upper triangular matrix and
* the permutation matrix.
*/
lup(A?: Matrix | MathArray): { L: MathArray | Matrix; U: MathArray | Matrix; P: number[] };
/**
* Solves the linear system A * x = b where A is an [n x n] matrix and b
* is a [n] column vector.
* @param A Invertible Matrix or the Matrix LU decomposition
* @param b Column Vector
* @param order The Symbolic Ordering and Analysis order, see slu for
* details. Matrix must be a SparseMatrix
* @param threshold Partial pivoting threshold (1 for partial pivoting),
* see slu for details. Matrix must be a SparseMatrix.
* @returns Column vector with the solution to the linear system A * x =
* b
*/
lusolve(A: Matrix | MathArray | number, b: Matrix | MathArray, order?: number, threshold?: number): Matrix | MathArray;
/**
* 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.
* @param A A two dimensional matrix or array for which to get the QR
* decomposition.
* @returns Q: the orthogonal matrix and R: the upper triangular matrix
*/
qr(A: Matrix | MathArray): { Q: MathArray | Matrix; R: MathArray | Matrix };
rationalize(expr: MathNode | string, optional?: object | boolean, detailed?: false): MathNode;
/**
* 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.
* @param expr The expression to check if is a polynomial expression
* @param optional scope of expression or true for already evaluated
* rational expression at input
* @param detailed optional True if return an object, false if return
* expression node (default)
* @returns The rational polynomial of expr
*/
rationalize(
expr: MathNode | string,
optional?: object | boolean,
detailed?: true
): { expression: MathNode | string; variables: string[]; coefficients: MathType[] };
/**
* Simplify an expression tree.
* @param expr The expression to be simplified
* @param [rules] (optional) 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.
* @param [scope] (optional) Scope to variables
* @param [options] (optional) An object with simplify options
* @returns Returns the simplified form of expr
*/
simplify: Simplify;
/**
* 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
* @param A A two dimensional sparse matrix for which to get the LU
* decomposition.
* @param order 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 analysis is performed on M = A' * A. Dense
* columns from A' are dropped, A recreated from A'. This is appropriate
* for LU factorization of non-symmetric matrices. 3 - Symbolic ordering
* and analysis 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.
* @param threshold Partial pivoting threshold (1 for partial pivoting)
* @returns The lower triangular matrix, the upper triangular matrix and
* the permutation vectors.
*/
slu(A: Matrix, order: number, threshold: number): object;
/**
* Solves the linear equation system by backward substitution. Matrix
* must be an upper triangular matrix. U * x = b
* @param U A N x N matrix or array (U)
* @param b A column vector with the b values
* @returns A column vector with the linear system solution (x)
*/
usolve(U: Matrix | MathArray, b: Matrix | MathArray): Matrix | MathArray;
/*************************************************************************
* Arithmetic functions
************************************************************************/
/**
* Calculate the absolute value of a number. For matrices, the function
* is evaluated element wise.
* @param x A number or matrix for which to get the absolute value
* @returns Absolute value of x
*/
abs(x: number): number;
abs(x: BigNumber): BigNumber;
abs(x: Fraction): Fraction;
abs(x: Complex): Complex;
abs(x: MathArray): MathArray;
abs(x: Matrix): Matrix;
abs(x: Unit): Unit;
/**
* Add two values, x + y. For matrices, the function is evaluated
* element wise.
* @param x First value to add
* @param y Second value to add
* @returns Sum of x and y
*/
add(x: MathType, y: MathType): MathType;
/**
* Calculate the cubic root of a value. For matrices, the function is
* evaluated element wise.
* @param x Value for which to calculate the cubic root.
* @param 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.
* @returns Returns the cubic root of x
*/
cbrt(x: number, allRoots?: boolean): number;
cbrt(x: BigNumber, allRoots?: boolean): BigNumber;
cbrt(x: Fraction, allRoots?: boolean): Fraction;
cbrt(x: Complex, allRoots?: boolean): Complex;
cbrt(x: MathArray, allRoots?: boolean): MathArray;
cbrt(x: Matrix, allRoots?: boolean): Matrix;
cbrt(x: Unit, allRoots?: boolean): Unit;
/**
* 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.
* @param x Number to be rounded
* @returns Rounded value
*/
ceil(x: number): number;
ceil(x: BigNumber): BigNumber;
ceil(x: Fraction): Fraction;
ceil(x: Complex): Complex;
ceil(x: MathArray): MathArray;
ceil(x: Matrix): Matrix;
ceil(x: Unit): Unit;
/**
* Compute the cube of a value, x * x * x. For matrices, the function is
* evaluated element wise.
* @param x Number for which to calculate the cube
* @returns Cube of x
*/
cube(x: number): number;
cube(x: BigNumber): BigNumber;
cube(x: Fraction): Fraction;
cube(x: Complex): Complex;
cube(x: MathArray): MathArray;
cube(x: Matrix): Matrix;
cube(x: Unit): Unit;
/**
* Divide two values, x / y. To divide matrices, x is multiplied with
* the inverse of y: x * inv(y).
* @param x Numerator
* @param y Denominator
* @returns Quotient, x / y
*/
divide(x: Unit, y: Unit): Unit | number;
divide(x: Unit, y: number): Unit;
divide(x: number, y: number): number;
divide(x: MathType, y: MathType): MathType;
/**
* Divide two matrices element wise. The function accepts both matrices
* and scalar values.
* @param x Numerator
* @param y Denominator
* @returns Quotient, x ./ y
*/
dotDivide(x: MathType, y: MathType): MathType;
/**
* Multiply two matrices element wise. The function accepts both
* matrices and scalar values.
* @param x Left hand value
* @param y Right hand value
* @returns Multiplication of x and y
*/
dotMultiply(x: MathType, y: MathType): MathType;
/**
* Calculates the power of x to y element wise.
* @param x The base
* @param y The exponent
* @returns The value of x to the power y
*/
dotPow(x: MathType, y: MathType): MathType;
/**
* Calculate the exponent of a value. For matrices, the function is
* evaluated element wise.
* @param x A number or matrix to exponentiate
* @returns Exponent of x
*/
exp(x: number): number;
exp(x: BigNumber): BigNumber;
exp(x: Complex): Complex;
exp(x: MathArray): MathArray;
exp(x: Matrix): Matrix;
/**
* Calculate the value of subtracting 1 from the exponential value. For
* matrices, the function is evaluated element wise.
* @param x A number or matrix to apply expm1
* @returns Exponent of x
*/
expm1(x: number): number;
expm1(x: BigNumber): BigNumber;
expm1(x: Complex): Complex;
expm1(x: MathArray): MathArray;
expm1(x: Matrix): Matrix;
/**
* Round a value towards zero. For matrices, the function is evaluated
* element wise.
* @param x Number to be rounded
* @returns Rounded value
*/
fix(x: number): number;
fix(x: BigNumber): BigNumber;
fix(x: Fraction): Fraction;
fix(x: Complex): Complex;
fix(x: MathArray): MathArray;
fix(x: Matrix): Matrix;
/**
* Round a value towards minus infinity. For matrices, the function is
* evaluated element wise.
* @param Number to be rounded
* @returns Rounded value
*/
floor(x: number): number;
floor(x: BigNumber): BigNumber;
floor(x: Fraction): Fraction;
floor(x: Complex): Complex;
floor(x: MathArray): MathArray;
floor(x: Matrix): Matrix;
/**
* Round a value towards minus infinity. For matrices, the function is
* evaluated element wise.
* @param x Number to be rounded
* @param n Number of decimals Default value: 0.
* @returns Rounded value
*/
floor(
x: number | BigNumber | Fraction | Complex | MathArray | Matrix,
n: number | BigNumber | MathArray
): number | BigNumber | Fraction | Complex | MathArray | Matrix;
/**
* Calculate the greatest common divisor for two or more values or
* arrays. For matrices, the function is evaluated element wise.
* @param args Two or more integer numbers
* @returns The greatest common divisor
*/
gcd(...args: number[]): number;
gcd(...args: BigNumber[]): BigNumber;
gcd(...args: Fraction[]): Fraction;
gcd(...args: MathArray[]): MathArray;
gcd(...args: Matrix[]): Matrix;
/**
* Calculate the hypotenusa of a list with values. The hypotenusa is
* defined as: hypot(a, b, c, ...) = sqrt(a^2 + b^2 + c^2 + ...) For
* matrix input, the hypotenusa is calculated for all values in the
* matrix.
* @param args 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.
* @returns Returns the hypothenuse of the input values.
*/
hypot(...args: number[]): number;
hypot(...args: BigNumber[]): BigNumber;
/**
* 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.
* @param a An integer number
* @param b An integer number
* @returns The least common multiple
*/
lcm(a: number, b: number): number;
lcm(a: BigNumber, b: BigNumber): BigNumber;
lcm(a: MathArray, b: MathArray): MathArray;
lcm(a: Matrix, b: Matrix): Matrix;
/**
* Calculate the logarithm of a value. For matrices, the function is
* evaluated element wise.
* @param x Value for which to calculate the logarithm.
* @param base Optional base for the logarithm. If not provided, the
* natural logarithm of x is calculated. Default value: e.
* @returns Returns the logarithm of x
*/
log<T extends number | BigNumber | Complex | MathArray | Matrix>(x: T, base?: number | BigNumber | Complex): NoLiteralType<T>;
/**
* Calculate the 10-base of a value. This is the same as calculating
* log(x, 10). For matrices, the function is evaluated element wise.
* @param x Value for which to calculate the logarithm.
* @returns Returns the 10-base logarithm of x
*/
log10(x: number): number;
log10(x: BigNumber): BigNumber;
log10(x: Complex): Complex;
log10(x: MathArray): MathArray;
log10(x: Matrix): Matrix;
/**
* Calculate the logarithm of a value+1. For matrices, the function is
* evaluated element wise.
* @param x Value for which to calculate the logarithm.
* @returns Returns the logarithm of x+1
*/
log1p(x: number, base?: number | BigNumber | Complex): number;
log1p(x: BigNumber, base?: number | BigNumber | Complex): BigNumber;
log1p(x: Complex, base?: number | BigNumber | Complex): Complex;
log1p(x: MathArray, base?: number | BigNumber | Complex): MathArray;
log1p(x: Matrix, base?: number | BigNumber | Complex): Matrix;
/**
* Calculate the 2-base of a value. This is the same as calculating
* log(x, 2). For matrices, the function is evaluated element wise.
* @param x Value for which to calculate the logarithm.
* @returns Returns the 2-base logarithm of x
*/
log2(x: number): number;
log2(x: BigNumber): BigNumber;
log2(x: Complex): Complex;
log2(x: MathArray): MathArray;
log2(x: Matrix): Matrix;
/**
* 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 http://en.wikipedia.org/wiki/Modulo_operation.
* @param x Dividend
* @param y Divisor
* @returns Returns the remainder of x divided by y
*/
mod<T extends number | BigNumber | Fraction | MathArray | Matrix>(
x: T,
y: number | BigNumber | Fraction | MathArray | Matrix
): NoLiteralType<T>;
/**
* Multiply two values, x * y. The result is squeezed. For matrices, the
* matrix product is calculated.
* @param x The first value to multiply
* @param y The second value to multiply
* @returns Multiplication of x and y
*/
multiply<T extends Matrix | MathArray>(x: T, y: MathType): T;
multiply(x: Unit, y: Unit): Unit;
multiply(x: number, y: number): number;
multiply(x: MathType, y: MathType): MathType;
/**
* Calculate the norm of a number, vector or matrix. The second
* parameter p is optional. If not provided, it defaults to 2.
* @param x Value for which to calculate the norm
* @param p Vector space. Supported numbers include Infinity and
* -Infinity. Supported strings are: 'inf', '-inf', and 'fro' (The
* Frobenius norm) Default value: 2.
* @returns the p-norm
*/
norm(x: number | BigNumber | Complex | MathArray | Matrix, p?: number | BigNumber | string): number | BigNumber;
/**
* 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.
* @param a Value for which to calculate the nth root
* @param root The root. Default value: 2.
* @return The nth root of a
*/
nthRoot(a: number | BigNumber | MathArray | Matrix | Complex, root?: number | BigNumber): number | Complex | MathArray | Matrix;
/**
* Calculates the power of x to y, x ^ y. Matrix exponentiation is
* supported for square matrices x, and positive integer exponents y.
* @param x The base
* @param y The exponent
* @returns x to the power y
*/
pow(x: MathType, y: number | BigNumber | Complex): MathType;
/**
* Round a value towards the nearest integer. For matrices, the function
* is evaluated element wise.
* @param x Number to be rounded
* @param n Number of decimals Default value: 0.
* @returns Rounded value of x
*/
round<T extends number | BigNumber | Fraction | Complex | MathArray | Matrix>(
x: T,
n?: number | BigNumber | MathArray
): NoLiteralType<T>;
/**
* Compute the sign of a value. The sign of a value x is: 1 when x > 1
* -1 when x < 0 0 when x == 0 For matrices, the function is evaluated
* element wise.
* @param x The number for which to determine the sign
* @returns The sign of x
*/
sign(x: number): number;
sign(x: BigNumber): BigNumber;
sign(x: Fraction): Fraction;
sign(x: Complex): Complex;
sign(x: MathArray): MathArray;
sign(x: Matrix): Matrix;
sign(x: Unit): Unit;
/**
* Calculate the square root of a value. For matrices, the function is
* evaluated element wise.
* @param x Value for which to calculate the square root
* @returns Returns the square root of x
*/
sqrt(x: number): number;
sqrt(x: BigNumber): BigNumber;
sqrt(x: Complex): Complex;
sqrt(x: MathArray): MathArray;
sqrt(x: Matrix): Matrix;
sqrt(x: Unit): Unit;
/**
* Compute the square of a value, x * x. For matrices, the function is
* evaluated element wise.
* @param x Number for which to calculate the square
* @returns Squared value
*/
square(x: number): number;
square(x: BigNumber): BigNumber;
square(x: Fraction): Fraction;
square(x: Complex): Complex;
square(x: MathArray): MathArray;
square(x: Matrix): Matrix;
square(x: Unit): Unit;
/**
* Subtract two values, x - y. For matrices, the function is evaluated
* element wise.
* @param x Initial value
* @param y Value to subtract from x
* @returns Subtraction of x and y
*/
subtract(x: number, y: number): number;
subtract(x: Unit, y: Unit): Unit;
subtract(x: MathType, y: MathType): MathType;
/**
* 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.
* @param x Number to be inverted
* @returns Retursn the value with inverted sign
*/
unaryMinus(x: number): number;
unaryMinus(x: BigNumber): BigNumber;
unaryMinus(x: Fraction): Fraction;
unaryMinus(x: Complex): Complex;
unaryMinus(x: MathArray): MathArray;
unaryMinus(x: Matrix): Matrix;
unaryMinus(x: Unit): Unit;
/**
* 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.
* @param x Input value
* @returns Returns the input value when numeric, converts to a number
* when input is non-numeric.
*/
unaryPlus(x: number): number;
unaryPlus(x: BigNumber): BigNumber;
unaryPlus(x: Fraction): Fraction;
unaryPlus(x: string): string;
unaryPlus(x: Complex): Complex;
unaryPlus(x: MathArray): MathArray;
unaryPlus(x: Matrix): Matrix;
unaryPlus(x: Unit): Unit;
/**
* Calculate the extended greatest common divisor for two values. See
* http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm.
* @param a An integer number
* @param b An integer number
* @returns Returns an array containing 3 integers [div, m, n] where div
* = gcd(a, b) and a*m + b*n = div
*/
xgcd(a: number | BigNumber, b: number | BigNumber): MathArray;
/*************************************************************************
* Bitwise functions
************************************************************************/
/**
* Bitwise AND two values, x & y. For matrices, the function is
* evaluated element wise.
* @param x First value to and
* @param y Second value to and
* @returns AND of x and y
*/
bitAnd<T extends number | BigNumber | MathArray | Matrix>(x: T, y: number | BigNumber | MathArray | Matrix): NoLiteralType<T>;
/**
* Bitwise NOT value, ~x. For matrices, the function is evaluated
* element wise. For units, the function is evaluated on the best prefix
* base.
* @param x Value to not
* @returns NOT of x
*/
bitNot(x: number): number;
bitNot(x: BigNumber): BigNumber;
bitNot(x: MathArray): MathArray;
bitNot(x: Matrix): Matrix;
/**
* 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.
* @param x First value to or
* @param y Second value to or
* @returns OR of x and y
*/
bitOr(x: number, y: number): number;
bitOr(x: BigNumber, y: BigNumber): BigNumber;
bitOr(x: MathArray, y: MathArray): MathArray;
bitOr(x: Matrix, y: Matrix): Matrix;
/**
* Bitwise XOR two values, x ^ y. For matrices, the function is
* evaluated element wise.
* @param x First value to xor
* @param y Second value to xor
* @returns XOR of x and y
*/
bitXor<T extends number | BigNumber | MathArray | Matrix>(x: T, y: number | BigNumber | MathArray | Matrix): NoLiteralType<T>;
/**
* 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.
* @param x Value to be shifted
* @param y Amount of shifts
* @returns x shifted left y times
*/
leftShift<T extends number | BigNumber | MathArray | Matrix>(x: T, y: number | BigNumber): NoLiteralType<T>;
/**
* 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.
* @param x Value to be shifted
* @param y Amount of shifts
* @returns x sign-filled shifted right y times
*/
rightArithShift<T extends number | BigNumber | MathArray | Matrix>(x: T, y: number | BigNumber): NoLiteralType<T>;
/**
* 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.
* @param x Value to be shifted
* @param y Amount of shifts
* @returns x zero-filled shifted right y times
*/
rightLogShift<T extends number | MathArray | Matrix>(x: T, y: number): NoLiteralType<T>;
/*************************************************************************
* Combinatorics functions
************************************************************************/
/**
* 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
* @param n Total number of objects in the set
* @returns B(n)
*/
bellNumbers(n: number): number;
bellNumbers(n: BigNumber): BigNumber;
/**
* The Catalan Numbers enumerate combinatorial structures of many
* different types. catalan only takes integer arguments. The following
* condition must be enforced: n >= 0
* @param n nth Catalan number
* @returns Cn(n)
*/
catalan(n: number): number;
catalan(n: BigNumber): BigNumber;
/**
* The composition counts of n into k parts. Composition only takes
* integer arguments. The following condition must be enforced: k <= n.
* @param n Total number of objects in the set
* @param k Number of objects in the subset
* @returns Returns the composition counts of n into k parts.
*/
composition<T extends number | BigNumber>(n: T, k: number | BigNumber): NoLiteralType<T>;
/**
* 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, then s(n,k) =
* 1
* @param n Total number of objects in the set
* @param k Number of objects in the subset
* @returns S(n,k)
*/
stirlingS2<T extends number | BigNumber>(n: T, k: number | BigNumber): NoLiteralType<T>;
/*************************************************************************
* Complex functions
************************************************************************/
/**
* 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.
* @param x A complex number or array with complex numbers
* @returns The argument of x
*/
arg(x: number | Complex): number;
arg(x: BigNumber | Complex): BigNumber;
arg(x: MathArray): MathArray;
arg(x: Matrix): Matrix;
/**
* 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.
* @param x A complex number or array with complex numbers
* @returns The complex conjugate of x
*/
conj<T extends number | BigNumber | Complex | MathArray | Matrix>(x: T): NoLiteralType<T>;
/**
* 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.
* @param x A complex number or array with complex numbers
* @returns The imaginary part of x
*/
im(x: number | BigNumber | Complex | MathArray | Matrix): number | BigNumber | MathArray | Matrix;
/**
* 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.
* @param x A complex number or array of complex numbers
* @returns The real part of x
*/
re(x: number | BigNumber | Complex | MathArray | Matrix): number | BigNumber | MathArray | Matrix;
/*************************************************************************
* Geometry functions
************************************************************************/
/**
* Calculates: The eucledian distance between two points in 2 and 3
* 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)
* @param x Coordinates of the first point
* @param y Coordinates of the second point
* @returns Returns the distance from two/three points
*/
distance(x: MathArray | Matrix | object, y: MathArray | Matrix | object): number | BigNumber;