-Implemented support for linspace() function in frontend.

-Fixed bug with slicing in modifiers  in several sub-component modifiers, e.g. PositivePin p[2](i(start={1,2}));
-Fixed bug in prefixExp on general ASUB expressions

git-svn-id: https://openmodelica.org/svn/OpenModelica/branches/MathCoreOSMC@4162 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: Peter Aronsson

Compiler/Builtin.mo

@@ -2160,6 +2160,14 @@ protected constant tuple<Types.TType, Option<Type_a>> intInt2vectorreal=(
           ("y",(Types.T_INTEGER({}),NONE))},
           (Types.T_ARRAY(Types.DIM(SOME(1)),(Types.T_REAL({}),NONE)),
           NONE)),NONE);
+          
+protected constant tuple<Types.TType, Option<Type_a>> realRealInt2vectorreal=(
+          Types.T_FUNCTION(
+          {("x",(Types.T_REAL({}),NONE)),
+          ("y",(Types.T_REAL({}),NONE)),
+          ("n",(Types.T_INTEGER({}),NONE))},
+          (Types.T_ARRAY(Types.DIM(NONE),(Types.T_REAL({}),NONE)),
+          NONE)),NONE);          
 
 protected constant tuple<Types.TType, Option<Type_a>> array1dimint2array3dimint=(
           Types.T_FUNCTION(
@@ -3154,7 +3162,7 @@ algorithm
       env = Env.extendFrameT(env, "array", n6real2arrayreal);
       env = Env.extendFrameT(env, "array", n7real2arrayreal);
       env = Env.extendFrameT(env, "array", n8real2arrayreal);
-      env = Env.extendFrameT(env, "linspace", intInt2vectorreal);
+      env = Env.extendFrameT(env, "linspace", realRealInt2vectorreal);
       env = Env.extendFrameT(env, "min", intInt2int);
       env = Env.extendFrameT(env, "min", realReal2real);
       env = Env.extendFrameT(env, "min", array1dimint2int);

Compiler/Ceval.mo

@@ -923,6 +923,7 @@ algorithm
     case "identity" then cevalBuiltinIdentity; 
     case "promote" then cevalBuiltinPromote; 
     case "String" then cevalBuiltinString;
+    case "linspace" then cevalBuiltinLinspace;
     //case "semiLinear" then cevalBuiltinSemiLinear;
     //case "delay" then cevalBuiltinDelay;
     case id
@@ -1971,6 +1972,70 @@ algorithm
   end matchcontinue;
 end cevalBuiltinString;
 
+protected function cevalBuiltinLinspace "
+  author: PA
+  Evaluates the linpace function"
+	input Env.Cache inCache;
+  input Env.Env inEnv;
+  input list<Exp.Exp> inExpExpLst;
+  input Boolean inBoolean;
+  input Option<Interactive.InteractiveSymbolTable> inInteractiveInteractiveSymbolTableOption;
+  input Msg inMsg;
+  output Env.Cache outCache;
+  output Values.Value outValue;
+  output Option<Interactive.InteractiveSymbolTable> st;
+algorithm 
+  (outCache,outValue,outInteractiveInteractiveSymbolTableOption):=
+  matchcontinue (inCache,inEnv,inExpExpLst,inBoolean,st,inMsg)
+      local
+        Exp.Exp x,y,n; Integer size;
+        Real rx,ry; list<Values.Value> valLst; Env.Cache cache; Boolean impl; Env.Env env; Msg msg;      
+    case (cache,env,{x,y,n},impl,st,msg) equation
+      (cache,Values.INTEGER(size),_) = ceval(cache,env, n, impl, st, NONE, msg);
+      verifyLinspaceN(size,{x,y,n});
+      (cache,Values.REAL(rx),_) = ceval(cache,env, x, impl, st, NONE, msg);
+      (cache,Values.REAL(ry),_) = ceval(cache,env, y, impl, st, NONE, msg);
+      valLst = cevalBuiltinLinspace2(rx,ry,size,1);
+    then (cache,Values.ARRAY(valLst),st);
+      
+  end matchcontinue;
+end cevalBuiltinLinspace;
+
+protected function verifyLinspaceN "checks that n>=2 for linspace(x,y,n) "
+  input Integer n;
+  input list<Exp.Exp> expl;
+algorithm
+  _ := matchcontinue(n,expl)
+  local String s; Exp.Exp x,y,nx;
+    case(n,_) equation
+      true = n >= 2;
+    then ();
+    case(_,{x,y,nx}) equation
+      s = "linspace("+&Exp.printExpStr(x)+&", "+&Exp.printExpStr(y)+&", "+&Exp.printExpStr(nx)+&")";
+      Error.addMessage(Error.LINSPACE_ILLEGAL_SIZE_ARG,{s});
+    then fail();
+  end matchcontinue;
+end verifyLinspaceN;
+
+protected function cevalBuiltinLinspace2 "Helper function to cevalBuiltinLinspace"
+  input Real rx;
+  input Real ry;
+  input Integer size;
+  input Integer i "iterator 1 <= i <= size";
+  output list<Values.Value> valLst;
+algorithm
+  valLst := matchcontinue(rx,ry,size,i)
+  local Real r;
+    case(rx,ry,size,i) equation
+      true = i > size; 
+    then {};
+    case(rx,ry,size,i) equation
+      r = rx +. (ry -. rx)*. intReal(i-1) /. intReal(size - 1);
+      valLst = cevalBuiltinLinspace2(rx,ry,size,i+1);
+    then Values.REAL(r)::valLst;      
+  end matchcontinue;
+end cevalBuiltinLinspace2;
+
 protected function cevalCat "function: cevalCat
   evaluates the cat operator given a list of 
   array values and a concatenation dimension."

Compiler/Error.mo

@@ -198,6 +198,8 @@ public constant ErrorID STRUCT_SINGULAR_SYSTEM_INITIALIZATION=111;
 public constant ErrorID CIRCULAR_EQUATION=112;
 public constant ErrorID IF_EQUATION_NO_ELSE=113;
 public constant ErrorID IF_EQUATION_UNBALANCED=114;
+public constant ErrorID LINSPACE_ILLEGAL_SIZE_ARG=115
+;
 public constant ErrorID UNBOUND_PARAMETER_WARNING=500;
 public constant ErrorID BUILTIN_FUNCTION_SUM_HAS_SCALAR_PARAMETER=501;
 public constant ErrorID BUILTIN_FUNCTION_PRODUCT_HAS_SCALAR_PARAMETER=502;
@@ -487,7 +489,9 @@ protected constant list<tuple<Integer, MessageType, Severity, String>> errorTabl
           (SELECTED_STATES,TRANSLATION(),NOTIFICATION(), "The following variables are selected as states: %s"),
           (INCONSISTENT_UNITS, TRANSLATION(),WARNING(),"The system of units is inconsistent in term %s with the units %s and %s respectively."),
           (IF_EQUATION_NO_ELSE, TRANSLATION(),ERROR(),"In equation %s. If-equation with conditions that are not parameter expressions must have an else branch, in equation."),
-          (IF_EQUATION_UNBALANCED, TRANSLATION(),ERROR(),"In equation %s. If-equation with conditions that are not parameter expressions must have the same number of equations in each branch, equation count is %s for each respective branch.") 
+          (IF_EQUATION_UNBALANCED, TRANSLATION(),ERROR(),"In equation %s. If-equation with conditions that are not parameter expressions must have the same number of equations in each branch, equation count is %s for each respective branch."),
+          (LINSPACE_ILLEGAL_SIZE_ARG,TRANSLATION(),ERROR(),"In expression %s, third argument to linspace must be >= 2")
+           
           };
 
 protected import ErrorExt;

Compiler/Inst.mo

@@ -1450,7 +1450,7 @@ algorithm
     case(cache,env,id,_,bind,expectedTp,Types.PROP(bindTp,_)) local String s1,s2;
       equation 
         failure((_,_) = Types.matchType(bind,bindTp,expectedTp));
-        s1 = "builtin attribute " +& id;
+        s1 = "builtin attribute " +& id +& " of type "+&Types.unparseType(bindTp);
         s2 = Types.unparseType(expectedTp);
         Error.addMessage(Error.TYPE_ERROR,{s1,s2});
       then fail();   
@@ -5835,7 +5835,7 @@ algorithm
     case (cache,env,store,ci_state,mod,pre,csets,n,cl,attr,prot,(dim :: dims),idxs,inst_dims,impl,comment,io,finalPrefix,graph) 
       equation 
         dime = instDimExp(dim, impl);
-        inst_dims_1 = Util.listListAppendLast(inst_dims, {dime});
+        inst_dims_1 = Util.listListAppendLast(inst_dims, {dime});        
         (cache,compenv,store,dae,Connect.SETS(_,crs,dc,oc),ty,graph) = 
           instArray(cache,env,store, ci_state, mod, pre, csets, n, (cl,attr),prot, 1, dim, dims, idxs, inst_dims_1, impl, comment,io,finalPrefix,graph);
         dimt = instDimType(dim);        
@@ -6747,7 +6747,7 @@ algorithm
         (cache,env_1,store,{dae},csets,ty,graph);
 
     case (cache,env,store,ci_state,mod,pre,csets,n,(cl,attr),prot,i,DIMEXP(subscript = _),dims,idxs,inst_dims,impl,comment,io,finalPrefix,graph)
-      equation 
+      equation         
         (cache,compenv,store,daeLst,csets,ty,graph) = 
           instVar2(cache, env, store,ci_state, mod, pre, csets, n, cl, attr, prot, dims, (i :: idxs), inst_dims, impl, comment,io,finalPrefix,graph);
       then

Compiler/Mod.mo

@@ -1134,10 +1134,7 @@ algorithm
         (mod_1,subs_1) = lookupIdxModification2(subs, NONE, idx);
         mod_2 = merge(Types.MOD(f,each_,subs_1,NONE), mod_1, {}, Prefix.NOPRE());
         eq_1 = indexEqmod(eq, {idx});
-        mod_3 = merge(mod_2, Types.MOD(f,each_,{},eq_1), {}, Prefix.NOPRE()) "	& print \"lookup_idx_modificaton input :\" &
-	print_mod_str inmod => s & print s & print \"\\n\" 
-	& print \"lookup_idx_modificaton returns :\" &
-	print_mod_str mod\'\'\' => s & print s & print \"\\n\"" ;
+        mod_3 = merge(mod_2, Types.MOD(f,each_,{},eq_1), {}, Prefix.NOPRE());
       then
         mod_3;
     case (mod,idx)
@@ -1235,15 +1232,16 @@ algorithm
     local
       Option<Types.EqMod> eq_1,eq;
       Boolean f;
-      list<Types.SubMod> subs;
+      list<Types.SubMod> subs,subs_1;
       Integer idx;
     case (Types.NOMOD(),_) then Types.NOMOD();  /* indx */ 
     case (Types.REDECL(finalPrefix = _),_) then Types.NOMOD(); 
     case (Types.MOD(finalPrefix = f,each_ = Absyn.NON_EACH(),subModLst = subs,eqModOption = eq),idx)
       equation 
+        (_,subs_1) = lookupIdxModification2(subs, NONE, idx);
         eq_1 = indexEqmod(eq, {idx});
       then
-        Types.MOD(f,Absyn.NON_EACH(),subs,eq_1);
+        Types.MOD(f,Absyn.NON_EACH(),subs_1,eq_1);
     case (Types.MOD(finalPrefix = f,each_ = Absyn.EACH(),subModLst = subs,eqModOption = eq),idx) then Types.MOD(f,Absyn.EACH(),subs,eq); 
     case (_,_) equation
       Debug.fprint("failtrace", "-lookupIdxModification3 failed\n");

Compiler/Prefix.mo

@@ -361,6 +361,15 @@ algorithm
           e2 = Exp.ASUB(Exp.CREF(p_1,t),es_1);
     then (cache,e2); 
 
+    case (cache,env,(e as Exp.ASUB(exp = e1, sub = expl)),pre) 
+      local list<Exp.Exp> expl;
+      equation
+        (cache,es_1) = prefixExpList(cache,env, expl, pre);
+        (cache,e1) = prefixExp(cache,env,e1,pre);
+        e2 = Exp.ASUB(e1,es_1);
+      then (cache,e2); 
+      
+      
     case (cache,env,Exp.CREF(componentRef = p,ty = t),pre)
       equation 
         (cache,_,_,_) = Lookup.lookupVarLocal(cache,env, p);

Compiler/Static.mo

@@ -5122,7 +5122,57 @@ algorithm
 				Types.PROP((Types.T_STRING({}),NONE),c));		
   end matchcontinue;
 end elabBuiltinString;
