Implemented Operable::complexity(); now the determination of whether an expression is simplified is based on its complexity, not the number of nodes. This fixes the issue where x*a*x is not simplified to x^2*a

Author: JiachenRen

src/jmc/cas/BinaryOperation.java

@@ -602,9 +602,9 @@ private void crossSimplify(ArrayList<Operable> pool) {
                 Operable other = pool.get(k);
                 String operation = getPriority() == 2 ? "*" : "+";
                 BinaryOperation binOp = new BinaryOperation(operable, operation, other);
-                int n1 = binOp.numNodes();
+                int n1 = binOp.complexity();
                 Operable op = binOp.simplify(); //be careful, avoid stack overflow
-                if (op.numNodes() < n1) { //simplifiable
+                if (op.complexity() < n1) { //simplifiable
                     pool.remove(i);
                     pool.remove(k - 1);
                     pool.add(op);
@@ -899,6 +899,10 @@ public int levelOf(Operable o) {
         return left > right ? right + 1 : left + 1;
     }
 
+    public int complexity() {
+        return getLeftHand().complexity() + getRightHand().complexity() + 1;
+    }
+
     public Operable replace(Operable o, Operable r) {
         if (this.equals(o)) return r;
         BinaryOperation clone = this.copy();

src/jmc/cas/Constants.java

@@ -79,6 +79,10 @@ public String toString() {
             return getName();
         }
 
+        public int complexity() {
+            return 2;
+        }
+
         public double eval(double x) {
             return computedConst.compute();
         }
@@ -95,7 +99,7 @@ public Constant copy() {
 
         public boolean equals(Operable other) {
             return other instanceof Constant && (((Constant) other).getName().equals(getName())
-            || other.val() == this.val());
+                    || other.val() == this.val());
         }
 
         public Operable plugIn(Variable var, Operable nested) {
@@ -117,6 +121,6 @@ public static Constant getConstant(String name) {
             if (constant.getName().equals(name))
                 return constant;
         }
-        throw new JMCException("constant + \""+name+"\" does not exist");
+        throw new JMCException("constant + \"" + name + "\" does not exist");
     }
 }

src/jmc/cas/LeafNode.java

@@ -21,6 +21,8 @@ public int numNodes() {
         return 1;
     }
 
+    public abstract int complexity();
+
     public Operable beautify() {
         return this;
     }

src/jmc/cas/Operable.java

@@ -38,6 +38,12 @@ public interface Operable extends Evaluable {
      */
     int levelOf(Operable o);
 
+    /**
+     * @return level of complexity of the expression represented by an integer with 1 being
+     * the most simplistic
+     */
+    int complexity();
+
     /**
      * plugs in the operable nested for all variables in the expression
      * NOTE: the method returns the operable with the desired nested operable plugged in, but

src/jmc/cas/RawValue.java

@@ -114,6 +114,10 @@ public boolean isPositive() {
         return doubleValue() > 0;
     }
 
+    public int complexity() {
+        return 1;
+    }
+
     /**
      * Since plugIn only applies to variable, a RawValue type should only return itself.
      *

src/jmc/cas/UnaryOperation.java

@@ -42,6 +42,10 @@ public double eval(double x) {
         return operation.eval(getLeftHand().eval(x));
     }
 
+    public int complexity() {
+        return getLeftHand().complexity() + 1;
+    }
+
 
     public static void define(String name, String expression) {
         UnaryOperation.define(name, Expression.interpret(expression));

src/jmc/cas/Variable.java

@@ -28,6 +28,10 @@ public String toString() {
         return name;
     }
 
+    public int complexity() {
+        return 3;
+    }
+
     public Operable simplify() {
         return this;
     }

src/tests/BinaryOperationTest.java

@@ -11,18 +11,18 @@
  */
 public class BinaryOperationTest {
     public static void main(String args[]) {
-//        BinaryOperation binOp = new BinaryOperation(RawValue.ZERO, "*", RawValue.ONE);
-//        l(binOp.getRightHand(), binOp.getLeftHand());
-//        binOp.setRightHand(RawValue.ONE);
-//        BinaryOperation.define("&", 3, (a, b) -> a + b);
-//        l(BinaryOperation.binaryOperations(), BinaryOperation.binaryOperations(3));
-//        l(BinaryOperation.getPriority("&"), BinaryOperation.getPriority("+"));
-//        l(new BinaryOperation(RawValue.ZERO, "*", RawValue.ONE).getPriority());
-//        l(new BinaryOperation(RawValue.ZERO, "*", RawValue.ONE).flattened());
-//        l(binOp.is("*"));
-//        l(Operation.mult(3, 5));
-//        l(Operation.exp(Math.random(), new RawValue(3)));
-//        l(Operation.exp(new RawValue(3), Math.random()));
+        BinaryOperation binOp = new BinaryOperation(RawValue.ZERO, "*", RawValue.ONE);
+        l(binOp.getRightHand(), binOp.getLeftHand());
+        binOp.setRightHand(RawValue.ONE);
+        BinaryOperation.define("&", 3, (a, b) -> a + b);
+        l(BinaryOperation.binaryOperations(), BinaryOperation.binaryOperations(3));
+        l(BinaryOperation.getPriority("&"), BinaryOperation.getPriority("+"));
+        l(new BinaryOperation(RawValue.ZERO, "*", RawValue.ONE).getPriority());
+        l(new BinaryOperation(RawValue.ZERO, "*", RawValue.ONE).flattened());
+        l(binOp.is("*"));
+        l(Operation.mult(3, 5));
+        l(Operation.exp(Math.random(), new RawValue(3)));
+        l(Operation.exp(new RawValue(3), Math.random()));
         l(Expression.interpret("x+x*a").simplify());
     }