omdBinaryExpressionNode

Represents a binary operation in a mathematical expression, such as addition (a + b), subtraction, multiplication, or division. This node is a cornerstone of the expression tree, containing a left operand, a right operand, and an operator.

Class Definition

export class omdBinaryExpressionNode extends omdNode

Constructor

new omdBinaryExpressionNode(ast)

Creates a new omdBinaryExpressionNode instance.

• ast (object): The abstract syntax tree (AST) node from a parser like math.js. It must contain:
  • args: An array with at least two operand nodes.
  • op: The operator symbol (e.g., +, *).
  • fn: The function name for the operation (e.g., add, multiply).
  • implicit (boolean, optional): true if the multiplication is implicit (e.g., 2x).

During construction, the node automatically handles a critical piece of mathematical convention: implicit multiplication. Based on the configuration in omdConfigManager, it will:

1. Reorder Operands: If it encounters an expression like x * 2, it will automatically reorder it to the conventional 2 * x by swapping the left and right child nodes.
2. Determine Implicit Form: It checks if the combination of operands (e.g., a constant and a variable) should be represented implicitly. If so, it removes the visible operator (*) and marks the node as implicit.

Public Properties

• left (omdNode): The node representing the left-hand side of the operation.
• right (omdNode): The node representing the right-hand side of the operation.
• op (omdOperatorNode | null): The node for the operator. This is null for implicit multiplication.
• operation (string): The name of the mathematical function (e.g., 'add', 'multiply').
• isImplicit (boolean): true if the node represents implicit multiplication.

Public Methods

clone()

Creates a deep, recursive clone of the node, including its children (left, right, op). The new node's provenance property will link back to the ID of this original node.

• Returns: A new omdBinaryExpressionNode instance.

evaluate(variables)

Recursively evaluates the expression and returns the numerical result.

• variables (object, optional): A map of variable names to their numeric values (e.g., { x: 5 }).
• Returns: number - The result of the calculation.
• Throws: An Error for unsupported operations or division by zero.

needsParentheses()

Determines if this expression needs to be wrapped in parentheses to maintain the correct order of operations when it is a child of another binary expression.

• Returns: boolean - true if parentheses are required.

setHighlight(highlightOn, color)

Applies or removes a highlight from the node and all of its children (left, right, and operator).

• highlightOn (boolean): true to highlight, false to remove.
• color (string, optional): The color of the highlight.

clearProvenanceHighlights()

Recursively clears all provenance-related highlights from this node and its children.

toMathJSNode()

Converts the node back into a math.js-compatible AST format.

• Returns: object - A math.js OperatorNode.

toString()

Converts the node into a human-readable string, automatically handling parentheses for precedence.

• Returns: string - The string representation of the expression.

Internal Methods

• _shouldUseImplicitMultiplication(left, right): Checks the configuration to decide if implicit multiplication is appropriate for the given operand types.
• _shouldReorderMultiplication(left, right): Determines if operands should be swapped to follow convention (e.g., variable * constant -> constant * variable).
• computeDimensions(): Calculates the bounding box of the expression.
• updateLayout(): Positions the left operand, operator, and right operand correctly, aligning them along their baseline.