mirror of
https://github.com/josdejong/mathjs.git
synced 2025-12-08 19:46:04 +00:00
Merge branch 'typescript_improvements' of https://github.com/LearnSomethingTeam/mathjs into LearnSomethingTeam-typescript_improvements
This commit is contained in:
Jos de Jong
commit
fc5c202e53
253
types/index.d.ts
vendored
253
types/index.d.ts
vendored
@ -156,6 +156,168 @@ declare namespace math {
|
||||
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 {
|
||||
@ -173,6 +335,23 @@ declare namespace math {
|
||||
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
|
||||
@ -500,6 +679,7 @@ declare namespace math {
|
||||
*/
|
||||
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
|
||||
@ -517,7 +697,7 @@ declare namespace math {
|
||||
optional?: object | boolean,
|
||||
detailed?: true
|
||||
): { expression: MathNode | string; variables: string[]; coefficients: MathType[] };
|
||||
rationalize(expr: MathNode | string, optional?: object | boolean, detailed?: false): MathNode;
|
||||
|
||||
|
||||
/**
|
||||
* Simplify an expression tree.
|
||||
@ -530,13 +710,7 @@ declare namespace math {
|
||||
* @param [options] (optional) An object with simplify options
|
||||
* @returns Returns the simplified form of expr
|
||||
*/
|
||||
simplify(
|
||||
expr: MathNode | string,
|
||||
rules?: Array<{ l: string; r: string } | string | ((node: MathNode) => MathNode)>,
|
||||
scope?: object,
|
||||
options?: SimplifyOptions,
|
||||
): MathNode;
|
||||
simplify(expr: MathNode | string, scope?: object, options?: SimplifyOptions): MathNode;
|
||||
simplify: Simplify;
|
||||
|
||||
/**
|
||||
* Calculate the Sparse Matrix LU decomposition with full pivoting.
|
||||
@ -649,6 +823,7 @@ declare namespace math {
|
||||
* @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;
|
||||
|
||||
@ -941,6 +1116,8 @@ declare namespace math {
|
||||
* @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;
|
||||
|
||||
/**
|
||||
@ -2540,7 +2717,7 @@ declare namespace math {
|
||||
* Factory and Dependencies
|
||||
************************************************************************/
|
||||
interface FactoryDependencies {
|
||||
create: (factories: FactoryFunctionMap, config?: ConfigOptions) => Partial<MathJsStatic>;
|
||||
create: (factories: FactoryFunctionMap, config?: ConfigOptions) => MathJsStatic;
|
||||
factory: <T>(
|
||||
name: string,
|
||||
dependencies: MathJsFunctionName[],
|
||||
@ -2941,8 +3118,8 @@ declare namespace math {
|
||||
pow(unit: Unit): Unit;
|
||||
abs(unit: Unit): Unit;
|
||||
to(unit: string): Unit;
|
||||
toNumber(unit: string): number;
|
||||
toNumeric(unit: string): number | Fraction | BigNumber;
|
||||
toNumber(unit?: string): number;
|
||||
toNumeric(unit?: string): number | Fraction | BigNumber;
|
||||
toSI(): Unit;
|
||||
toString(): string;
|
||||
toJSON(): MathJSON;
|
||||
@ -2969,6 +3146,26 @@ declare namespace math {
|
||||
fractionsLimit?: number;
|
||||
}
|
||||
|
||||
type SimplifyRule = { l: string; r: string } | string | ((node: MathNode) => MathNode);
|
||||
|
||||
interface Simplify {
|
||||
(
|
||||
expr: MathNode | string,
|
||||
rules?: SimplifyRule[],
|
||||
scope?: object,
|
||||
options?: SimplifyOptions,
|
||||
): MathNode;
|
||||
(
|
||||
expr: MathNode | string,
|
||||
scope?: object,
|
||||
options?: SimplifyOptions,
|
||||
): MathNode;
|
||||
|
||||
rules: SimplifyRule[];
|
||||
|
||||
simplifyCore(expr: MathNode): MathNode;
|
||||
}
|
||||
|
||||
interface UnitDefinition {
|
||||
definition?: string | Unit;
|
||||
prefixes?: string;
|
||||
@ -2982,32 +3179,14 @@ declare namespace math {
|
||||
evaluate(scope?: any): any;
|
||||
}
|
||||
|
||||
interface MathNode {
|
||||
isNode: boolean;
|
||||
isAccessorNode?: boolean;
|
||||
isArrayNode?: boolean;
|
||||
isAssignmentNode?: boolean;
|
||||
isBlockNode?: boolean;
|
||||
isConditionalNode?: boolean;
|
||||
isConstantNode?: boolean;
|
||||
isFunctionAssignmentNode?: boolean;
|
||||
isFunctionNode?: boolean;
|
||||
isIndexNode?: boolean;
|
||||
isObjectNode?: boolean;
|
||||
isOperatorNode?: boolean;
|
||||
isParenthesisNode?: boolean;
|
||||
isRangeNode?: boolean;
|
||||
isRelationalNode?: boolean;
|
||||
isSymbolNode?: boolean;
|
||||
interface MathNodeCommon {
|
||||
isNode: true;
|
||||
comment: string;
|
||||
type: 'AccessorNode' | 'ArrayNode' | 'AssignmentNode' | 'BlockNode' | 'ConditionalNode' | 'ConstantNode' |
|
||||
'FunctionAssignmentNode' | 'FunctionNode' | 'IndexNode' | 'ObjectNode' | 'OperatorNode' | 'ParenthesisNode' |
|
||||
'RangeNode' | 'RelationalNode' | 'SymbolNode';
|
||||
|
||||
isUpdateNode?: boolean;
|
||||
comment?: string;
|
||||
content?: MathNode;
|
||||
op?: string;
|
||||
fn?: string;
|
||||
args?: MathNode[];
|
||||
type: string;
|
||||
name?: string;
|
||||
value?: any;
|
||||
|
||||
/**
|
||||
* Create a shallow clone of the node. The node itself is cloned, its
|
||||
@ -3445,7 +3624,7 @@ declare namespace math {
|
||||
* can be specified as an object, string, or function.
|
||||
* @param scope Scope to variables
|
||||
*/
|
||||
simplify(rules?: Array<{ l: string; r: string } | string | ((node: MathNode) => MathNode)>, scope?: object): MathJsChain;
|
||||
simplify(rules?: SimplifyRule[], scope?: object): MathJsChain;
|
||||
|
||||
/**
|
||||
* Calculate the Sparse Matrix LU decomposition with full pivoting.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user