@teachinglab/omd 0.1.0

package/omd/nodes/omdUnaryExpressionNode.js

@@ -0,0 +1,178 @@
+import { omdNode } from "./omdNode.js";
+import { getNodeForAST } from "../core/omdUtilities.js";
+import { omdOperatorNode } from "./omdOperatorNode.js";
+import { omdConstantNode } from "./omdConstantNode.js";
+import { omdBinaryExpressionNode } from "./omdBinaryExpressionNode.js";
+import { simplifyStep } from "../simplification/omdSimplification.js";
+
+/**
+ * Represents a unary expression, like negation (-(x+y)).
+ * @extends omdNode
+ */
+export class omdUnaryExpressionNode extends omdNode {
+    /**
+     * @param {Object} ast - The AST node from math.js.
+     */
+    constructor(ast) {
+        super(ast);
+        this.type = "omdUnaryExpressionNode";
+        if (!ast.args || ast.args.length !== 1) {
+            console.error("omdUnaryExpressionNode requires an AST node with exactly 1 argument", ast);
+            return;
+        }
+
+        this.op = this.createOperatorNode(ast);
+        this.operand = this.createExpressionNode(ast.args[0]);
+        
+        // Set the operation property for compatibility with SimplificationEngine
+        this.operation = ast.fn || ast.op;
+
+        // Populate the argumentNodeList for mathematical child nodes
+        this.argumentNodeList.operand = this.operand;
+
+        this.addChild(this.op);
+        this.addChild(this.operand);
+    }
+
+    createOperatorNode(ast) {
+        const opNode = new omdOperatorNode({ op: ast.op, fn: ast.fn });
+        opNode.parent = this;
+        return opNode;
+    }
+    
+    createExpressionNode(ast) {
+        const NodeClass = getNodeForAST(ast);
+        const node = new NodeClass(ast);
+        node.parent = this;
+        return node;
+    }
+
+    computeDimensions() {
+        this.op.computeDimensions();
+        this.operand.computeDimensions();
+
+        const opWidth = this.op.width;
+        // No extra spacing for unary minus.
+        const argWidth = this.operand.width;
+        
+        const totalWidth = opWidth + argWidth;
+        const totalHeight = Math.max(this.op.height, this.operand.height);
+
+        this.setWidthAndHeight(totalWidth, totalHeight);
+    }
+
+    updateLayout() {
+        this.op.updateLayout();
+        this.operand.updateLayout();
+        
+        const opY = (this.height - this.op.height) / 2;
+        const argY = (this.height - this.operand.height) / 2;
+
+        this.op.setPosition(0, opY);
+        this.operand.setPosition(this.op.width, argY);
+    }
+
+    clone() {
+        // Create a new node. The constructor will add a backRect and temporary children.
+        const tempAst = { type: 'OperatorNode', op: '-', args: [{type: 'ConstantNode', value: 1}] };
+        const clone = new omdUnaryExpressionNode(tempAst);
+
+        // Keep the backRect, but get rid of the temporary children.
+        const backRect = clone.backRect;
+        clone.removeAllChildren();
+        clone.addChild(backRect);
+        
+        // Manually clone the real children to ensure the entire tree has correct provenance.
+        clone.op = this.op.clone();
+        clone.addChild(clone.op);
+
+        clone.operand = this.operand.clone();
+        clone.addChild(clone.operand);
+        
+        // Rebuild the argument list and copy AST data.
+        clone.argumentNodeList = { operand: clone.operand };
+        clone.astNodeData = JSON.parse(JSON.stringify(this.astNodeData));
+
+        // The crucial step: link the clone to its origin.
+        clone.provenance.push(this.id);
+
+        return clone;
+    }
+
+    /**
+     * Converts the omdUnaryExpressionNode to a math.js AST node.
+     * @returns {Object} A math.js-compatible AST node.
+     */
+    toMathJSNode() {
+        const astNode = {
+            type: 'OperatorNode',
+            op: this.op.opName,
+            fn: this.operation,
+            args: [this.operand.toMathJSNode()],
+            id: this.id,
+            provenance: this.provenance
+        };
+
+        // Add a clone method to maintain compatibility with math.js's expectations.
+        astNode.clone = function() {
+            const clonedNode = { ...this };
+            clonedNode.args = this.args.map(arg => arg.clone());
+            return clonedNode;
+        };
+        return astNode;
+    }
+
+    /**
+     * Converts the unary expression node to a string.
+     * @returns {string} The string representation of the expression.
+     */
+    toString() {
+        const operandStr = this.operand.toString();
+        if (this.needsParentheses()) {
+            return `${this.op.opName}(${operandStr})`;
+        }
+        return `${this.op.opName}${operandStr}`;
+    }
+
+    /**
+     * Check if the operand needs parentheses.
+     * @returns {boolean} Whether parentheses are required
+     */
+    needsParentheses() {
+        // Parentheses are needed if the operand is a binary expression.
+        return this.operand.type === 'omdBinaryExpressionNode';
+    }
+
+    /**
+     * Evaluate the negation.
+     * @param {Object} variables - Variable name to value mapping
+     * @returns {number} The negated result
+     */
+    evaluate(variables = {}) {
+        if (!this.operand.evaluate) return NaN;
+        const value = this.operand.evaluate(variables);
+        if (this.op.opName === '-') {
+            return -value;
+        }
+        return value; // For other potential unary ops like '+'
+    }
+
+    /**
+     * Create a negation node from a string.
+     * @static
+     * @param {string} expressionString - Expression with negation
+     * @returns {omdUnaryExpressionNode}
+     */
+    static fromString(expressionString) {
+        try {
+            const ast = window.math.parse(expressionString);
+            if (ast.type === 'OperatorNode' && ast.fn === 'unaryMinus') {
+                return new omdUnaryExpressionNode(ast);
+            }
+            throw new Error("Expression is not a unary minus operation.");
+        } catch (error) {
+            console.error("Failed to create unary expression node from string:", error);
+            throw error;
+        }
+    }
+}

