# OMD Documentation

# omdRationalNode

Represents a fraction, with a numerator and a denominator, such as `1/2` or `(x+1)/(x-1)`. It handles the distinct visual layout of a fraction, with the numerator positioned above the denominator, separated by a horizontal line.

## Class Definition

    export class omdRationalNode extends omdNode

## Constructor

### `new omdRationalNode(astNodeData)`

Creates a new `omdRationalNode` instance.

- `astNodeData` (`object`): The math.js AST for the division operation. It must be an `OperatorNode` with `op: '/'` and an `args` array containing two elements: the numerator and the denominator. The constructor also creates and initializes the visual `fractionLine`.

## Static Methods

### `fromString(expressionString)`

Creates an `omdRationalNode` from a string containing a division. Requires `window.math` (math.js) to be available globally for parsing.

- `expressionString` (`string`): The fractional expression as a string (e.g., `"x / 2"`, `"(a+b)/(a-b)"`).
- Returns: `omdRationalNode` - A new instance.
- Throws: `Error` if `math.js` is not available, if the string cannot be parsed, or if it does not represent a valid division expression.

## Public Properties

- `numerator` (`omdNode`): The node representing the top part of the fraction.
- `denominator` (`omdNode`): The node representing the bottom part of the fraction.
- `fractionLine` (`jsvgLine`): The visual horizontal line separating the numerator and denominator.

## Public Methods

### `computeDimensions()`

Calculates the dimensions of the rational node. It scales down the font size of the numerator and denominator, computes their individual dimensions, and then determines the total width (maximum of numerator/denominator width plus spacing) and total height (sum of numerator, denominator, and padding for the fraction line).

- Overrides: `omdNode.computeDimensions()`.

### `updateLayout()`

Updates the layout of the rational node. It positions the `numerator` at the top, the `fractionLine` in the middle, and the `denominator` at the bottom, ensuring they are horizontally centered and have appropriate vertical spacing.

- Overrides: `omdNode.updateLayout()`.

### `getAlignmentBaseline()`

Calculates the vertical alignment point for the node. For a rational node, this is the y-position of the fraction bar, which serves as the visual baseline.

- Overrides: `omdNode.getAlignmentBaseline()`.

### `isConstant()`

Checks if both the numerator and the denominator are constant numerical values.

- Returns: `boolean`.

### `getRationalValue()`

Retrieves the rational value of the node as a numerator/denominator pair. This method only works if the fraction is constant.

- Returns: `{ num: number, den: number }`.
- Throws: `Error` if the rational node is not constant.

### `getValue()`

Retrieves the numerical value of the rational node by dividing the numerator's value by the denominator's value. This method only works if the fraction is constant.

- Returns: `number`.
- Throws: `Error` if the rational node is not constant or if division by zero occurs.

### `clone()`

Creates a deep, structural clone of the rational node, including its `numerator` and `denominator` nodes. The `fractionLine` is also recreated. The cloned node's `provenance` array is updated to include the original node's ID.

- Returns: `omdRationalNode` - A new, identical instance of the rational node.

### `toMathJSNode()`

Converts the `omdRationalNode` back into its math.js AST representation. It creates an `OperatorNode` with `op: '/'` and `fn: 'divide'`, containing the converted numerator and denominator ASTs.

- Returns: `object` - A math.js `OperatorNode` for division. The returned object also includes a `clone` method for compatibility.

### `toString()`

Converts the node to its string representation, adding parentheses around the numerator and/or denominator if they are complex expressions (e.g., binary expressions) to maintain correct order of operations.

- Returns: `string` - e.g., `"(x + 1) / (x - 1)"`.

### `evaluate(variables)`

Evaluates the rational expression by evaluating the numerator and denominator and then performing the division.

- `variables` (`object`): A map of variable names to their values.
- Returns: `number` - The result of the division.
- Throws: `Error` if the denominator evaluates to zero.

### `reduce()`

If the fraction is constant, this method reduces it to its lowest terms (e.g., `4/8` becomes `1/2`). If the reduced denominator is `1`, it returns an `omdConstantNode` representing the integer value. It uses a `gcd` (greatest common divisor) helper function internally.

- Returns: `omdRationalNode` | `omdConstantNode` - The reduced fraction node, or an `omdConstantNode` if it simplifies to an integer.

### `isProper()`

Checks if the fraction is proper (the absolute value of the numerator is less than the absolute value of the denominator). This check only applies to constant fractions.

- Returns: `boolean` | `null` - `true` if proper, `false` if improper, `null` if the fraction is not constant.

## Internal Methods

- `parseValue()`: Sets the `value` property to `"/"`.
- `createOperand(ast)`: Creates an `omdNode` instance for the numerator or denominator from its AST, attempting to preserve provenance.

## Example

    import { omdRationalNode } from '@teachinglab/omd';
    import * as math from 'mathjs';

    // Create a fraction from a string
    const fraction = omdRationalNode.fromString('(a+b)/(a-b)');

    // Set font size and render
    fraction.setFontSize(28);
    fraction.initialize();

    // Evaluate with given variables
    const result = fraction.evaluate({ a: 3, b: 1 });
    console.log(result); // Output: 2 (since (3+1)/(3-1) = 4/2 = 2)

    // Add to an SVG container to display
    // const svgContainer = new jsvgContainer();
    // svgContainer.addChild(fraction);
    // document.body.appendChild(svgContainer.svgObject);

## See Also

- `omdNode` - The base class.
- `omdConstantNode` - For constant numerators/denominators.
- `omdBinaryExpressionNode` - For complex numerators/denominators.

↑ Top