From: villberg <villberg@ac1ea38d-2e2b-0410-8846-a27921b304fc>
Date: Thu, 21 Aug 2014 08:23:13 +0000 (+0000)
Subject: refs #5198
X-Git-Tag: v1.29.0~227
X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=commitdiff_plain;h=987be97cd93be0d5d6db24f1c88dcfffb23df97b;p=simantics%2Fsysdyn.git

refs #5198

git-svn-id: https://www.simantics.org/svn/simantics/sysdyn/trunk@30111 ac1ea38d-2e2b-0410-8846-a27921b304fc
---

diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Array.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Array.java
index 68a0504b..d0ceff4f 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Array.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Array.java
@@ -21,6 +21,8 @@ public class Array implements IExpression {
 	public static final Array FULL = new Array();
 	
 	final private ArrayList<Object> elements;
+	
+	boolean isVector = true;
 
 	public Array() {
 		elements = new ArrayList<Object>();
@@ -32,7 +34,15 @@ public class Array implements IExpression {
 
 	public Array addElement(Object element) {
 		if(element instanceof Constant) addElement(((Constant)element).value);
-		else elements.add(element);
+		else {
+			
+//			if(element instanceof Double)
+//				if(Double.isNaN((Double)element))
+//					throw new IllegalStateException();
+
+			if(element instanceof Array) isVector = false;
+			elements.add(element);
+		}
 		return this;
 	}
 	
@@ -307,6 +317,29 @@ public class Array implements IExpression {
 		return result;
 	}
 
+	public Array sub(Array other) {
+		Array result = new Array();
+		Collection<Object> lae = elements();
+		Collection<Object> rae = other.elements();
+		if(lae.size() != rae.size()) throw new IllegalStateException();
+		Iterator<Object> li = lae.iterator();
+		Iterator<Object> ri = rae.iterator();
+		for(int i=0;i<lae.size();i++) {
+			Object l = li.next();
+			Object r = ri.next();
+			if(l instanceof Double && r instanceof Double) {
+				result.addElement(((Double)l)-((Double)r));
+			} else if (l instanceof Array && r instanceof Array) {
+				Array arr = (Array)l;
+				Array otherArr = (Array)r;
+				result.addElement(arr.sub(otherArr));
+			} else {
+				throw new IllegalStateException();
+			}
+		}
+		return result;
+	}
+
 	public Array mul(Array other) {
 		Array result = new Array();
 		Collection<Object> lae = elements();
@@ -329,6 +362,27 @@ public class Array implements IExpression {
 		}
 		return result;
 	}
+	/*
+	 * Both arrays are vectors 
+	 */
+	public double inner(Array other) {
+		double result = 0;
+		Collection<Object> lae = elements();
+		Collection<Object> rae = other.elements();
+		if(lae.size() != rae.size()) throw new IllegalStateException();
+		Iterator<Object> li = lae.iterator();
+		Iterator<Object> ri = rae.iterator();
+		for(int i=0;i<lae.size();i++) {
+			Object l = li.next();
+			Object r = ri.next();
+			if(l instanceof Double && r instanceof Double) {
+				result += ((Double)l)*((Double)r);
+			} else {
+				throw new IllegalStateException();
+			}
+		}
+		return result;
+	}
 
 	public Array pow(Array other) {
 		Array result = new Array();
@@ -378,5 +432,9 @@ public class Array implements IExpression {
 		}
 		return result;
 	}
+	
+	public boolean isVector() {
+		return isVector;
+	}
 
 }
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Derivate.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Derivate.java
index 7d26af56..6e3772a8 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Derivate.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Derivate.java
@@ -28,10 +28,27 @@ public class Derivate implements IExpression {
 	public Object evaluate(IEnvironment _environment) {
 		Environment environment = (Environment)_environment;
 //		Double old = (Double)environment.getValue(variable.name + variable.subscriptKey());
-		Double old = (Double)environment.getValue(variable.base.index(_environment, subscripts));
+		Object old = variable.evaluate(environment);
+		
+//		Double old = (Double)environment.getValue(variable.base.index(_environment, subscripts));
 		// FIXME: should not be fixed like this
 		if(old == null) old = 0.0;
-		return old+environment.step*(Double)e.evaluate(environment);
+		Object eval = e.evaluate(environment);
+		if(eval instanceof Double) {
+			return ((Double)old)+environment.step*(Double)eval;
+		} else if (eval instanceof Array) {
+			Array arr = (Array)eval;
+			Array oldArray = (Array)old;
+			Array result = new Array();
+			for(int i=0;i<arr.dimension();i++) {
+				Double d = (Double)arr.element(i);
+				Double o = (Double)oldArray.element(i);
+				result.addElement(o+environment.step*d);
+			}
+			return result;
+		} else {
+			throw new UnsupportedOperationException();
+		}
 	}
 	
 	@Override
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseDivision.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseDivision.java
index 77362aa5..51c91e92 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseDivision.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseDivision.java
@@ -59,6 +59,10 @@ public class ElementwiseDivision implements IExpression {
 				result.addElement(ld/rd);
 			}
 			return result;
+		} else if(left instanceof Double && right instanceof Double) {
+			double ld = (Double)left;
+			double rd = (Double)right;
+			return ld*rd;
 		} else {
 			throw new UnsupportedOperationException();
 		}
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseProduct.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseProduct.java
index f87529c5..fa670ac8 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseProduct.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/ElementwiseProduct.java
@@ -58,6 +58,16 @@ public class ElementwiseProduct implements IExpression {
 				result.addElement(ld*rd);
 			}
 			return result;
+		} else if (left instanceof Double && right instanceof Array) {
+			Array ra = (Array)right;
+			Double ld = (Double)left;
+			List<Object> rae = ra.elements();
+			Array result = new Array(rae.size());
+			for(Object o : rae) {
+				Double rd = (Double)o;
+				result.addElement(ld*rd);
+			}
+			return result;
 		} else {
 			throw new UnsupportedOperationException();
 		}
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Model.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Model.java
index e4b1337a..a5fde8b0 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Model.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Model.java
@@ -122,20 +122,54 @@ class Model implements IFrame {
 			}
 			
 			Variable[] parameters = fn.parameters();
+			Object[] ps = new Object[parameters.length];
 			
+			int vectorDimension = 0;
 			for(int i=0;i<parameters.length;i++) {
 				Variable var = parameters[i];
 				if(i < argh.size()) {
-					Object value = argh.get(i);
-					var.assignPlain(frame, value);
+					ps[i] = argh.get(i);
 				} else {
-					Object value = fn.evaluateInput(environment, i);
-					var.assignPlain(frame, value);
+					ps[i] = fn.evaluateInput(environment, i);
 				}
+				if(var.base.dimensions == null && ps[i] instanceof Array)
+					vectorDimension = ((Array)ps[i]).dimension();
 			}
 			
-			fn.setLocals(frame);
-			return fn.evaluate(frame, args.args.length);
+			if(vectorDimension > 0) {
+
+				Array result = new Array();
+				
+				for(int i=0;i<vectorDimension;i++) {
+
+					for(int j=0;j<parameters.length;j++) {
+						Object o = ps[j];
+						if(o instanceof Array) {
+							Object sub = ((Array)o).element(i);
+							parameters[j].assignPlain(frame, sub);
+						} else {
+							parameters[j].assignPlain(frame, o);
+						}
+					}
+					
+					fn.setLocals(frame);
+					Object ret = fn.evaluate(frame, args.args.length);
+					result.addElement(ret);
+					
+				}
+				
+				return result;
+				
+			} else {
+			
+				for(int i=0;i<parameters.length;i++) {
+					parameters[i].assignPlain(frame, ps[i]);
+				}
+				
+				fn.setLocals(frame);
+				return fn.evaluate(frame, args.args.length);
+				
+			}
 			
 		}
 			
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Multiplication.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Multiplication.java
index e4d29b2c..154d4e91 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Multiplication.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Multiplication.java
@@ -38,7 +38,9 @@ public class Multiplication implements IExpression {
 		else if(left instanceof Array && right instanceof Array) {
 			Array la = (Array)left;
 			Array ra = (Array)right;
-			return la.mul(ra);
+			if(la.isVector && ra.isVector) {
+				return la.inner(ra);
+			}
 		}
 		else if (left instanceof Array && right instanceof Double) return ((Array)left).mul((Double)right);
 		else if (left instanceof Double && right instanceof Array) return ((Array)right).mul((Double)left);
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Solver.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Solver.java
index 6ea46d57..dd1e876f 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Solver.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Solver.java
@@ -30,16 +30,15 @@ public class Solver {
 
 	private static final boolean PRINT_EXCEPTIONS = false;	
 	private static final int STACK_SIZE = 1000;
+	private static final int MAX_LOOPS = 50;
 
 	private Model model;
 	private Environment env;
 
 	private Object[] newValues;
-	private Object[] derivatives;
 	
 	private double defaultStep;
 	private double start;
-	private NodeCache cache;
 	private boolean ready;
 	
 	private boolean dirty;
@@ -49,7 +48,6 @@ public class Solver {
 		defaultStep = 0.1;
 		start = 0;
 		// is it okay to store the cache with the solver instance?
-		cache = new NodeCache();
 		ready = false;
 	}
 	
@@ -112,6 +110,17 @@ public class Solver {
 	private SimpleNode n;
 	private String codeCache = null;
 	
+	private void validate(Variable var, Object value) {
+		if(value instanceof Double) {
+			if(Double.isNaN((Double)value)) {
+				throw new IllegalStateException("value is invalid (NaN)");
+			}
+		}
+		if(value instanceof Array) {
+			for(Object o : ((Array)value).elements()) validate(var, o);
+		}
+	}
+	
 	public void prepare(String input) throws Exception {
 		
 		long startNanos = System.nanoTime();
@@ -148,13 +157,16 @@ public class Solver {
 		model.parameterArray = model.parameters.toArray(new ParameterDeclaration[model.parameters.size()]);
 		
 		newValues = new Object[Math.max(model.assignments.size(),model.derivatives.size())];
-		derivatives = new Object[model.derivatives.size()];
 		
 		int condition = 1;
 		int loops = 0;
 		
-		while(condition > 0 && loops++ < 50) {
+		StringBuilder errors = null;
+		
+		while(condition > 0 && loops++ < MAX_LOOPS) {
 
+			if(loops == MAX_LOOPS) errors = new StringBuilder();
+			
 			if(PRINT_EXCEPTIONS) {
 				System.err.println("== LOOP " + loops + " ==");
 			}
@@ -164,14 +176,21 @@ public class Solver {
 			for(ParameterDeclaration pd : model.parameters) {
 				try {
 					if(!pd.assigned) {
-						pd.variable.assign(env, null, pd.modification.evaluate(env));
+						Object value = pd.modification.evaluate(env);
+						validate(pd.variable, value);
+						pd.variable.assign(env, null, value);
 						pd.assigned = true;
 					}
 				} catch (Exception e) {
+					String error = "  -" + pd.variable.toString() + ": " + e.getMessage();
+					if(errors != null) {
+						errors.append(error);
+						errors.append("\n");
+					}
 					condition++;
 					if(PRINT_EXCEPTIONS) {
 						e.printStackTrace();
-						System.err.println("failed to assign " + pd.variable.toString());
+						System.err.println(error);
 					}
 				}
 			}
@@ -187,12 +206,16 @@ public class Solver {
 							if(arg.name.endsWith("start")) {
 								Object value = arg.modification.evaluate(env);
 								if(vd.variable.base.dimension() == 1) {
+									validate(vd.variable, value);
 									vd.variable.assign(env, null, value);
 								} else {
+									validate(vd.variable, value);
 									if(value instanceof Double) {
 										Array array = new Array();
 										for(int i=0;i<vd.variable.base.dimension();i++) array.addElement(value);
 										vd.variable.assign(env, null, array);
+									} else if (value instanceof Array) {
+										vd.variable.assign(env, null, value);
 									} else {
 										throw new IllegalStateException();
 									}
@@ -209,10 +232,15 @@ public class Solver {
 						}
 					}
 				} catch (Exception e) {
+					String error = "  -" + vd.variable.toString() + ": " + e.getMessage();
+					if(errors != null) {
+						errors.append(error);
+						errors.append("\n");
+					}
 					condition++;
 					if(PRINT_EXCEPTIONS) {
 						e.printStackTrace();
-						System.err.println("failed to assign " + vd.variable.toString());
+						System.err.println(error);
 					}
 				}
 			}
@@ -222,20 +250,29 @@ public class Solver {
 					if(!ass.assigned) {
 						Object value = ass.expression.evaluate(env);
 						if(value != null) {
+							validate(ass.target, value);
 							ass.target.assign(env, ass.subscripts, value);
 							ass.assigned = true;
 						}
 					}
 				} catch (Exception e) {
+					String error = "  -" + ass.target.toString() + ": " + e.getMessage();
+					if(errors != null) {
+						errors.append(error);
+						errors.append("\n");
+					}
 					condition++;
 					if(PRINT_EXCEPTIONS) {
 						e.printStackTrace();
-						System.err.println("failed to assign " + ass.target.toString());
+						System.err.println(error);
 					}
 				}
 			}
 		}
 		
+		if(loops == (MAX_LOOPS+1))
+			throw new IllegalStateException("Did not find initial state for model:\n" + errors.toString());
+		
 		for(Assignment ass : model.assignments) {
 			if(ass.expression instanceof Constant)
 				ass.isConstant = true;
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Subtraction.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Subtraction.java
index 7534d1fb..4ef86db8 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Subtraction.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Subtraction.java
@@ -30,10 +30,18 @@ public class Subtraction implements IExpression {
     
 	@Override
 	public Object evaluate(IEnvironment environment) {
-		Double d1 = (Double)exp1.evaluate(environment);
-		Double d2 = (Double)exp2.evaluate(environment);
-		if(d1 == null || d2 == null) return null;
-		return d1-d2;
+		Object o1 = exp1.evaluate(environment);
+		Object o2 = exp2.evaluate(environment);
+		if(o1 == null || o2 == null) return null; 
+		if(o1 instanceof Double && o2 instanceof Double) {
+			return (Double)o1 - (Double)o2;
+		}
+		if(o1 instanceof Array && o2 instanceof Array) {
+			Array la = (Array)o1;
+			Array ra = (Array)o2;
+			return la.sub(ra);
+		}
+		throw new IllegalStateException();
 	}
 	
 	@Override
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Variable.java b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Variable.java
index 9335f68f..9420424b 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Variable.java
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/Variable.java
@@ -119,6 +119,11 @@ public class Variable implements IExpression {
 		env.put(base.index, value);
 	}
 	
+	private int subscriptLength() {
+		if(this.subscripts == null) return 1;
+		return this.subscripts.length;
+	}
+	
 	private void validateSize(IEnvironment env, IExpression[] subscripts, Object value) {
 		
 		if(value == null) return;
@@ -134,7 +139,7 @@ public class Variable implements IExpression {
 			}
 		} else {
 			if(subscripts == null) {
-				if(base.dimensions.length == this.subscripts.length && value instanceof Double) 
+				if(base.dimensions.length == subscriptLength() && value instanceof Double) 
 					return;
 				if(!(value instanceof Array))
 					throw new IllegalStateException();
diff --git a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/parser/ModelicaParser.jjt b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/parser/ModelicaParser.jjt
index 977d83d7..7c4de3d3 100644
--- a/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/parser/ModelicaParser.jjt
+++ b/fi.semantum.sysdyn.solver/src/fi/semantum/sysdyn/solver/parser/ModelicaParser.jjt
@@ -71,7 +71,7 @@ TOKEN:
 | "*" | "/" | ".*" | "./"
 | "^" | ".^"
 | "=" | ":=" 
-| <IDENT: ["a"-"z","A"-"Z","_"] (["a"-"z","A"-"Z","_",".", "0"-"9"])* >
+| <IDENT: ["a"-"z","A"-"Z","_"] (["a"-"z","A"-"Z","_","0"-"9"] | "." ["a"-"z","A"-"Z","_","0"-"9"])* >
 | <STRING: "\"" (~["\"", "\\", "\n"] | "\\" ~["\n"])* "\"">
     { matchedToken.image = matchedToken.image.substring(1,matchedToken.image.length()-1); }
 | <EXP: "e" | "e-" | "E" | "E-" | "E+" | "e+" >
@@ -641,7 +641,7 @@ void arithmetic_expression() : {
 
 void add_op() : {
 } {
-    "+" { jjtThis.op = "+";} | "-" { jjtThis.op = "-";} | ".+" | ".-"
+    "+" { jjtThis.op = "+";} | "-" { jjtThis.op = "-";} | ".+" { jjtThis.op = ".+";} | ".-" { jjtThis.op = ".-";}
 }
 
 
@@ -652,7 +652,7 @@ void term() : {
 
 void mul_op() : {
 } {
-    "*" { jjtThis.op = "*";} | "/" { jjtThis.op = "/";} | ".*" { jjtThis.op = ".*";} | "./"  { jjtThis.op = "./";}
+    ".*" { jjtThis.op = ".*";} | "./"  { jjtThis.op = "./";} | "*" { jjtThis.op = "*";} | "/" { jjtThis.op = "/";} 
 }
 
 void factor() : {