-  
+
+protected function elabBuiltinLinspace "
+  author: PA
+ 
+  This function handles the built-in linspace function.
+  e.g. linspace(1,3,3) => {1,2,3}
+       linspace(0,1,5) => {0,0.25,0.5,0.75,1.0}
+"
+	input Env.Cache inCache;
+  input Env.Env inEnv;
+  input list<Absyn.Exp> expl;
+  input list<Absyn.NamedArg> inNamedArg;  
+  input Boolean impl;
+  output Env.Cache outCache;
+  output Exp.Exp outExp;
+  output Types.Properties outProperties;
+algorithm 
+  (outCache,outExp,outProperties):=
+  matchcontinue (inCache,inEnv,expl,inNamedArg,impl)
+      local Absyn.Exp x,y,n;
+        Exp.Exp x1,y1,n1,x2,y2; Types.Type tp1,tp2,tp3,tp11,tp22; Types.Const c1,c2,c3,c;
+        Integer size;
+        Env.Cache cache; Env.Env env;
+        
+        /* linspace(x,y,n) where n is constant or parameter */
+    case (cache,env,{x,y,n},_,impl) equation
+      (cache,x1,Types.PROP(tp1,c1),_) = elabExp(cache,env, x, impl, NONE,true);
+      (cache,y1,Types.PROP(tp2,c2),_) = elabExp(cache,env, y, impl, NONE,true);
+      (x2,tp11) = Types.matchType(x1,tp1,(Types.T_REAL({}),NONE));
+      (y2,tp22) = Types.matchType(y1,tp2,(Types.T_REAL({}),NONE));    
+      (cache,n1,Types.PROP(tp3 as (Types.T_INTEGER(_),_),c3),_) = elabExp(cache,env, n, impl, NONE,true);
+      true = Types.isParameterOrConstant(c3);
+      (cache,Values.INTEGER(size),_) = Ceval.ceval(cache,env, n1, false, NONE, NONE, Ceval.MSG());      
+      c = Types.constAnd(c1,c2);
+    then (cache, Exp.CALL(Absyn.IDENT("linspace"),{x2,y2,n1},false,true,Exp.T_ARRAY(Exp.REAL(),{SOME(size)})),
+      Types.PROP((Types.T_ARRAY(Types.DIM(SOME(size)),tp11),NONE),c));
+      
+    /* linspace(x,y,n) where n is variable time expression */
+    case (cache,env,{x,y,n},_,impl) equation
+      (cache,x1,Types.PROP(tp1,c1),_) = elabExp(cache,env, x, impl, NONE,true);
+      (cache,y1,Types.PROP(tp2,c2),_) = elabExp(cache,env, y, impl, NONE,true);
+      (x2,tp11) = Types.matchType(x1,tp1,(Types.T_REAL({}),NONE));
+      (y2,tp22) = Types.matchType(y1,tp2,(Types.T_REAL({}),NONE));    
+      (cache,n1,Types.PROP(tp3 as (Types.T_INTEGER(_),_),c3),_) = elabExp(cache,env, n, impl, NONE,true);
+      false = Types.isParameterOrConstant(c3);           
+      c = Types.constAnd(c1,Types.constAnd(c2,c3));
+    then (cache, Exp.CALL(Absyn.IDENT("linspace"),{x2,y2,n1},false,true,Exp.T_ARRAY(Exp.REAL(),{NONE})),
+      Types.PROP((Types.T_ARRAY(Types.DIM(NONE),tp11),NONE),c));      
+  end matchcontinue;
+end elabBuiltinLinspace;
+
 protected function elabBuiltinVector "function: elabBuiltinVector
   author: PA
  
@@ -5403,6 +5453,7 @@ algorithm
     case "cross" then elabBuiltinCross;
     case "skew" then elabBuiltinSkew;
     case "String" then elabBuiltinString;
+    case "linspace" then elabBuiltinLinspace;
   end matchcontinue;
 end elabBuiltinHandler;