@teachinglab/omd 0.2.0 → 0.2.1

package/omd/nodes/omdUnaryExpressionNode.js

@@ -28,7 +28,10 @@ export class omdUnaryExpressionNode extends omdNode {
         this.operation = ast.fn || ast.op;
 
         // Populate the argumentNodeList for mathematical child nodes
+        this.operand = this.operand;
+        this.argument = this.operand;
         this.argumentNodeList.operand = this.operand;
+        this.argumentNodeList.argument = this.argument;
 
         this.addChild(this.op);
         this.addChild(this.operand);
@@ -83,14 +86,17 @@ export class omdUnaryExpressionNode extends omdNode {
         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.op = this.op.clone();
+    clone.addChild(clone.op);
 
-        clone.operand = this.operand.clone();
-        clone.addChild(clone.operand);
+    clone.operand = this.operand.clone();
+    clone.addChild(clone.operand);
         
-        // Rebuild the argument list and copy AST data.
-        clone.argumentNodeList = { operand: clone.operand };
+    // Ensure `argument` alias exists on the clone for compatibility
+    clone.argument = clone.operand;
+        
+    // Rebuild the argument list and copy AST data.
+    clone.argumentNodeList = { operand: clone.operand, argument: clone.argument };
         clone.astNodeData = JSON.parse(JSON.stringify(this.astNodeData));
 
         // The crucial step: link the clone to its origin.
@@ -99,6 +105,50 @@ export class omdUnaryExpressionNode extends omdNode {
         return clone;
     }
 
+    /**
+     * A unary expression is constant if its operand is constant.
+     * @returns {boolean}
+     */
+    isConstant() {
+        return !!(this.operand && typeof this.operand.isConstant === 'function' && this.operand.isConstant());
+    }
+
+    /**
+     * Get numeric value for unary expression (handles unary minus)
+     * @returns {number}
+     */
+    getValue() {
+        if (!this.isConstant()) throw new Error('Node is not a constant expression');
+        const val = this.operand.getValue();
+        if (this.operation === 'unaryMinus' || (this.op && this.op.opName === '-')) {
+            return -val;
+        }
+        return val;
+    }
+
+    /**
+     * If the operand represents a rational constant, return its rational pair adjusted for sign.
+     */
+    getRationalValue() {
+        if (!this.isConstant()) throw new Error('Node is not a constant expression');
+
+        // If operand supports getRationalValue, use it and adjust sign
+        if (typeof this.operand.getRationalValue === 'function') {
+            const { num, den } = this.operand.getRationalValue();
+            if (this.operation === 'unaryMinus' || (this.op && this.op.opName === '-')) {
+                return { num: -num, den };
+            }
+            return { num, den };
+        }
+
+        // Fallback: treat operand as integer rational
+        const raw = this.operand.getValue();
+        if (this.operation === 'unaryMinus' || (this.op && this.op.opName === '-')) {
+            return { num: -raw, den: 1 };
+        }
+        return { num: raw, den: 1 };
+    }
+
     /**
      * Converts the omdUnaryExpressionNode to a math.js AST node.
      * @returns {Object} A math.js-compatible AST node.

package/omd/simplification/omdSimplificationEngine.js

@@ -189,7 +189,8 @@ export class SimplificationEngine {
      * @returns {boolean} True if the node matches the type, false otherwise.
      */
     static isType(node, typeName) {
-        return node.type === typeName;
+    if (!node) return false;
+    return node.type === typeName;
     }
 
     /**
@@ -495,7 +496,8 @@ export class SimplificationEngine {
     static getNodeClass(className) {
         const classMap = {
             'omdVariableNode': omdVariableNode,
-            'omdPowerNode': omdPowerNode
+            'omdPowerNode': omdPowerNode,
+            'omdUnaryExpressionNode': omdUnaryExpressionNode
         };
         return classMap[className];
     }
@@ -528,7 +530,7 @@ export class SimplificationEngine {
          */
         canApply(node) {
             const result = this.match(node);
-            return result === false || result === null || result === undefined ? null : 
+            return result === false || result === null || result === undefined ? null :
                    result === true ? {} : result; // Normalize match results
         }
         

package/omd/simplification/rules/rationalRules.js

@@ -1,8 +1,115 @@
 import { SimplificationEngine } from '../omdSimplificationEngine.js';
 import * as utils from '../simplificationUtils.js';
+import { omdRationalNode } from '../../nodes/omdRationalNode.js';
 
 // ===== RATIONAL NODE RULES =====
 export const rationalRules = [
+    // Simplify when both numerator and denominator are unary negatives: (-a)/(-b) -> a/b
+    SimplificationEngine.createRule("Unary Minus Cancellation",
+        (node) => {
+            if (node.type !== 'omdRationalNode') return false;
+
+            const num = SimplificationEngine.unwrapParentheses(node.numerator);
+            const den = SimplificationEngine.unwrapParentheses(node.denominator);
+
+            if (SimplificationEngine.isType(num, 'omdUnaryExpressionNode') &&
+                SimplificationEngine.isType(den, 'omdUnaryExpressionNode')) {
+                // Both sides are unary; cancel the unary minus operators
+                return {
+                    numeratorArg: num.argument || num.operand,
+                    denominatorArg: den.argument || den.operand,
+                    numeratorNode: num,
+                    denominatorNode: den
+                };
+            }
+
+            return false;
+        },
+        (node, data) => {
+            // Create a new rational node with arguments unwrapped
+            const fontSize = node.getFontSize();
+            const numArg = data.numeratorArg;
+            const denArg = data.denominatorArg;
+
+            // If the denominator argument is a constant 1, return the numerator directly (e.g., x/1 -> x)
+            if (denArg && typeof denArg.isConstant === 'function' && denArg.isConstant() && denArg.getValue() === 1) {
+                const result = numArg.clone();
+                // Preserve provenance from original nodes and the rational node
+                try { utils.applyProvenance(result, node.numerator, node.denominator, node); } catch (e) {
+                    // Fallback to manual pushes if applyProvenance fails
+                    result.provenance = result.provenance || [];
+                    if (data.numeratorNode) result.provenance.push(data.numeratorNode.id);
+                    if (data.denominatorNode) result.provenance.push(data.denominatorNode.id);
+                    result.provenance.push(node.id);
+                }
+                return result;
+            }
+
+            const newNum = numArg.clone();
+            const newDen = denArg.clone();
+
+            const ast = {
+                type: 'OperatorNode', op: '/', fn: 'divide',
+                args: [newNum.toMathJSNode(), newDen.toMathJSNode()],
+                clone: function() { return { ...this, args: this.args.map(a => a.clone()) }; }
+            };
+
+            const rational = new omdRationalNode(ast);
+            rational.setFontSize(fontSize);
+            rational.initialize();
+
+            // Give granular provenance to numerator and denominator children
+            try {
+                // Attach provenance to the child numerator and denominator specifically
+                if (rational.numerator) utils.applyProvenance(rational.numerator, node.numerator);
+                if (rational.denominator) utils.applyProvenance(rational.denominator, node.denominator);
+                // Also attach provenance to the rational node itself
+                utils.applyProvenance(rational, node.numerator, node.denominator, node);
+            } catch (e) {
+                _preserveComponentProvenance(rational, data.numeratorNode.argument || data.numeratorNode.operand, data.denominatorNode.argument || data.denominatorNode.operand);
+                if (!rational.provenance.includes(node.id)) rational.provenance.push(node.id);
+            }
+
+            return rational;
+        },
+        (originalNode, ruleData, newNode) => {
+            return `Canceled unary negatives in fraction`;
+        },
+        'rational'
+    ),
+
+    // Simplify when numerator is unary minus and denominator is constant -1: (-x)/-1 -> x
+    SimplificationEngine.createRule("Unary Numerator Divide By -1",
+        (node) => {
+            if (node.type !== 'omdRationalNode') return false;
+            const num = SimplificationEngine.unwrapParentheses(node.numerator);
+            const den = SimplificationEngine.unwrapParentheses(node.denominator);
+
+            if (SimplificationEngine.isType(num, 'omdUnaryExpressionNode') && den.isConstant && den.isConstant() && den.getValue() === -1) {
+                return { numeratorArg: num.argument || num.operand, numeratorNode: num, denominatorNode: den };
+            }
+
+            return false;
+        },
+        (node, data) => {
+            const newNode = data.numeratorArg.clone();
+            // Preserve granular provenance: numerator argument's provenance and the denominator and whole node
+            try {
+                // If the result is a leaf (variable/constant), ensure it gets provenance from numerator/denominator
+                utils.applyProvenance(newNode, node.numerator, node.denominator, node);
+            } catch (e) {
+                newNode.provenance = newNode.provenance || [];
+                if (data.numeratorNode) newNode.provenance.push(data.numeratorNode.id);
+                if (data.denominatorNode) newNode.provenance.push(data.denominatorNode.id);
+                newNode.provenance.push(node.id);
+            }
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            return `Divided by -1 cancels unary minus in numerator`;
+        },
+        'rational'
+    ),
     // Simplify x/x = 1 (variable divided by itself)
     SimplificationEngine.createRule("Variable Self Division",
         (node) => {
@@ -282,6 +389,149 @@ export const rationalRules = [
         'rational'
     ),
 
+    // Cancel numeric coefficient when numerator is unary-negative monomial and denominator is negative constant
+    SimplificationEngine.createRule("Cancel Negative Coefficient",
+        (node) => {
+            if (node.type !== 'omdRationalNode') return false;
+
+            const numerator = SimplificationEngine.unwrapParentheses(node.numerator);
+            const denominator = SimplificationEngine.unwrapParentheses(node.denominator);
+
+            // We expect numerator to be unary minus wrapping a multiplication (e.g., -(2*x) )
+            if (!SimplificationEngine.isType(numerator, 'omdUnaryExpressionNode')) return false;
+            const inner = numerator.argument || numerator.operand;
+            if (!SimplificationEngine.isBinaryOp(inner, 'multiply')) return false;
+
+            // Find the constant operand inside the multiplication
+            const constOp = SimplificationEngine.hasConstantOperand(inner);
+            if (!constOp || !constOp.constant.isConstant()) return false;
+
+            // Denominator should be a constant and negative
+            if (!denominator.isConstant()) return false;
+            const denVal = denominator.getValue();
+            if (denVal >= 0) return false;
+
+            const coeffVal = constOp.constant.getValue();
+
+            // If absolute values match, we can cancel the coefficient
+            if (Math.abs(coeffVal) === Math.abs(denVal)) {
+                return {
+                    innerMultiplication: inner,
+                    otherFactor: constOp.other,
+                    numeratorUnary: numerator,
+                    denominatorNode: denominator
+                };
+            }
+
+            return false;
+        },
+        (node, data) => {
+            // Return the other factor (e.g., x) possibly adjusting sign if needed
+            const newNode = data.otherFactor.clone();
+            // Preserve granular provenance from the multiplication and the rational node
+            try { utils.applyProvenance(newNode, data.innerMultiplication || node.numerator, node.denominator, node); }
+            catch (e) {
+                newNode.provenance = newNode.provenance || [];
+                newNode.provenance.push(data.numeratorUnary.id);
+                newNode.provenance.push(data.denominatorNode.id);
+                newNode.provenance.push(node.id);
+            }
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            return `Canceled matching numeric factors between numerator and denominator`;
+        },
+        'rational'
+    ),
+
+    // Handle negative constant numerator over multiplication with negative constant in denominator: (-a)/(-b * rest) -> a/(b * rest)
+    SimplificationEngine.createRule("Negative Constant Over Negative Product",
+        (node) => {
+            if (node.type !== 'omdRationalNode') return false;
+
+            const numerator = SimplificationEngine.unwrapParentheses(node.numerator);
+            const denominator = SimplificationEngine.unwrapParentheses(node.denominator);
+
+            if (!numerator.isConstant || !numerator.isConstant()) return false;
+            const numVal = numerator.getValue();
+            if (numVal >= 0) return false;
+
+            // Denominator must be a multiplication with a constant operand that's negative
+            if (!SimplificationEngine.isBinaryOp(denominator, 'multiply')) return false;
+            const constOp = SimplificationEngine.hasConstantOperand(denominator);
+            if (!constOp || !constOp.constant.isConstant()) return false;
+            const denConstVal = constOp.constant.getValue();
+            if (denConstVal >= 0) return false;
+
+            return {
+                numeratorNode: numerator,
+                denominatorNode: denominator,
+                denominatorConst: constOp.constant,
+                denominatorOther: constOp.other
+            };
+        },
+        (node, data) => {
+            const fontSize = node.getFontSize();
+
+            // Build new numerator absolute value
+            const newNumConst = SimplificationEngine.createConstant(Math.abs(data.numeratorNode.getValue()), fontSize);
+
+            // Build new denominator as (abs(denConst) * other)
+            const newDenConst = SimplificationEngine.createConstant(Math.abs(data.denominatorConst.getValue()), fontSize);
+            const newDenProduct = SimplificationEngine.createBinaryOp(newDenConst, 'multiply', data.denominatorOther.clone(), fontSize);
+
+            // Construct rational AST
+            const ast = {
+                type: 'OperatorNode', op: '/', fn: 'divide',
+                args: [newNumConst.toMathJSNode(), newDenProduct.toMathJSNode()],
+                clone: function() { return { ...this, args: this.args.map(a => a.clone()) }; }
+            };
+
+            const rational = new omdRationalNode(ast);
+            rational.setFontSize(fontSize);
+            rational.initialize();
+
+            // Debug: show matching components and their provenance
+
+            // Preserve provenance from original components and whole node.
+            // Attach granular provenance to numerator and denominator children as well as the rational node.
+            try {
+                // Numerator: if original numerator was a unary expression, use its inner operand (the constant '1')
+                const numeratorSource = (data && data.numeratorNode && (data.numeratorNode.argument || data.numeratorNode.operand)) || node.numerator;
+                if (rational.numerator && numeratorSource) {
+                    utils.applyProvenance(rational.numerator, numeratorSource);
+                }
+
+                // Denominator: if original denominator was a multiplication, attach provenance to the left/right children
+                const denomSourceBinary = (data && data.denominatorNode) || node.denominator;
+                if (rational.denominator && SimplificationEngine.isBinaryOp(denomSourceBinary, 'multiply') && SimplificationEngine.isBinaryOp(rational.denominator, 'multiply')) {
+                    // Attempt to map original const -> left, other -> right
+                    const leftSource = (data && data.denominatorConst) || (denomSourceBinary.left || denomSourceBinary.right);
+                    const rightSource = (data && data.denominatorOther) || ((denomSourceBinary.left === leftSource) ? denomSourceBinary.right : denomSourceBinary.left);
+
+                    if (rational.denominator.left && leftSource) utils.applyProvenance(rational.denominator.left, leftSource);
+                    if (rational.denominator.right && rightSource) utils.applyProvenance(rational.denominator.right, rightSource);
+                } else if (rational.denominator) {
+                    // Fallback: attach provenance to the whole denominator
+                    utils.applyProvenance(rational.denominator, node.denominator);
+                }
+
+                // Finally, attach provenance to the rational node itself
+                utils.applyProvenance(rational, node.numerator, node.denominator, node);
+            } catch (e) {
+                // Fallback to copying provenance arrays/ids
+                _preserveComponentProvenance(rational, node.numerator, node.denominator);
+                if (!rational.provenance.includes(node.id)) rational.provenance.push(node.id);
+            }
+
+            // (debug logs removed)
+
+            return rational;
+        },
+        (originalNode, ruleData, newNode) => `Canceled matching negative factors: simplified sign and magnitude`,
+        'rational'
+    ),
+
     // Distribute division over addition/subtraction ((4*x+6)/3 → 4/3*x + 2)
     SimplificationEngine.createRule("Simplify Rational Division",
         (node) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teachinglab/omd",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "omd",
   "main": "./index.js",
   "module": "./index.js",
@@ -40,7 +40,7 @@
   },
   "scripts": {
     "start": "node --env-file=.env server.js",
-    "dev": "node --env-file=.env server.js"
+    "dev": "vite"
   },
   "publishConfig": {
     "access": "public"

package/src/omdCoordinatePlane.js

@@ -339,8 +339,8 @@ export class omdCoordinatePlane extends jsvgGroup {
 
         const compiledExpression = math.compile(expression);
 
-        const leftLimit = domain.min;
-        const rightLimit = domain.max;
+    const leftLimit = (domain && typeof domain.min === 'number') ? domain.min : this.xMin;
+    const rightLimit = (domain && typeof domain.max === 'number') ? domain.max : this.xMax;
 
         const step = Math.abs(rightLimit - leftLimit) / 1000;
         for (let x = leftLimit; x <= rightLimit; x += step) {