@flomsstaar/expression-tree 0.1.0

package/src/expression_parser.ts

@@ -0,0 +1,117 @@
+import { InvalidExpressionError } from './errors/invalid_expression_error.js'
+import { BaseNode } from './models/base_node.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 {
+  protected tokens: string[] = []
+  protected pos: number = 0
+
+  protected peek(): string | null {
+    return this.tokens[this.pos] ?? null
+  }
+
+  protected consume(): string {
+    if (this.pos >= this.tokens.length) {
+      throw new InvalidExpressionError()
+    }
+    return this.tokens[this.pos++]
+  }
+
+  protected match(expected: string[]): string | null {
+    const token = this.peek()
+    if (token && expected.includes(token)) {
+      this.consume()
+      return token
+    }
+    return null
+  }
+
+  public parse(expression: string[]): BaseNode {
+    this.tokens = [...expression]
+    this.pos = 0
+
+    const node = this.parseExpression()
+
+    if (this.pos < this.tokens.length) {
+      throw new InvalidExpressionError()
+    }
+
+    return node
+  }
+
+  protected parseExpression(): BaseNode {
+    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
+  }
+
+  protected parseTerm(): BaseNode {
+    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
+  }
+
+  protected parseFactor(): BaseNode {
+    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)
+  }
+
+  protected mapRowOperator(operator: string): BinaryNodeOperator {
+    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/src/expression_tree.ts

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

package/src/models/base_node.ts

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

package/src/models/binary_node.ts

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

package/src/models/number_node.ts

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

package/src/models/unary_node.ts

@@ -0,0 +1,12 @@
+import { BaseNode } from './base_node.js'
+import type { UnaryNodeOperator } from '../enums/unary_node_operator.js'
+import { NodeType } from '../enums/node_type.js'
+
+export class UnaryNode extends BaseNode {
+  constructor(
+    public operator: UnaryNodeOperator,
+    public value: BaseNode
+  ) {
+    super(NodeType.UNARY)
+  }
+}

package/src/render_expression.ts

@@ -0,0 +1,57 @@
+import type { BaseNode } from './models/base_node.js'
+import { NumberNode } from './models/number_node.js'
+import { BinaryNode } from './models/binary_node.js'
+import { BinaryNodeOperator } from './enums/binary_node_operator.js'
+import { UnknownBinaryOperatorError } from './errors/unknown_binary_operator_error.js'
+import { UnaryNode } from './models/unary_node.js'
+import { UnaryNodeOperator } from './enums/unary_node_operator.js'
+import { UnknownUnaryOperatorError } from './errors/unknown_unary_operator_error.js'
+import { UnknownNodeTypeError } from './errors/unknown_node_type_error.js'
+
+export function renderExpression(node: BaseNode): string {
+  if (node instanceof BinaryNode) {
+    const leftNode = renderExpression(node.left)
+    const rightNode = renderExpression(node.right)
+    const operator = {
+      [BinaryNodeOperator.SUM]: '+',
+      [BinaryNodeOperator.SUBTRACT]: '-',
+      [BinaryNodeOperator.MULTIPLY]: '*',
+      [BinaryNodeOperator.DIVIDE]: '/',
+      [BinaryNodeOperator.POWER]: '^',
+    }[node.operator]
+
+    if (!operator) {
+      throw new UnknownBinaryOperatorError(node.operator)
+    }
+
+    return `${leftNode} ${operator} ${rightNode}`
+  } else if (node instanceof UnaryNode) {
+    switch (node.operator) {
+      case UnaryNodeOperator.NEGATE: {
+        if (node.value instanceof NumberNode && node.value.value === 0) {
+          return '0'
+        } else if (node.value instanceof BinaryNode) {
+          const valueNode = renderExpression(node.value)
+          return `-(${valueNode})`
+        }
+
+        const valueNode = renderExpression(node.value)
+        return `-${valueNode}`
+      }
+      case UnaryNodeOperator.ABSOLUTE: {
+        const valueNode = renderExpression(node.value)
+        return `abs(${valueNode})`
+      }
+      case UnaryNodeOperator.SQUARE_ROOT: {
+        const valueNode = renderExpression(node.value)
+        return `sqrt(${valueNode})`
+      }
+      default:
+        throw new UnknownUnaryOperatorError(node.operator)
+    }
+  } else if (node instanceof NumberNode) {
+    return node.toString()
+  } else {
+    throw new UnknownNodeTypeError(node.type)
+  }
+}