@flomsstaar/expression-tree 0.1.0

package/build/tests/inputs/expression_parser_input.js

@@ -0,0 +1,197 @@
+import { BinaryNodeOperator } from '../../src/enums/binary_node_operator.js';
+import { BinaryNode } from '../../src/models/binary_node.js';
+import { NumberNode } from '../../src/models/number_node.js';
+import { UnaryNodeOperator } from '../../src/enums/unary_node_operator.js';
+import { UnaryNode } from '../../src/models/unary_node.js';
+export function expressionParserInput() {
+    return [
+        // Classic cases
+        [['6', '+', '5'], new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(6), new NumberNode(5))],
+        [
+            ['6', '-', '5'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['6', '*', '5'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['6', '/', '5'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['6', '^', '5'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['64', '+', '5'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['64', '-', '5'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['64', '*', '5'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['64', '/', '5'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['64', '^', '5'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['6', '+', '25'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['6', '-', '25'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['6', '*', '25'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['6', '/', '25'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['6', '^', '25'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['12', '+', '34'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['12', '-', '34'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['12', '*', '34'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['12', '/', '34'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['12', '^', '34'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(12), new NumberNode(34)),
+        ],
+        // Parentheses
+        [
+            ['(', '6', '+', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['(', '6', '-', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['(', '6', '*', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['(', '6', '/', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['(', '6', '^', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(6), new NumberNode(5)),
+        ],
+        [
+            ['(', '64', '+', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['(', '64', '-', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['(', '64', '*', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['(', '64', '/', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['(', '64', '^', '5', ')'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(64), new NumberNode(5)),
+        ],
+        [
+            ['(', '6', '+', '25', ')'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['(', '6', '-', '25', ')'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['(', '6', '*', '25', ')'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['(', '6', '/', '25', ')'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['(', '6', '^', '25', ')'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(6), new NumberNode(25)),
+        ],
+        [
+            ['(', '12', '+', '34', ')'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['(', '12', '-', '34', ')'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['(', '12', '*', '34', ')'],
+            new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['(', '12', '/', '34', ')'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(12), new NumberNode(34)),
+        ],
+        [
+            ['(', '12', '^', '34', ')'],
+            new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(12), new NumberNode(34)),
+        ],
+        // Negative numbers
+        [
+            ['-', '6', '+', '5'],
+            new BinaryNode(BinaryNodeOperator.SUM, new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(6)), new NumberNode(5)),
+        ],
+        [
+            ['6', '+', '-', '5'],
+            new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(6), new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(5))),
+        ],
+        [
+            ['6', '-', '-', '5'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(6), new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(5))),
+        ],
+        [
+            ['-', '6', '-', '5'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(6)), new NumberNode(5)),
+        ],
+        [
+            ['-', '6', '-', '-', '5'],
+            new BinaryNode(BinaryNodeOperator.SUBTRACT, new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(6)), new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(5))),
+        ],
+        [
+            ['-', '(', '5', '+', '2', ')'],
+            new UnaryNode(UnaryNodeOperator.NEGATE, new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(5), new NumberNode(2))),
+        ],
+        [
+            ['-', '(', '5', '*', '2', '-', '4', ')', '/', '2'],
+            new BinaryNode(BinaryNodeOperator.DIVIDE, new UnaryNode(UnaryNodeOperator.NEGATE, new BinaryNode(BinaryNodeOperator.SUBTRACT, new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(5), new NumberNode(2)), new NumberNode(4))), new NumberNode(2)),
+        ],
+    ];
+}

package/build/tests/inputs/expression_tree_input.d.ts

@@ -0,0 +1 @@
+export declare function expressionTreeInput(): [string, number][];

package/build/tests/inputs/expression_tree_input.js

@@ -0,0 +1,44 @@
+export function expressionTreeInput() {
+    return [
+        ['6 + 5', 11],
+        ['6 - 5', 1],
+        ['6 * 5', 30],
+        ['6 / 5', 1.2],
+        ['6 ^ 5', 7776],
+        ['64 + 5', 69],
+        ['64 - 5', 59],
+        ['64 * 5', 320],
+        ['64 / 5', 12.8],
+        ['64 ^ 5', 1073741824],
+        ['6 + 25', 31],
+        ['6 - 25', -19],
+        ['6 * 25', 150],
+        ['6 / 25', 0.24],
+        ['6 ^ 12', 2176782336],
+        ['(6 ^ 2)', 36],
+        ['(2 ^ 15)', 32768],
+        ['(12 ^ 4)', 20736],
+        ['(6 + 5) ^ (4 * 3)', 3138428376721],
+        ['2 ^ -1', 0.5],
+        ['(6 + 5) * (3 - 1)', 22],
+        ['(6 + -2) * (3 - 1)', 8],
+        ['(6 + -2) * (3 - -1)', 16],
+        ['(6 + -2) * (3 - -1) / (3 + -1)', 8],
+        ['(6 + -2) * (3 - -1) / (3 + -1) / (2 + -1)', 8],
+        ['6 - -2 + 5', 13],
+        ['6 + -(2 + 5)', -1],
+        ['6 + -2 * 5', -4],
+        ['6 + -2 * (5 + 3)', -10],
+        ['6 + -2 * (5 + 3) / 2', -2],
+        ['6 + -2 * (5 + 3) / (3 + 1)', 2],
+        ['6 + -(2 * 5)', -4],
+        ['6 + 2 * 3 - 1', 11],
+        ['6 + 2 * (3 - 1)', 10],
+        ['6 + 2 * (3 - 1) / 2', 8],
+        ['6 + 2 * (3 - 1) / (3 + 1)', 7],
+        ['(6 + 2) * (3 - 1)', 16],
+        ['(6 + 2) * (4 - 1) / (2 + 1)', 8],
+        ['(6 + -2) * (3 - 1)', 8],
+        ['(6 + -2) * (3 - 2) / 2', 2],
+    ];
+}

package/build/tests/number_node.test.d.ts

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

package/build/tests/number_node.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { NumberNode } from '../src/models/number_node.js';
+import { NodeType } from '../src/enums/node_type.js';
+describe('number node', () => {
+    it('should create a number node with the correct value', () => {
+        const value = 42;
+        const node = new NumberNode(value);
+        expect(node.value).toBe(value);
+        expect(node.type).toBe(NodeType.NUMBER);
+    });
+    it('should return the correct string representation', () => {
+        const value = 42;
+        const node = new NumberNode(value);
+        expect(node.toString()).toBe(value.toString());
+    });
+});

package/build/tests/render_expression.test.d.ts

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

package/build/tests/render_expression.test.js

@@ -0,0 +1,85 @@
+import { describe, expect, it, test } from 'vitest';
+import { UnaryNode } from '../src/models/unary_node.js';
+import { UnaryNodeOperator } from '../src/enums/unary_node_operator.js';
+import { NumberNode } from '../src/models/number_node.js';
+import { renderExpression } from '../src/render_expression.js';
+import { BinaryNode } from '../src/models/binary_node.js';
+import { BinaryNodeOperator } from '../src/enums/binary_node_operator.js';
+import { UnknownBinaryOperatorError } from '../src/errors/unknown_binary_operator_error.js';
+import { UnknownNodeTypeError } from '../src/errors/unknown_node_type_error.js';
+import { UnknownUnaryOperatorError } from '../src/errors/unknown_unary_operator_error.js';
+describe('render expression', () => {
+    describe('unary node operations', () => {
+        describe('negation operation', () => {
+            it('should render a negation of a number', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(5));
+                const result = renderExpression(expression);
+                expect(result).toBe('-5');
+            });
+            it('should render a negation of zero', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.NEGATE, new NumberNode(0));
+                const result = renderExpression(expression);
+                expect(result).toBe('0');
+            });
+            it('should render a negation of an operation', () => {
+                const expression = new UnaryNode(UnaryNodeOperator.NEGATE, new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(3), new NumberNode(2)));
+                const result = renderExpression(expression);
+                expect(result).toBe('-(3 + 2)');
+            });
+        });
+        it('should render a square root of a number', () => {
+            const expression = new UnaryNode(UnaryNodeOperator.SQUARE_ROOT, new NumberNode(16));
+            const result = renderExpression(expression);
+            expect(result).toBe('sqrt(16)');
+        });
+        it('should render an absolute value of a number', () => {
+            const expression = new UnaryNode(UnaryNodeOperator.ABSOLUTE, new NumberNode(-10));
+            const result = renderExpression(expression);
+            expect(result).toBe('abs(-10)');
+        });
+    });
+    describe('binary node operations', () => {
+        it('should render a sum of two numbers', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.SUM, new NumberNode(3), new NumberNode(2));
+            const result = renderExpression(expression);
+            expect(result).toBe('3 + 2');
+        });
+        it('should render a subtraction of two numbers', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.SUBTRACT, new NumberNode(5), new NumberNode(2));
+            const result = renderExpression(expression);
+            expect(result).toBe('5 - 2');
+        });
+        it('should render a multiplication of two numbers', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.MULTIPLY, new NumberNode(4), new NumberNode(3));
+            const result = renderExpression(expression);
+            expect(result).toBe('4 * 3');
+        });
+        it('should render a division of two numbers', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.DIVIDE, new NumberNode(8), new NumberNode(2));
+            const result = renderExpression(expression);
+            expect(result).toBe('8 / 2');
+        });
+        it('should render a power operation', () => {
+            const expression = new BinaryNode(BinaryNodeOperator.POWER, new NumberNode(2), new NumberNode(3));
+            const result = renderExpression(expression);
+            expect(result).toBe('2 ^ 3');
+        });
+    });
+    describe('unsupported operations', () => {
+        test('unknown unary operator', () => {
+            const expression = new UnaryNode('UNKNOWN_UNARY_OPERATOR', new NumberNode(1));
+            expect(() => renderExpression(expression)).toThrowError(UnknownUnaryOperatorError);
+        });
+        test('unknown binary operator', () => {
+            const expression = new BinaryNode('UNKNOWN_OPERATOR', new NumberNode(1), new NumberNode(2));
+            expect(() => renderExpression(expression)).toThrowError(UnknownBinaryOperatorError);
+        });
+        test('unknown node type', () => {
+            const expression = {
+                type: 'UNKNOWN_NODE_TYPE',
+                value: 42,
+            };
+            expect(() => renderExpression(expression)).toThrowError(UnknownNodeTypeError);
+        });
+    });
+});

package/build/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/build/vitest.config.js

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        include: ['tests/**/*.test.ts'],
+        coverage: {
+            include: ['src/**/*.ts'],
+            reporter: ['text', 'lcov'],
+        },
+    },
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@flomsstaar/expression-tree",
+  "version": "0.1.0",
+  "main": "build/index.js",
+  "type": "module",
+  "files": [
+    "src",
+    "build"
+  ],
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "scripts": {
+    "dev": "bun index.ts",
+    "lint": "eslint src index.ts",
+    "lint:fix": "eslint src index.ts --fix",
+    "format": "prettier --check src index.ts",
+    "format:fix": "prettier --write src index.ts",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "typecheck": "bun run tsc --noEmit"
+  },
+  "devDependencies": {
+    "@adonisjs/eslint-config": "^2.1.0",
+    "@adonisjs/prettier-config": "^1.4.5",
+    "@adonisjs/tsconfig": "^1.4.1",
+    "@types/bun": "latest",
+    "@vitest/coverage-v8": "3.2.4",
+    "eslint": "^9.29.0",
+    "prettier": "^3.6.0",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "author": "Florent Marques <florent.marques19@gmail.com>",
+  "license": "MIT",
+  "keywords": [
+    "expression-tree",
+    "calculator"
+  ],
+  "repository": "https://github.com/flomSStaar/expression-tree-ts",
+  "eslintConfig": {
+    "extends": "@adonisjs/eslint-config/app"
+  },
+  "prettier": "@adonisjs/prettier-config"
+}

package/src/enums/binary_node_operator.ts

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

package/src/enums/node_type.ts

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

package/src/enums/unary_node_operator.ts

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

package/src/errors/division_by_zero_error.ts

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

package/src/errors/invalid_expression_error.ts

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

package/src/errors/invalid_number_error.ts

@@ -0,0 +1,6 @@
+export class InvalidNumberError extends Error {
+  constructor(public readonly token: string | null = null) {
+    super('Invalid number format')
+    this.name = 'InvalidNumberError'
+  }
+}

package/src/errors/invalid_square_root_error.ts

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

package/src/errors/missing_parenthese_error.ts

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

package/src/errors/unknown_binary_operator_error.ts

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

package/src/errors/unknown_node_type_error.ts

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

package/src/errors/unknown_unary_operator_error.ts

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

package/src/expression_cutter.ts

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

package/src/expression_evaluator.ts

@@ -0,0 +1,76 @@
+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'
+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 {
+  public evaluate(node: BaseNode): number {
+    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)
+    }
+  }
+
+  protected evaluateBinaryNode(node: BinaryNode): number {
+    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)
+    }
+  }
+
+  protected evaluateUnaryNode(node: UnaryNode): number {
+    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)
+    }
+  }
+
+  protected evaluateNumberNode(node: NumberNode): number {
+    return node.value
+  }
+}