@teachinglab/omd 0.6.0 → 0.6.2

package/omd/simplification/rules/sqrtRules.js

@@ -1,48 +1,48 @@
-import { SimplificationEngine } from '../omdSimplificationEngine.js';
-import * as utils from '../simplificationUtils.js';
-
-// ===== SQRT NODE RULES =====
-export const sqrtRules = [
-    // Simplify square root of perfect squares (sqrt(9) → 3)
-    SimplificationEngine.createRule("Simplify Square Root of Constant",
-        (node) => {
-            if (!node.argument.isConstant()) return false;
-            const value = node.argument.getValue();
-            if (value < 0) return false;
-
-            const sqrt = Math.sqrt(value);
-            return Number.isInteger(sqrt) ? { value: sqrt } : false;
-        },
-        (node, data) => {
-            const newNode = SimplificationEngine.createConstant(data.value, node.getFontSize());
-            newNode.provenance.push(node.id, node.argument.id);
-            return newNode;
-        },
-        (originalNode, ruleData, newNode) => {
-            const value = originalNode.argument.getValue();
-            const result = ruleData.value;
-            return `Calculated square root: √${value} = ${result}`;
-        }
-    ),
-
-    // Simplify sqrt(x^2) → x (assuming x ≥ 0 for simplicity)
-    SimplificationEngine.createRule("Square Root of Square",
-        (node) => {
-            if (!node.argument || node.argument.type !== 'omdPowerNode') return false;
-            
-            const powerNode = node.argument;
-            if (!powerNode.exponent.isConstant() || powerNode.exponent.getValue() !== 2) return false;
-            
-            return { base: powerNode.base };
-        },
-        (node, data) => {
-            const newNode = data.base.clone();
-            newNode.provenance.push(node.id, node.argument.id);
-            return newNode;
-        },
-        (originalNode, ruleData, newNode) => {
-            const baseStr = utils.nodeToString(ruleData.base);
-            return `Simplified square root of square: √(${baseStr}²) = ${baseStr}`;
-        }
-    )
-];
+import { SimplificationEngine } from '../omdSimplificationEngine.js';
+import * as utils from '../simplificationUtils.js';
+
+// ===== SQRT NODE RULES =====
+export const sqrtRules = [
+    // Simplify square root of perfect squares (sqrt(9) → 3)
+    SimplificationEngine.createRule("Simplify Square Root of Constant",
+        (node) => {
+            if (!node.argument.isConstant()) return false;
+            const value = node.argument.getValue();
+            if (value < 0) return false;
+
+            const sqrt = Math.sqrt(value);
+            return Number.isInteger(sqrt) ? { value: sqrt } : false;
+        },
+        (node, data) => {
+            const newNode = SimplificationEngine.createConstant(data.value, node.getFontSize());
+            newNode.provenance.push(node.id, node.argument.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const value = originalNode.argument.getValue();
+            const result = ruleData.value;
+            return `Calculated square root: √${value} = ${result}`;
+        }
+    ),
+
+    // Simplify sqrt(x^2) → x (assuming x ≥ 0 for simplicity)
+    SimplificationEngine.createRule("Square Root of Square",
+        (node) => {
+            if (!node.argument || node.argument.type !== 'omdPowerNode') return false;
+            
+            const powerNode = node.argument;
+            if (!powerNode.exponent.isConstant() || powerNode.exponent.getValue() !== 2) return false;
+            
+            return { base: powerNode.base };
+        },
+        (node, data) => {
+            const newNode = data.base.clone();
+            newNode.provenance.push(node.id, node.argument.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const baseStr = utils.nodeToString(ruleData.base);
+            return `Simplified square root of square: √(${baseStr}²) = ${baseStr}`;
+        }
+    )
+];

package/omd/simplification/rules/unaryRules.js

@@ -1,37 +1,37 @@
-import { SimplificationEngine } from '../omdSimplificationEngine.js';
-import * as utils from '../simplificationUtils.js';
-
-// ===== UNARY EXPRESSION RULES =====
-export const unaryRules = [
-    // Simplify double negation (-(-x) → x)
-    SimplificationEngine.createRule("Simplify Double Negation",
-        (node) => {
-            return node.operation === 'unaryMinus' && 
-                   SimplificationEngine.isType(node.argument, 'omdUnaryExpressionNode') &&
-                   node.argument.operation === 'unaryMinus';
-        },
-        (node) => {
-            const newNode = node.argument.argument.clone();
-            newNode.provenance.push(node.id, node.argument.id);
-            return newNode;
-        },
-        (originalNode, ruleData, newNode) => {
-            const childStr = utils.nodeToString(originalNode.argument.argument);
-            return `Simplified double negation: -(-${childStr}) = ${childStr}`;
-        }
-    ),
-
-    // Remove unary plus (+x → x)
-    SimplificationEngine.createRule("Remove Unary Plus",
-        (node) => node.operation === 'unaryPlus',
-        (node) => {
-            const newNode = node.argument.clone();
-            newNode.provenance.push(node.id);
-            return newNode;
-        },
-        (originalNode, ruleData, newNode) => {
-            const childStr = utils.nodeToString(originalNode.argument);
-            return `Removed unary plus from "${childStr}"`;
-        }
-    )
-];
+import { SimplificationEngine } from '../omdSimplificationEngine.js';
+import * as utils from '../simplificationUtils.js';
+
+// ===== UNARY EXPRESSION RULES =====
+export const unaryRules = [
+    // Simplify double negation (-(-x) → x)
+    SimplificationEngine.createRule("Simplify Double Negation",
+        (node) => {
+            return node.operation === 'unaryMinus' && 
+                   SimplificationEngine.isType(node.argument, 'omdUnaryExpressionNode') &&
+                   node.argument.operation === 'unaryMinus';
+        },
+        (node) => {
+            const newNode = node.argument.argument.clone();
+            newNode.provenance.push(node.id, node.argument.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const childStr = utils.nodeToString(originalNode.argument.argument);
+            return `Simplified double negation: -(-${childStr}) = ${childStr}`;
+        }
+    ),
+
+    // Remove unary plus (+x → x)
+    SimplificationEngine.createRule("Remove Unary Plus",
+        (node) => node.operation === 'unaryPlus',
+        (node) => {
+            const newNode = node.argument.clone();
+            newNode.provenance.push(node.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const childStr = utils.nodeToString(originalNode.argument);
+            return `Removed unary plus from "${childStr}"`;
+        }
+    )
+];

package/omd/simplification/simplificationRules.js

@@ -1,32 +1,32 @@
-// Import rules progressively to identify the problematic one
-import { unaryRules } from './rules/unaryRules.js';
-import { parenthesisRules } from './rules/parenthesisRules.js';
-import { sqrtRules } from './rules/sqrtRules.js';
-import { powerRules } from './rules/powerRules.js';
-import { functionRules } from './rules/functionRules.js';
-import { rationalRules } from './rules/rationalRules.js';
-import { binaryRules } from './rules/binaryRules.js';
-
-export const rules = {
-    binary: binaryRules,
-    rational: rationalRules,
-    parenthesis: parenthesisRules,
-    unary: unaryRules,
-    power: powerRules,
-    sqrt: sqrtRules,
-    function: functionRules
-};
-
-export const ruleMap = {
-    'omdBinaryExpressionNode': rules.binary,
-    'omdRationalNode': rules.rational,
-    'omdParenthesisNode': rules.parenthesis,
-    'omdUnaryExpressionNode': rules.unary,
-    'omdPowerNode': rules.power,
-    'omdSqrtNode': rules.sqrt,
-    'omdFunctionNode': rules.function
-};
-
-export function getRulesForNode(node) {
-    return ruleMap[node.type] || [];
+// Import rules progressively to identify the problematic one
+import { unaryRules } from './rules/unaryRules.js';
+import { parenthesisRules } from './rules/parenthesisRules.js';
+import { sqrtRules } from './rules/sqrtRules.js';
+import { powerRules } from './rules/powerRules.js';
+import { functionRules } from './rules/functionRules.js';
+import { rationalRules } from './rules/rationalRules.js';
+import { binaryRules } from './rules/binaryRules.js';
+
+export const rules = {
+    binary: binaryRules,
+    rational: rationalRules,
+    parenthesis: parenthesisRules,
+    unary: unaryRules,
+    power: powerRules,
+    sqrt: sqrtRules,
+    function: functionRules
+};
+
+export const ruleMap = {
+    'omdBinaryExpressionNode': rules.binary,
+    'omdRationalNode': rules.rational,
+    'omdParenthesisNode': rules.parenthesis,
+    'omdUnaryExpressionNode': rules.unary,
+    'omdPowerNode': rules.power,
+    'omdSqrtNode': rules.sqrt,
+    'omdFunctionNode': rules.function
+};
+
+export function getRulesForNode(node) {
+    return ruleMap[node.type] || [];
 }