UNPKG

@teachinglab/omd

Version:

omd

98 lines (62 loc) • 4.64 kB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
# SimplificationEngine The `SimplificationEngine` is a static class that provides a collection of helper methods for creating, matching, and transforming expression nodes. It forms the backbone of the simplification rule system. ## Overview The engine is not instantiated. Instead, its static methods are used directly by the simplification rules to perform their logic. The methods can be grouped into several categories: - **Node Creation:** Helpers to build new `omdNode` instances (e.g., `createConstant`, `createBinaryOp`). - **Pattern Matching:** Helpers to check if a node matches a specific structure or value (e.g., `isBinaryOp`, `isConstantValue`). - **Monomial Helpers:** Specialized functions for working with monomials (terms like `2x^2`), which are essential for rules like combining like terms. - **Rule Definition:** The `SimplificationRule` inner class, which defines the structure for all simplification rules. ## Node Creation Helpers These methods simplify the process of creating new nodes, often by abstracting away the underlying AST structure. #### `createConstant(value, fontSize)` - Creates an `omdConstantNode`. #### `createBinaryOp(left, operator, right, ...)` - Creates an `omdBinaryExpressionNode` for operations like 'add', 'subtract', etc. #### `createMultiplication(leftConstantNode, rightNode, ...)` - A specialized version of `createBinaryOp` for multiplication. #### `createRational(numerator, denominator, fontSize)` - Creates an `omdRationalNode` (a fraction). #### `createMonomial(coefficient, variable, power, ...)` - Constructs a complete monomial term (e.g., `2x^3`) from its constituent parts. ## Pattern Matching Helpers These methods are used within the `match` function of a simplification rule to determine if the rule applies to a given node. #### `isType(node, typeName)` - Checks if a node is an instance of a specific class (e.g., `'omdConstantNode'`). #### `isBinaryOp(node, operator)` - Checks if a node is a binary operation, optionally matching a specific operator (e.g., `'add'`). #### `isConstantValue(node, value)` - Checks if a node is a constant, optionally matching a specific value. #### `hasConstantOperand(node)` - For a binary operation, checks if one of its operands is a constant and returns both the constant and the other operand. #### `unwrapParentheses(node)` - If the given node is an `omdParenthesisNode`, it returns the inner expression; otherwise, it returns the node itself. ## Monomial and Like Terms Helpers #### `isMonomial(node)` - A powerful helper that checks if a node represents a monomial (e.g., `x`, `2x`, `-5x^2`). - **Returns:** An object with `{ coefficient, variable, power, ... }` if it is a monomial, otherwise `null`. #### `areLikeTerms(monomial1, monomial2)` - Compares the output of two `isMonomial` calls to see if they have the same variable and power. ## `SimplificationRule` Class This is an inner class of `SimplificationEngine` that provides the blueprint for all simplification rules. ### Constructor `new SimplificationRule(name, matchFn, transformFn, messageFn, type)` - `name` {string}: The name of the rule (e.g., "Combine Constants"). - `matchFn` {function}: A function that takes a node and returns `true` or a data object if the rule applies, `false` otherwise. - `transformFn` {function}: A function that takes the matched node and the data from `matchFn` and returns a new, transformed node. - `messageFn` {function} (optional): A function to generate a user-friendly description of the change. ### Key Methods - `canApply(node)`: Executes the `matchFn`. - `apply(node, ruleData, currentRoot)`: Executes the `transformFn` and handles replacing the old node with the new one in the expression tree. ## Rule Factory Functions These are static methods on `SimplificationEngine` that create common types of rules. #### `createRule(...)` - The base factory function for creating a `SimplificationRule` instance. #### `createConstantFoldRule(name, operator)` - Creates a rule that evaluates binary operations on two constants (e.g., `2 + 3` -> `5`). #### `createIdentityRule(name, operator, identityValue, side)` - Creates a rule for identity operations (e.g., `x + 0` -> `x` or `y * 1` -> `y`). #### `createZeroMultiplicationRule()` - Creates the rule for `x * 0` -> `0`. ### See Also - [`omdSimplification`](./omdSimplification.md): The top-level module that uses the engine. - [`simplificationRules`](./simplificationRules.md): The module where specific rules are defined using the engine's helpers.