Merge branch 'unary'

src/org/nwapw/abacus/function/Operator.java

@@ -9,6 +9,10 @@ public class Operator {
      * The associativity of the operator.
      */
     private OperatorAssociativity associativity;
+    /**
+     * The type of this operator.
+     */
+    private OperatorType type;
     /**
      * The precedence of the operator.
      */
@@ -24,8 +28,9 @@ public class Operator {
      * @param precedence the precedence of the operator.
      * @param function the function that the operator calls.
      */
-    public Operator(OperatorAssociativity associativity, int precedence, Function function){
+    public Operator(OperatorAssociativity associativity, OperatorType operatorType, int precedence, Function function){
         this.associativity = associativity;
+        this.type = operatorType;
         this.precedence = precedence;
         this.function = function;
     }
@@ -38,6 +43,14 @@ public class Operator {
         return associativity;
     }
 
+    /**
+     * Gets the operator's type.
+     * @return the type.
+     */
+    public OperatorType getType() {
+        return type;
+    }
+
     /**
      * Gets the operator's precedence.
      * @return the precedence.

src/org/nwapw/abacus/function/OperatorType.java

@@ -0,0 +1,8 @@
+package org.nwapw.abacus.function;
+
+/**
+ * The type of an operator, describing how it should behave.
+ */
+public enum OperatorType {
+    BINARY_INFIX, UNARY_POSTFIX
+}

src/org/nwapw/abacus/plugin/StandardPlugin.java

@@ -3,6 +3,7 @@ package org.nwapw.abacus.plugin;
 import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 
@@ -20,7 +21,7 @@ public class StandardPlugin extends Plugin {
 
     @Override
     public void onEnable() {
-        registerOperator("+", new Operator(OperatorAssociativity.LEFT, 0, new Function() {
+        registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length >= 1;
@@ -36,7 +37,7 @@ public class StandardPlugin extends Plugin {
             }
         }));
 
-        registerOperator("-", new Operator(OperatorAssociativity.LEFT, 0, new Function() {
+        registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 2;
@@ -48,7 +49,7 @@ public class StandardPlugin extends Plugin {
             }
         }));
 
-        registerOperator("*", new Operator(OperatorAssociativity.LEFT, 1, new Function() {
+        registerOperator("*", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length >= 1;
@@ -64,7 +65,7 @@ public class StandardPlugin extends Plugin {
             }
         }));
 
-        registerOperator("/", new Operator(OperatorAssociativity.LEFT, 1, new Function() {
+        registerOperator("/", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 2;
@@ -76,7 +77,7 @@ public class StandardPlugin extends Plugin {
             }
         }));
 
-        registerOperator("^", new Operator(OperatorAssociativity.RIGHT, 2, new Function() {
+        registerOperator("^", new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 2;
@@ -88,7 +89,7 @@ public class StandardPlugin extends Plugin {
             }
         }));
 
-        registerFunction("!", new Function() {
+        registerOperator("!", new Operator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0, new Function() {
             //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
@@ -113,7 +114,7 @@ public class StandardPlugin extends Plugin {
                     storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
                 }*/
             }
-        });
+        }));
 
         registerFunction("abs", new Function() {
             @Override
@@ -245,7 +246,7 @@ public class StandardPlugin extends Plugin {
      * @return the nth term of the series.
      */
     private NumberInterface getExpSeriesTerm(int n, NumberInterface x){
-        return x.intPow(n).divide(this.getFunction("!").apply((new NaiveNumber(n)).promoteTo(x.getClass())));
+        return x.intPow(n).divide(this.getOperator("!").getFunction().apply((new NaiveNumber(n)).promoteTo(x.getClass())));
     }
 
     /**

src/org/nwapw/abacus/tree/BinaryInfixNode.java

@@ -3,7 +3,7 @@ package org.nwapw.abacus.tree;
 /**
  * A tree node that represents an operation being applied to two operands.
  */
-public class OpNode extends TreeNode {
+public class BinaryInfixNode extends TreeNode {
 
     /**
      * The operation being applied.
@@ -18,14 +18,14 @@ public class OpNode extends TreeNode {
      */
     private TreeNode right;
 
-    private OpNode() {}
+    private BinaryInfixNode() {}
 
     /**
      * Creates a new operation node with the given operation
      * and no child nodes.
      * @param operation the operation.
      */
-    public OpNode(String operation){
+    public BinaryInfixNode(String operation){
         this(operation, null, null);
     }
 
@@ -36,7 +36,7 @@ public class OpNode extends TreeNode {
      * @param left the left node of the expression.
      * @param right the right node of the expression.
      */
-    public OpNode(String operation, TreeNode left, TreeNode right){
+    public BinaryInfixNode(String operation, TreeNode left, TreeNode right){
         this.operation = operation;
         this.left = left;
         this.right = right;

src/org/nwapw/abacus/tree/NumberReducer.java

@@ -27,12 +27,17 @@ public class NumberReducer implements Reducer<NumberInterface> {
     public NumberInterface reduceNode(TreeNode node, Object... children) {
         if(node instanceof NumberNode) {
             return ((NumberNode) node).getNumber();
-        } else if(node instanceof OpNode){
+        } else if(node instanceof BinaryInfixNode){
             NumberInterface left = (NumberInterface) children[0];
             NumberInterface right = (NumberInterface) children[1];
-            Function function = manager.operatorFor(((OpNode) node).getOperation()).getFunction();
+            Function function = manager.operatorFor(((BinaryInfixNode) node).getOperation()).getFunction();
             if(function == null) return null;
             return function.apply(left, right);
+        } else if(node instanceof UnaryPrefixNode) {
+            NumberInterface child = (NumberInterface) children[0];
+            Function functionn = manager.operatorFor(((UnaryPrefixNode) node).getOperation()).getFunction();
+            if(functionn == null) return null;
+            return functionn.apply(child);
         } else if(node instanceof FunctionNode){
             NumberInterface[] convertedChildren = new NumberInterface[children.length];
             for(int i = 0; i < convertedChildren.length; i++){

src/org/nwapw/abacus/tree/TreeBuilder.java

@@ -1,6 +1,7 @@
 package org.nwapw.abacus.tree;
 
 import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
 import org.nwapw.abacus.lexing.Lexer;
 import org.nwapw.abacus.lexing.pattern.Match;
 import org.nwapw.abacus.lexing.pattern.Pattern;
@@ -24,6 +25,10 @@ public class TreeBuilder {
      * The map of operator associativity.
      */
     private Map<String, OperatorAssociativity> associativityMap;
+    /**
+     * The map of operator types.
+     */
+    private Map<String, OperatorType> typeMap;
 
     /**
      * Comparator used to sort token types.
@@ -43,6 +48,7 @@ public class TreeBuilder {
         }};
         precedenceMap = new HashMap<>();
         associativityMap = new HashMap<>();
+        typeMap = new HashMap<>();
     }
 
     /**
@@ -59,10 +65,12 @@ public class TreeBuilder {
      * @param precedence the precedence of the operator.
      * @param associativity the associativity of the operator.
      */
-    public void registerOperator(String operator, int precedence, OperatorAssociativity associativity){
+    public void registerOperator(String operator, OperatorAssociativity associativity,
+                                 OperatorType operatorType, int precedence){
         lexer.register(Pattern.sanitize(operator), TokenType.OP);
         precedenceMap.put(operator, precedence);
         associativityMap.put(operator, associativity);
+        typeMap.put(operator, operatorType);
     }
 
     /**
@@ -93,9 +101,15 @@ public class TreeBuilder {
                 tokenStack.push(match);
             } else if(matchType == TokenType.OP){
                 String tokenString = source.substring(match.getFrom(), match.getTo());
+                OperatorType type = typeMap.get(tokenString);
                 int precedence = precedenceMap.get(tokenString);
                 OperatorAssociativity associativity = associativityMap.get(tokenString);
 
+                if(type == OperatorType.UNARY_POSTFIX){
+                    output.add(match);
+                    continue;
+                }
+
                 while(!tokenStack.empty()) {
                     Match<TokenType> otherMatch = tokenStack.peek();
                     TokenType otherMatchType = otherMatch.getType();
@@ -143,10 +157,18 @@ public class TreeBuilder {
         Match<TokenType> match = matches.remove(0);
         TokenType matchType = match.getType();
         if(matchType == TokenType.OP){
+            String operator = source.substring(match.getFrom(), match.getTo());
+            OperatorType type = typeMap.get(operator);
+            if(type == OperatorType.BINARY_INFIX){
                 TreeNode right = fromStringRecursive(source, matches);
                 TreeNode left = fromStringRecursive(source, matches);
                 if(left == null || right == null) return null;
-            else return new OpNode(source.substring(match.getFrom(), match.getTo()), left, right);
+                else return new BinaryInfixNode(operator, left, right);
+            } else {
+                TreeNode applyTo = fromStringRecursive(source, matches);
+                if(applyTo == null) return null;
+                else return new UnaryPrefixNode(operator, applyTo);
+            }
         } else if(matchType == TokenType.NUM){
             return new NumberNode(Double.parseDouble(source.substring(match.getFrom(), match.getTo())));
         } else if(matchType == TokenType.FUNCTION){

src/org/nwapw/abacus/tree/UnaryPrefixNode.java

@@ -0,0 +1,54 @@
+package org.nwapw.abacus.tree;
+
+public class UnaryPrefixNode extends TreeNode {
+
+    /**
+     * The operation this node will apply.
+     */
+    private String operation;
+    /**
+     * The tree node to apply the operation to.
+     */
+    private TreeNode applyTo;
+
+    /**
+     * Creates a new node with the given operation and no child.
+     * @param operation the operation for this node.
+     */
+    public UnaryPrefixNode(String operation){
+        this(operation, null);
+    }
+
+    /**
+     * Creates a new node with the given operation and child.
+     * @param operation the operation for this node.
+     * @param applyTo the node to apply the function to.
+     */
+    public UnaryPrefixNode(String operation, TreeNode applyTo){
+        this.operation = operation;
+        this.applyTo = applyTo;
+    }
+
+    @Override
+    public <T> T reduce(Reducer<T> reducer) {
+        Object reducedChild = applyTo.reduce(reducer);
+        if(reducedChild == null) return null;
+        return reducer.reduceNode(this, reducedChild);
+    }
+
+    /**
+     * Gets the operation of this node.
+     * @return the operation this node performs.
+     */
+    public String getOperation() {
+        return operation;
+    }
+
+    /**
+     * Gets the node to which this node's operation applies.
+     * @return the tree node to which the operation will be applied.
+     */
+    public TreeNode getApplyTo() {
+        return applyTo;
+    }
+}

src/org/nwapw/abacus/window/Window.java

@@ -269,7 +269,10 @@ public class Window extends JFrame implements PluginListener {
         }
         for(String operator : manager.getAllOperators()){
             Operator operatorObject = manager.operatorFor(operator);
-            builder.registerOperator(operator, operatorObject.getPrecedence(), operatorObject.getAssociativity());
+            builder.registerOperator(operator,
+                    operatorObject.getAssociativity(),
+                    operatorObject.getType(),
+                    operatorObject.getPrecedence());
         }
     }