@flomsstaar/expression-tree 0.1.0

package/README.md

@@ -0,0 +1,83 @@
+# expression-tree
+
+[![Quality Gate Status](https://sonarqube.florentmarques.fr/api/project_badges/measure?project=expression-tree&metric=alert_status&token=sqb_5625e2db1fa54b8af4278b6f13b70bc99f094f0a)](https://sonarqube.florentmarques.fr/dashboard?id=expression-tree)
+[![Security Rating](https://sonarqube.florentmarques.fr/api/project_badges/measure?project=expression-tree&metric=software_quality_security_rating&token=sqb_5625e2db1fa54b8af4278b6f13b70bc99f094f0a)](https://sonarqube.florentmarques.fr/dashboard?id=expression-tree)
+[![Coverage](https://sonarqube.florentmarques.fr/api/project_badges/measure?project=expression-tree&metric=coverage&token=sqb_5625e2db1fa54b8af4278b6f13b70bc99f094f0a)](https://sonarqube.florentmarques.fr/dashboard?id=expression-tree)
+
+## Concept
+
+This is a simple expression tree implementation in TypeScript. It allows you to parse mathematical expressions and evaluate them using a tree structure.
+
+![expression tree](docs/tree.png)
+
+## Features
+
+- [x] Parse mathematical expressions into a tree structure.
+- [x] Evaluate expressions using the tree.
+- [x] Support for basic arithmetic operations
+  - [x] addition
+  - [x] subtraction
+  - [x] multiplication
+  - [x] division
+  - [x] exponentiation
+  - [x] unary minus
+  - [x] parentheses
+  - [x] operator precedence
+  - [x] operator associativity
+  - [ ] square root
+  - [ ] absolute value
+  - [ ] trigonometric functions (sin, cos, tan)
+  - [ ] logarithm
+
+## Example
+
+```shell
+$ bun run index.ts
+```
+
+Output:
+
+```text
+-------------------
+expected: 6 - -2 + 5 = 13
+actual:   6 - -2 + 5 = 13
+same ?    true
+-------------------
+expected: 6 + -(2 + 5) = -1
+actual:   6 + -(2 + 5) = -1
+same ?    true
+-------------------
+expected: 6 + -2 * 5 = -4
+actual:   6 + -2 * 5 = -4
+same ?    true
+-------------------
+expected: 6 + 4 / 2 * 5 = 16
+actual:   6 + 4 / 2 * 5 = 16
+same ?    true
+-------------------
+expected: 6 + -(2 * 5) = -4
+actual:   6 + -(2 * 5) = -4
+same ?    true
+-------------------
+expected: 6 + 2 * 3 - 1 = 11
+actual:   6 + 2 * 3 - 1 = 11
+same ?    true
+-------------------
+expected: 6 + 2 * 3 - 1 + 2 ^ 2 = 15
+actual:   6 + 2 * 3 - 1 + 2 ^ 2 = 15
+same ?    true
+```
+
+## Development
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```

package/build/example.d.ts

@@ -0,0 +1 @@
+export {};

package/build/example.js

@@ -0,0 +1,18 @@
+import { ExpressionTree } from './src/expression_tree.js';
+function testExpression(expression, expectedResult) {
+    const expressionTree = new ExpressionTree();
+    console.log('-------------------');
+    const expected = `${expression} = ${expectedResult}`;
+    const actual = `${expression} = ${expressionTree.evaluate(expression)}`;
+    console.log('expected:', expected);
+    console.log('actual:  ', actual);
+    console.log('same ?   ', expected === actual);
+}
+// testExpression('sqrt(6 + 4 / 2 * 5)', 4)
+testExpression('6 - -2 + 5', 13);
+testExpression('6 + -(2 + 5)', -1);
+testExpression('6 + -2 * 5', -4);
+testExpression('6 + 4 / 2 * 5', 16);
+testExpression('6 + -(2 * 5)', -4);
+testExpression('6 + 2 * 3 - 1', 11);
+testExpression('6 + 2 * 3 - 1 + 2 ^ 2', 15);

package/build/index.d.ts

@@ -0,0 +1,16 @@
+export { ExpressionTree } from './src/expression_tree.js';
+export { ExpressionParser } from './src/expression_parser.js';
+export { ExpressionEvaluator } from './src/expression_evaluator.js';
+export { ExpressionCutter } from './src/expression_cutter.js';
+export { InvalidExpressionError } from './src/errors/invalid_expression_error.js';
+export { InvalidNumberError } from './src/errors/invalid_number_error.js';
+export { MissingClosingParenthesisError } from './src/errors/missing_parenthese_error.js';
+export { UnknownBinaryOperatorError } from './src/errors/unknown_binary_operator_error.js';
+export { UnknownUnaryOperatorError } from './src/errors/unknown_unary_operator_error.js';
+export { DivisionByZeroError } from './src/errors/division_by_zero_error.js';
+export { NegativeSquareRootError } from './src/errors/invalid_square_root_error.js';
+export { UnknownNodeTypeError } from './src/errors/unknown_node_type_error.js';
+export { BaseNode } from './src/models/base_node.js';
+export { BinaryNode } from './src/models/binary_node.js';
+export { UnaryNode } from './src/models/unary_node.js';
+export { NumberNode } from './src/models/number_node.js';

package/build/index.js

@@ -0,0 +1,16 @@
+export { ExpressionTree } from './src/expression_tree.js';
+export { ExpressionParser } from './src/expression_parser.js';
+export { ExpressionEvaluator } from './src/expression_evaluator.js';
+export { ExpressionCutter } from './src/expression_cutter.js';
+export { InvalidExpressionError } from './src/errors/invalid_expression_error.js';
+export { InvalidNumberError } from './src/errors/invalid_number_error.js';
+export { MissingClosingParenthesisError } from './src/errors/missing_parenthese_error.js';
+export { UnknownBinaryOperatorError } from './src/errors/unknown_binary_operator_error.js';
+export { UnknownUnaryOperatorError } from './src/errors/unknown_unary_operator_error.js';
+export { DivisionByZeroError } from './src/errors/division_by_zero_error.js';
+export { NegativeSquareRootError } from './src/errors/invalid_square_root_error.js';
+export { UnknownNodeTypeError } from './src/errors/unknown_node_type_error.js';
+export { BaseNode } from './src/models/base_node.js';
+export { BinaryNode } from './src/models/binary_node.js';
+export { UnaryNode } from './src/models/unary_node.js';
+export { NumberNode } from './src/models/number_node.js';

package/build/src/enums/binary_node_operator.d.ts

@@ -0,0 +1,7 @@
+export declare enum BinaryNodeOperator {
+    SUM = "addition",
+    SUBTRACT = "subtraction",
+    MULTIPLY = "multiplication",
+    DIVIDE = "division",
+    POWER = "power"
+}

package/build/src/enums/binary_node_operator.js

@@ -0,0 +1,8 @@
+export var BinaryNodeOperator;
+(function (BinaryNodeOperator) {
+    BinaryNodeOperator["SUM"] = "addition";
+    BinaryNodeOperator["SUBTRACT"] = "subtraction";
+    BinaryNodeOperator["MULTIPLY"] = "multiplication";
+    BinaryNodeOperator["DIVIDE"] = "division";
+    BinaryNodeOperator["POWER"] = "power";
+})(BinaryNodeOperator || (BinaryNodeOperator = {}));

package/build/src/enums/node_type.d.ts

@@ -0,0 +1,6 @@
+export declare enum NodeType {
+    EXPRESSION = "expression",
+    NUMBER = "number",
+    BINARY = "binary",
+    UNARY = "unary"
+}

package/build/src/enums/node_type.js

@@ -0,0 +1,7 @@
+export var NodeType;
+(function (NodeType) {
+    NodeType["EXPRESSION"] = "expression";
+    NodeType["NUMBER"] = "number";
+    NodeType["BINARY"] = "binary";
+    NodeType["UNARY"] = "unary";
+})(NodeType || (NodeType = {}));

package/build/src/enums/unary_node_operator.d.ts

@@ -0,0 +1,5 @@
+export declare enum UnaryNodeOperator {
+    SQUARE_ROOT = "square_root",
+    NEGATE = "negate",
+    ABSOLUTE = "absolute"
+}

package/build/src/enums/unary_node_operator.js

@@ -0,0 +1,6 @@
+export var UnaryNodeOperator;
+(function (UnaryNodeOperator) {
+    UnaryNodeOperator["SQUARE_ROOT"] = "square_root";
+    UnaryNodeOperator["NEGATE"] = "negate";
+    UnaryNodeOperator["ABSOLUTE"] = "absolute";
+})(UnaryNodeOperator || (UnaryNodeOperator = {}));

package/build/src/errors/division_by_zero_error.d.ts

@@ -0,0 +1,3 @@
+export declare class DivisionByZeroError extends Error {
+    constructor();
+}

package/build/src/errors/division_by_zero_error.js

@@ -0,0 +1,6 @@
+export class DivisionByZeroError extends Error {
+    constructor() {
+        super('Division by zero is not allowed');
+        this.name = 'DivisionByZeroError';
+    }
+}

package/build/src/errors/invalid_expression_error.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidExpressionError extends Error {
+    constructor();
+}

package/build/src/errors/invalid_expression_error.js

@@ -0,0 +1,6 @@
+export class InvalidExpressionError extends Error {
+    constructor() {
+        super('Invalid expression encountered during parsing');
+        this.name = 'InvalidExpressionError';
+    }
+}

package/build/src/errors/invalid_number_error.d.ts

@@ -0,0 +1,4 @@
+export declare class InvalidNumberError extends Error {
+    readonly token: string | null;
+    constructor(token?: string | null);
+}

package/build/src/errors/invalid_number_error.js

@@ -0,0 +1,8 @@
+export class InvalidNumberError extends Error {
+    token;
+    constructor(token = null) {
+        super('Invalid number format');
+        this.token = token;
+        this.name = 'InvalidNumberError';
+    }
+}

package/build/src/errors/invalid_square_root_error.d.ts

@@ -0,0 +1,3 @@
+export declare class NegativeSquareRootError extends Error {
+    constructor();
+}

package/build/src/errors/invalid_square_root_error.js

@@ -0,0 +1,6 @@
+export class NegativeSquareRootError extends Error {
+    constructor() {
+        super('Cannot take square root of a negative number');
+        this.name = 'InvalidSquareRootError';
+    }
+}

package/build/src/errors/missing_parenthese_error.d.ts

@@ -0,0 +1,3 @@
+export declare class MissingClosingParenthesisError extends Error {
+    constructor();
+}

package/build/src/errors/missing_parenthese_error.js

@@ -0,0 +1,6 @@
+export class MissingClosingParenthesisError extends Error {
+    constructor() {
+        super('Missing closing parenthesis in the expression');
+        this.name = 'MissingClosingParenthesisError';
+    }
+}

package/build/src/errors/unknown_binary_operator_error.d.ts

@@ -0,0 +1,3 @@
+export declare class UnknownBinaryOperatorError extends Error {
+    constructor(operator: string);
+}

package/build/src/errors/unknown_binary_operator_error.js

@@ -0,0 +1,6 @@
+export class UnknownBinaryOperatorError extends Error {
+    constructor(operator) {
+        super(`Unknown binary operator: ${operator}`);
+        this.name = 'UnknownBinaryOperatorError';
+    }
+}

package/build/src/errors/unknown_node_type_error.d.ts

@@ -0,0 +1,3 @@
+export declare class UnknownNodeTypeError extends Error {
+    constructor(nodeType: string);
+}

package/build/src/errors/unknown_node_type_error.js

@@ -0,0 +1,6 @@
+export class UnknownNodeTypeError extends Error {
+    constructor(nodeType) {
+        super(`Unknown node type: ${nodeType}`);
+        this.name = 'UnknownNodeTypeError';
+    }
+}

package/build/src/errors/unknown_unary_operator_error.d.ts

@@ -0,0 +1,3 @@
+export declare class UnknownUnaryOperatorError extends Error {
+    constructor(operator: string);
+}

package/build/src/errors/unknown_unary_operator_error.js

@@ -0,0 +1,6 @@
+export class UnknownUnaryOperatorError extends Error {
+    constructor(operator) {
+        super(`Unknown unary operator: ${operator}`);
+        this.name = 'UnknownUnaryOperatorError';
+    }
+}

package/build/src/expression_cutter.d.ts

@@ -0,0 +1,4 @@
+export declare class ExpressionCutter {
+    static readonly REGEX: RegExp;
+    cut(expression: string): string[];
+}

package/build/src/expression_cutter.js

@@ -0,0 +1,7 @@
+export class ExpressionCutter {
+    static REGEX = /(\d+(?:\.\d+)?|\+|-|\*|\^|\/|\(|\)|sqrt|abs)/g;
+    cut(expression) {
+        const cleanExpr = expression.replace(/\s+/g, '');
+        return Array.from(cleanExpr.matchAll(ExpressionCutter.REGEX)).map((m) => m[0]);
+    }
+}

package/build/src/expression_evaluator.d.ts

@@ -0,0 +1,10 @@
+import { BinaryNode } from './models/binary_node.js';
+import type { BaseNode } from './models/base_node.js';
+import { UnaryNode } from './models/unary_node.js';
+import { NumberNode } from './models/number_node.js';
+export declare class ExpressionEvaluator {
+    evaluate(node: BaseNode): number;
+    protected evaluateBinaryNode(node: BinaryNode): number;
+    protected evaluateUnaryNode(node: UnaryNode): number;
+    protected evaluateNumberNode(node: NumberNode): number;
+}

package/build/src/expression_evaluator.js

@@ -0,0 +1,74 @@
+import { BinaryNode } from './models/binary_node.js';
+import { UnaryNode } from './models/unary_node.js';
+import { NumberNode } from './models/number_node.js';
+import { UnknownNodeTypeError } from './errors/unknown_node_type_error.js';
+import { BinaryNodeOperator } from './enums/binary_node_operator.js';
+import { UnaryNodeOperator } from './enums/unary_node_operator.js';
+import { NegativeSquareRootError } from './errors/invalid_square_root_error.js';
+import { UnknownUnaryOperatorError } from './errors/unknown_unary_operator_error.js';
+import { UnknownBinaryOperatorError } from './errors/unknown_binary_operator_error.js';
+import { DivisionByZeroError } from './errors/division_by_zero_error.js';
+export class ExpressionEvaluator {
+    evaluate(node) {
+        if (node instanceof BinaryNode) {
+            return this.evaluateBinaryNode(node);
+        }
+        else if (node instanceof UnaryNode) {
+            return this.evaluateUnaryNode(node);
+        }
+        else if (node instanceof NumberNode) {
+            return this.evaluateNumberNode(node);
+        }
+        else {
+            throw new UnknownNodeTypeError(node.type);
+        }
+    }
+    evaluateBinaryNode(node) {
+        switch (node.operator) {
+            case BinaryNodeOperator.SUM: {
+                return this.evaluate(node.left) + this.evaluate(node.right);
+            }
+            case BinaryNodeOperator.SUBTRACT: {
+                return this.evaluate(node.left) - this.evaluate(node.right);
+            }
+            case BinaryNodeOperator.MULTIPLY: {
+                return this.evaluate(node.left) * this.evaluate(node.right);
+            }
+            case BinaryNodeOperator.DIVIDE: {
+                const leftValue = this.evaluate(node.left);
+                const rightValue = this.evaluate(node.right);
+                if (rightValue === 0) {
+                    throw new DivisionByZeroError();
+                }
+                return leftValue / rightValue;
+            }
+            case BinaryNodeOperator.POWER: {
+                return Math.pow(this.evaluate(node.left), this.evaluate(node.right));
+            }
+            default:
+                throw new UnknownBinaryOperatorError(node.operator);
+        }
+    }
+    evaluateUnaryNode(node) {
+        switch (node.operator) {
+            case UnaryNodeOperator.NEGATE: {
+                return -this.evaluate(node.value);
+            }
+            case UnaryNodeOperator.ABSOLUTE: {
+                return Math.abs(this.evaluate(node.value));
+            }
+            case UnaryNodeOperator.SQUARE_ROOT: {
+                const leftValue = this.evaluate(node.value);
+                if (leftValue < 0) {
+                    throw new NegativeSquareRootError();
+                }
+                return Math.sqrt(leftValue);
+            }
+            default:
+                throw new UnknownUnaryOperatorError(node.operator);
+        }
+    }
+    evaluateNumberNode(node) {
+        return node.value;
+    }
+}

package/build/src/expression_parser.d.ts

@@ -0,0 +1,14 @@
+import { BaseNode } from './models/base_node.js';
+import { BinaryNodeOperator } from './enums/binary_node_operator.js';
+export declare class ExpressionParser {
+    protected tokens: string[];
+    protected pos: number;
+    protected peek(): string | null;
+    protected consume(): string;
+    protected match(expected: string[]): string | null;
+    parse(expression: string[]): BaseNode;
+    protected parseExpression(): BaseNode;
+    protected parseTerm(): BaseNode;
+    protected parseFactor(): BaseNode;
+    protected mapRowOperator(operator: string): BinaryNodeOperator;
+}

package/build/src/expression_parser.js

@@ -0,0 +1,94 @@
+import { InvalidExpressionError } from './errors/invalid_expression_error.js';
+import { BinaryNodeOperator } from './enums/binary_node_operator.js';
+import { UnknownBinaryOperatorError } from './errors/unknown_binary_operator_error.js';
+import { NumberNode } from './models/number_node.js';
+import { UnaryNode } from './models/unary_node.js';
+import { UnaryNodeOperator } from './enums/unary_node_operator.js';
+import { MissingClosingParenthesisError } from './errors/missing_parenthese_error.js';
+import { InvalidNumberError } from './errors/invalid_number_error.js';
+import { BinaryNode } from './models/binary_node.js';
+export class ExpressionParser {
+    tokens = [];
+    pos = 0;
+    peek() {
+        return this.tokens[this.pos] ?? null;
+    }
+    consume() {
+        if (this.pos >= this.tokens.length) {
+            throw new InvalidExpressionError();
+        }
+        return this.tokens[this.pos++];
+    }
+    match(expected) {
+        const token = this.peek();
+        if (token && expected.includes(token)) {
+            this.consume();
+            return token;
+        }
+        return null;
+    }
+    parse(expression) {
+        this.tokens = [...expression];
+        this.pos = 0;
+        const node = this.parseExpression();
+        if (this.pos < this.tokens.length) {
+            throw new InvalidExpressionError();
+        }
+        return node;
+    }
+    parseExpression() {
+        let node = this.parseTerm();
+        while (this.match(['+', '-'])) {
+            const operator = this.mapRowOperator(this.tokens[this.pos - 1]);
+            const right = this.parseTerm();
+            node = new BinaryNode(operator, node, right);
+        }
+        return node;
+    }
+    parseTerm() {
+        let node = this.parseFactor();
+        while (this.match(['^', '*', '/'])) {
+            const operator = this.mapRowOperator(this.tokens[this.pos - 1]);
+            const right = this.parseFactor();
+            node = new BinaryNode(operator, node, right);
+        }
+        return node;
+    }
+    parseFactor() {
+        const token = this.peek();
+        if (token === '-') {
+            this.consume(); // consume '-'
+            const value = this.parseFactor();
+            return new UnaryNode(UnaryNodeOperator.NEGATE, value);
+        }
+        if (token === '(') {
+            this.consume(); // consume '('
+            const node = this.parseExpression();
+            if (this.consume() !== ')') {
+                throw new MissingClosingParenthesisError();
+            }
+            return node;
+        }
+        const value = Number(this.consume());
+        if (Number.isNaN(value)) {
+            throw new InvalidNumberError(token);
+        }
+        return new NumberNode(value);
+    }
+    mapRowOperator(operator) {
+        switch (operator) {
+            case '+':
+                return BinaryNodeOperator.SUM;
+            case '-':
+                return BinaryNodeOperator.SUBTRACT;
+            case '*':
+                return BinaryNodeOperator.MULTIPLY;
+            case '/':
+                return BinaryNodeOperator.DIVIDE;
+            case '^':
+                return BinaryNodeOperator.POWER;
+            default:
+                throw new UnknownBinaryOperatorError(operator);
+        }
+    }
+}

package/build/src/expression_tree.d.ts

@@ -0,0 +1,10 @@
+import { ExpressionCutter } from './expression_cutter.js';
+import { ExpressionParser } from './expression_parser.js';
+import { ExpressionEvaluator } from './expression_evaluator.js';
+export declare class ExpressionTree {
+    protected cutter: ExpressionCutter;
+    protected parser: ExpressionParser;
+    protected evaluator: ExpressionEvaluator;
+    constructor(cutter?: ExpressionCutter, parser?: ExpressionParser, evaluator?: ExpressionEvaluator);
+    evaluate(expression: string): number;
+}

package/build/src/expression_tree.js

@@ -0,0 +1,18 @@
+import { ExpressionCutter } from './expression_cutter.js';
+import { ExpressionParser } from './expression_parser.js';
+import { ExpressionEvaluator } from './expression_evaluator.js';
+export class ExpressionTree {
+    cutter;
+    parser;
+    evaluator;
+    constructor(cutter = new ExpressionCutter(), parser = new ExpressionParser(), evaluator = new ExpressionEvaluator()) {
+        this.cutter = cutter;
+        this.parser = parser;
+        this.evaluator = evaluator;
+    }
+    evaluate(expression) {
+        const cutExpression = this.cutter.cut(expression);
+        const baseNode = this.parser.parse(cutExpression);
+        return this.evaluator.evaluate(baseNode);
+    }
+}

package/build/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/build/src/index.js

@@ -0,0 +1 @@
+export {};

package/build/src/models/base_node.d.ts

@@ -0,0 +1,5 @@
+import type { NodeType } from '../enums/node_type.js';
+export declare abstract class BaseNode {
+    readonly type: NodeType;
+    protected constructor(type: NodeType);
+}

package/build/src/models/base_node.js

@@ -0,0 +1,6 @@
+export class BaseNode {
+    type;
+    constructor(type) {
+        this.type = type;
+    }
+}

package/build/src/models/binary_node.d.ts

@@ -0,0 +1,8 @@
+import { BaseNode } from './base_node.js';
+import { BinaryNodeOperator } from '../enums/binary_node_operator.js';
+export declare class BinaryNode extends BaseNode {
+    operator: BinaryNodeOperator;
+    left: BaseNode;
+    right: BaseNode;
+    constructor(operator: BinaryNodeOperator, left: BaseNode, right: BaseNode);
+}

package/build/src/models/binary_node.js

@@ -0,0 +1,13 @@
+import { BaseNode } from './base_node.js';
+import { NodeType } from '../enums/node_type.js';
+export class BinaryNode extends BaseNode {
+    operator;
+    left;
+    right;
+    constructor(operator, left, right) {
+        super(NodeType.BINARY);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+}

package/build/src/models/number_node.d.ts

@@ -0,0 +1,6 @@
+import { BaseNode } from './base_node.js';
+export declare class NumberNode extends BaseNode {
+    readonly value: number;
+    constructor(value: number);
+    toString(): string;
+}

package/build/src/models/number_node.js

@@ -0,0 +1,12 @@
+import { BaseNode } from './base_node.js';
+import { NodeType } from '../enums/node_type.js';
+export class NumberNode extends BaseNode {
+    value;
+    constructor(value) {
+        super(NodeType.NUMBER);
+        this.value = value;
+    }
+    toString() {
+        return this.value.toString();
+    }
+}

package/build/src/models/unary_node.d.ts

@@ -0,0 +1,7 @@
+import { BaseNode } from './base_node.js';
+import type { UnaryNodeOperator } from '../enums/unary_node_operator.js';
+export declare class UnaryNode extends BaseNode {
+    operator: UnaryNodeOperator;
+    value: BaseNode;
+    constructor(operator: UnaryNodeOperator, value: BaseNode);
+}

package/build/src/models/unary_node.js

@@ -0,0 +1,11 @@
+import { BaseNode } from './base_node.js';
+import { NodeType } from '../enums/node_type.js';
+export class UnaryNode extends BaseNode {
+    operator;
+    value;
+    constructor(operator, value) {
+        super(NodeType.UNARY);
+        this.operator = operator;
+        this.value = value;
+    }
+}

package/build/src/render_expression.d.ts

@@ -0,0 +1,2 @@
+import type { BaseNode } from './models/base_node.js';
+export declare function renderExpression(node: BaseNode): string;