maths.ts

/** * Inside the expressions, whenever numberPattern matches a string, it will be * considered as a number. */ export declare const numberRegex: RegExp; /** * Inside the expressions, whenever symbolPattern matches a string, it will be * considered as a symbol. */ export declare const symbolRegex: RegExp; /** * The types the Node class accepts for performing its operations from * creating the Node to adding, etc. */ export declare type ValidNumber = number | string | Node; /** * Node represents the basic tree node class. Any implementation of a tree * expression must be extended through Node internally. */ export default class Node { parent: Node; static scope: any; children: Node[]; exponent: Node | number; type: NodeType; value: number | string; /** * Builds the tree for expression. * @param exp The expression to be represented with this. * @param parent The parent for this Node. */ constructor(exp?: ValidNumber, parent?: Node); /** * Access the operators in Node's scope. * @return The operators in the scope. */ static readonly operators: any; /** * Access the functions in Node's scope. * @return The functions in the scope. */ static readonly functions: any; /** * Access the constants in Node's scope. * @return The constants in the scope. */ static readonly constants: any; private _positive; /** * Returns whether this is positive or not. * @return true if this is positive, false otherwise. */ /** * Sets the sign of this. */ positive: boolean; readonly isFraction: boolean; /** * Calculates the value of this Node as a number type. If this contains * an element that cannot be converted to a number it will return undefined. * @return The value of this as a number. */ readonly numberValue: number; /** * Returns whether this is positive or not. * @return true if this is positive, false otherwise. */ /** * Sets the sign of this. */ negative: boolean; /** * Creates a new Node from the given expression. * @param exp The expression from where to create the node. * @return A new node representing the expression. */ static newNode(exp?: ValidNumber): Node; /** * Returns a new Node representing the addition of a plus b. * @param a A number to add. * @param b A number to add. * @return new Node(a + b). */ static add(a: ValidNumber, b: ValidNumber): Node; /** * Returns a new Node representing the multiplication of a times b. * @param a A number to multiply. * @param b A number to multiply. * @return new Node(a * b). */ static multiply(a: ValidNumber, b: ValidNumber): Node; /** * Adds a constant to the scope. * @param c The constant to be added. * @param v The value the constant will get. */ static setConstant(c: string, v: number): void; /** * Gets the value as a number for this node. In the event that there is * a variable in this expression, that variable must be declared in the * global scope or sent through the scope param in order to interpret * the variable in the expression, if a variable has no number value in * scope then the value returned will be undefined. * @param lScope The scope in which some variables inside this will be * evaluated. * @return The value for this according to the scope provided. In the * event that a variable is missed in the scope it will return undefined. */ getNumberValue(lScope?: any): number; /** * Adds to this another value in a new Node. * @param s The expression to operate with. * @return A new Node with the value of this plus s. */ add(s: ValidNumber): Node; /** * Subtracts to this another value in a new Node. * @param s The expression to operate with. * @return A new Node with the value of this minus s. */ subtract(s: ValidNumber): Node; /** * Multiplies to this another value in a new Node. * @param s The expression to operate with. * @return A new Node with the value of this times s. */ multiply(s: ValidNumber): Node; /** * Divides to this another value in a new Node. * @param s The expression to operate with. * @return A new Node with the value of this between s. */ divide(s: ValidNumber): Node; /** * Powers to this another value in a new Node. * @param s The expression to operate with. * @return A new Node with the value of this pow s. */ pow(s: ValidNumber): Node; /** * Creates a new node equivalent to -this. * @return A negation of this. */ negate(): Node; /** * Adds to this another value and keeps the result in this Node. * @param s The expression to operate with. */ addHere(s: ValidNumber): Node; /** * Subtracts to this another value and keeps the result in this Node. * @param s The expression to operate with. */ subtractHere(s: ValidNumber): Node; /** * Multiplies to this another value and keeps the result in this Node. * @param s The expression to operate with. */ multiplyHere(s: ValidNumber): Node; /** * Divides to this another value and keeps the result in this Node. * @param s The expression to operate with. */ divideHere(s: ValidNumber): Node; /** * Powers to this another value in a new Node. * @param s The expression to operate with. * @return A new Node with the value of this pow s. */ powHere(s: ValidNumber): Node; /** * Changes this node's sign. */ negateHere(): Node; /** * Compare this and other number with the given operator. * @param n The number which to compare this. * @param operator The operator to compare this with n. * @return this {operator} n. */ compare(n: Node | number, operator?: string): boolean; /** * Converts this to a string. * @return The string that represents this. */ toString(): string; /** * Creates a copy of this Node. * @return A copy of this Node. */ clone(): Node; /** * Checks if this is Not a Number. * @return true if this is NaN, false otherwise. */ isNaN(): boolean; /** * Simplifies each children of this, then simplifies this. At this * moment simplify uses a very simple simplification that is yet waiting * to be completed. */ simplify(): void; /** * Whenever this.value is a number, it may be seen as a rational number. * If it has a decimal point then it is better to represent that value * as a fraction in order to keep accuracy on later operations. * Rationalize transforms this node to a fraction if this.value is a non * integer number. */ rationalize(): void; /** * Updates this to a new value or type of node. * @param n The new value. */ update(n: number | Node): void; /** * Prints the child sent with or without parentheses according to this * operator's priority. * @param n The child to be printed. * @return The string as how n should be printed. */ private printChild(n); /** * Simplifies this when it is a division. */ private simplifyDivision(); /** * Simplifies this when it is a product. */ private simplifyProduct(); /** * Simplifies this when it is a division. */ private simplifyAddition(); /** * Simplifies this when it is a product. */ private simplifySubtraction(); } /** * Represents the types which a Node can represent. The nodes can only be * operators, constants, functions or variables. Each one of this node types * have their own features that distinguish them from the others. */ export declare enum NodeType { Operator = 0, Constant = 1, Function = 2, Variable = 3, }