package/omd/nodes/omdVariableNode.js

@@ -0,0 +1,123 @@
+import { omdLeafNode } from "./omdLeafNode.js";
+import { omdColor } from "../../src/omdColor.js";
+import { jsvgTextLine } from '@teachinglab/jsvg';
+/**
+ * Leaf node that represents a variable.
+ * @extends omdLeafNode
+ */
+export class omdVariableNode extends omdLeafNode {
+    /**
+     * Creates a leaf node from the AST data.
+     * @param {Object} astNodeData - The AST node containing leaf information.
+     */
+    constructor(nodeData) {
+        super(nodeData);
+        this.type = "omdVariableNode";
+
+        this.name = this.parseName(nodeData);
+        
+        this.textElement = super.createTextElement(this.name);
+    }
+
+    parseName(nodeData) {
+        if (typeof nodeData === "string")
+            return nodeData;
+
+        return nodeData.name;
+    }
+
+    parseType() {
+        return "variable";
+    }
+
+    /**
+     * Calculates the dimensions of the node.
+     * Adds padding around the node.
+     * @override
+     */
+    computeDimensions() {
+        super.computeDimensions();
+
+        const ratio = this.getFontSize() / this.getRootFontSize();
+        const padding = 4 * ratio;
+        let paddedWidth = this.width + padding;
+        let paddedHeight = this.height + padding;
+        this.setWidthAndHeight(paddedWidth, paddedHeight);
+    }
+
+    /**
+     * Updates the layout of the node.
+     * @override
+     */
+    updateLayout() {
+        super.updateLayout();
+    }
+
+    /**
+     * Converts the omdVariableNode to a math.js AST node.
+     * @returns {Object} A math.js-compatible AST node.
+     */
+    toMathJSNode() {
+        const astNode = { 
+            type: 'SymbolNode', 
+            name: this.name,
+            id: this.id,
+            provenance: this.provenance
+        };
+        astNode.clone = function() {
+            return { ...this };
+        };
+        return astNode;
+    }
+
+    highlight(color) {
+        super.highlight(color);
+        if (this.textElement) {
+            this.textElement.setFillColor(omdColor.white);
+        }
+    }
+
+    clearProvenanceHighlights() {
+        super.clearProvenanceHighlights();
+        if (this.textElement) {
+            this.textElement.setFillColor(omdColor.text);
+        }
+    }
+
+    /**
+     * Converts the variable node to a string.
+     * @returns {string} The name of the variable.
+     */
+    toString() {
+        return this.name;
+    }
+
+    /**
+     * Evaluates the variable by looking up its value in a map.
+     * @param {Object} variables - A map of variable names to their numeric values.
+     * @returns {number} The value of the variable.
+     */
+    evaluate(variables = {}) {
+        if (Object.prototype.hasOwnProperty.call(variables, this.name)) {
+            return variables[this.name];
+        }
+        throw new Error(`Variable '${this.name}' is not defined.`);
+    }
+    
+    /**
+    
+    /**
+     * Create a variable node from a name.
+     * @param {string} name - The variable name
+     * @returns {omdVariableNode}
+     * @static
+     */
+    static fromName(name) {
+        // Create a minimal AST-like object for the constructor
+        const astNodeData = {
+            type: 'SymbolNode',
+            name: name
+        };
+        return new omdVariableNode(astNodeData);
+    }
+}

package/omd/simplification/omdSimplification.js

