Unary operators handled properly in explicit engine.

git-svn-id: https://www.prismmodelchecker.org/svn/prism/prism/trunk@4629 bbc10eb1-c90d-0410-af57-cb519fbb1720

prism/src/explicit/StateModelChecker.java

@@ -250,6 +250,10 @@ public class StateModelChecker
 		if (expr instanceof ExpressionBinaryOp) {
 			res = checkExpressionBinaryOp(model, (ExpressionBinaryOp) expr);
 		}
+		// Unary ops
+		if (expr instanceof ExpressionUnaryOp) {
+			res = checkExpressionUnaryOp(model, (ExpressionUnaryOp) expr);
+		}
 		// Literals
 		else if (expr instanceof ExpressionLiteral) {
 			res = checkExpressionLiteral(model, (ExpressionLiteral) expr);
@@ -322,6 +326,27 @@ public class StateModelChecker
 		return res1;
 	}
 
+	/**
+	 * Model check a unary operator.
+	 */
+	protected StateValues checkExpressionUnaryOp(Model model, ExpressionUnaryOp expr) throws PrismException
+	{
+		StateValues res1 = null;
+		int op = expr.getOperator();
+		
+		// Check operand recursively
+		res1 = checkExpression(model, expr.getOperand());
+		
+		// Parentheses are easy - nothing to do:
+		if (op == ExpressionUnaryOp.PARENTH)
+			return res1;
+
+		// Apply operation
+		res1.applyUnaryOp(op);
+		
+		return res1;
+	}
+
 	/**
 	 * Model check a literal.
 	 */

prism/src/explicit/StateValues.java

@@ -35,6 +35,7 @@ import java.util.List;
 
 import parser.State;
 import parser.ast.ExpressionBinaryOp;
+import parser.ast.ExpressionUnaryOp;
 import parser.type.Type;
 import parser.type.TypeBool;
 import parser.type.TypeDouble;
@@ -491,8 +492,7 @@ public class StateValues
 				for (int i = 0; i < size; i++) {
 					valuesB.set(i, valuesD[i] > sv.valuesD[i]);
 				}
-			}
-			else {
+			} else {
 				throw new PrismException("Operator > can not be applied to Boolean vectors");
 			}
 		} else {
@@ -531,8 +531,7 @@ public class StateValues
 				for (int i = 0; i < size; i++) {
 					valuesB.set(i, valuesD[i] >= sv.valuesD[i]);
 				}
-			}
-			else {
+			} else {
 				throw new PrismException("Operator >= can not be applied to Boolean vectors");
 			}
 		} else {
@@ -571,8 +570,7 @@ public class StateValues
 				for (int i = 0; i < size; i++) {
 					valuesB.set(i, valuesD[i] < sv.valuesD[i]);
 				}
-			}
-			else {
+			} else {
 				throw new PrismException("Operator < can not be applied to Boolean vectors");
 			}
 		} else {
@@ -611,8 +609,7 @@ public class StateValues
 				for (int i = 0; i < size; i++) {
 					valuesB.set(i, valuesD[i] <= sv.valuesD[i]);
 				}
-			}
-			else {
+			} else {
 				throw new PrismException("Operator <= can not be applied to Boolean vectors");
 			}
 		} else {
@@ -771,6 +768,52 @@ public class StateValues
 		}
 	}
 
+	/**
+	 * Modify the vector by applying unary operator {@code op}.
+	 */
+	public void applyUnaryOp(int op) throws PrismException
+	{
+		switch (op) {
+		case ExpressionUnaryOp.NOT:
+			not();
+			break;
+		case ExpressionUnaryOp.MINUS:
+			minus();
+			break;
+		default:
+			throw new PrismException("Unknown binary operator");
+		}
+	}
+
+	/**
+	 * Modify the vector by applying 'not'
+	 */
+	public void not() throws PrismException
+	{
+		if (!(type instanceof TypeBool)) {
+			throw new PrismException("Operator ! can only be applied to Boolean vectors");
+		}
+		valuesB.flip(0, size);
+	}
+
+	/**
+	 * Modify the vector by applying (unary) 'minus'.
+	 */
+	public void minus() throws PrismException
+	{
+		if (type instanceof TypeInt) {
+			for (int i = 0; i < size; i++) {
+				valuesI[i] = -valuesI[i];
+			}
+		} else if (type instanceof TypeDouble) {
+			for (int i = 0; i < size; i++) {
+				valuesD[i] = -valuesD[i];
+			}
+		} else {
+			throw new PrismException("Operator - can not be applied to Boolean vectors");
+		}
+	}
+
 	/**
 	 * Set the elements of this vector by reading them in from a file.
 	 */