@@ -0,0 +1,171 @@
+import { getRulesForNode } from './simplificationRules.js';
+import { setSimplifyStep } from '../nodes/omdNode.js';
+
+/**
+ * Finds all simplification opportunities within an expression tree.
+ * Now much faster - only checks relevant rules for each node type!
+ * @param {omdNode} rootNode - The root of the expression tree to search.
+ * @returns {Array<Object>} Array of simplification opportunities.
+ */
+export function findSimplificationOpportunities(rootNode) {
+    const opportunities = [];
+    const visitedNodes = new Set();
+
+    function traverse(node) {
+        if (!node || visitedNodes.has(node)) return;
+        visitedNodes.add(node);
+
+
+        if (node.type === 'omdEquationNode') {
+
+        }
+
+        // Traverse children first (depth-first)
+        if (node.childList && node.childList.length > 0) {
+
+            for (const child of node.childList) {
+                traverse(child);
+            }
+        }
+
+        // Only check rules that apply to this node type
+        const relevantRules = getRulesForNode(node);
+
+        
+        for (const rule of relevantRules) {
+            const ruleData = rule.canApply(node);
+            if (ruleData) {
+
+                opportunities.push({ node, rule, ruleData });
+                break; // Only apply the first matching rule
+            }
+        }
+    }
+
+    traverse(rootNode);
+    console.log(`📊 Total opportunities found: ${opportunities.length}`);
+    return opportunities;
+}
+
+export function simplifyStep(rootNode) {
+    console.log(`🚀 simplifyStep called for root node:`, {
+        nodeType: rootNode.type,
+        constructorName: rootNode.type,
+        nodeId: rootNode.id
+    });
+
+    let foldedCount = 0;
+    let newRoot = rootNode;
+    let historyEntry = null;
+
+    // Find all simplification opportunities
+    const opportunities = findSimplificationOpportunities(rootNode);
+    console.log(`📊 Found ${opportunities.length} simplification opportunities`);
+
+    if (opportunities.length > 0) {
+        // Apply the first opportunity
+        const opportunity = opportunities[0];
+        console.log(`🔧 Applying simplification rule:`, opportunity.rule.name);
+        
+        try {
+            const result = opportunity.rule.apply(opportunity.node, opportunity.ruleData, rootNode);
+            console.log(`✅ Rule "${opportunity.rule.name}" applied successfully:`, result);
+            
+            if (result && result.success && result.newRoot) {
+                newRoot = result.newRoot;
+                foldedCount = 1;
+                historyEntry = result.historyEntry || {
+                    name: opportunity.rule.name,
+                    affectedNodes: [rootNode.id],
+                    message: `Applied ${opportunity.rule.name}`
+                };
+                console.log(`✅ Simplification successful! New root:`, {
+                    nodeType: newRoot.type,
+                    nodeId: newRoot.id
+                });
+            } else {
+                console.log(`❌ Rule "${opportunity.rule.name}" returned no result`);
+            }
+        } catch (error) {
+            console.error(`❌ Error applying rule "${opportunity.rule.name}":`, error);
+        }
+    } else {
+        console.log(`❌ No simplification opportunities found`);
+    }
+
+    console.log(`📊 simplifyStep result:`, {
+        foldedCount,
+        hasNewRoot: newRoot !== rootNode,
+        newRootType: newRoot.type,
+        newRootId: newRoot.id
+    });
+
+    return { newRoot, foldedCount, historyEntry };
+}
+
+/**
+ * Simplifies an entire mathematical expression tree by repeatedly applying rules.
+ * @param {omdNode} rootNode - The root node of the expression to simplify.
+ * @returns {{foldedCount: number, newRoot: omdNode}}
+ */
+export function simplifyExpression(rootNode) {
+    let totalFolded = 0;
+    let currentRoot = rootNode;
+    let iterations = 0;
+    const maxIterations = 50; // Prevent infinite loops
+
+    while (iterations < maxIterations) {
+        const { foldedCount, newRoot } = simplifyStep(currentRoot);
+
+        if (foldedCount === 0) {
+            break; // No more simplifications possible
+        }
+
+        currentRoot = newRoot;
+        totalFolded += foldedCount;
+        iterations++;
+    }
+
+    // Return a fresh clone if any simplifications occurred
+    if (totalFolded > 0) {
+        const cleanRoot = currentRoot.clone();
+        cleanRoot.setFontSize(rootNode.getFontSize());
+        return { foldedCount: totalFolded, newRoot: cleanRoot };
+    }
+
+    return { foldedCount: totalFolded, newRoot: currentRoot };
+}
+
+/**
+ * Debug function to show which rules are available for a node
+ * @param {omdNode} node - The node to check
+ * @returns {Array<string>} Array of rule names
+ */
+export function getAvailableRulesForNode(node) {
+    const rules = getRulesForNode(node);
+    return rules.map(rule => rule.name);
+}
+
+/**
+ * Debug function to show which rules can be applied to a node
+ * @param {omdNode} node - The node to check  
+ * @returns {Array<string>} Array of applicable rule names
+ */
+export function getApplicableRulesForNode(node) {
+    const rules = getRulesForNode(node);
+    const applicable = [];
+    
+    for (const rule of rules) {
+        try {
+            const ruleData = rule.canApply(node);
+            if (ruleData) {
+                applicable.push(rule.name);
+            }
+        } catch (error) {
+        }
+    }
+    
+    return applicable;
+}
+
+setSimplifyStep(simplifyStep);