- remove unused flags VAR_INDEX,VAR_INDEX2

- remove unecessary code from removesimpleequationsfast - implement vararrayList2 tailrecursive - fix tests git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@12828 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
OpenModelica · Sep 7, 2012 · 2fc7253 · 2fc7253
1 parent 30f812e
commit 2fc7253
Show file tree

Hide file tree

Showing 6 changed files with 168 additions and 126 deletions.
diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo
@@ -380,8 +380,6 @@ algorithm
   match (isyst,sharedOptimized)
     local
       BackendVarTransform.VariableReplacements repl,repl_1;
-      BackendDAE.BinTree movedVars;
-      BackendDAE.Variables movedAVars;
       list<Integer> meqns,deqns;
       Boolean b,b1;
       BackendDAE.Shared shared;
@@ -394,17 +392,55 @@ algorithm
         derrepl = HashTable2.emptyHashTable();
         // check equations
         n = BackendDAEUtil.equationArraySizeDAE(syst);
-        ((syst,shared,repl_1,derrepl1,deqns,movedVars,movedAVars,meqns,b)) = 
+        ((syst,shared,repl_1,derrepl1,deqns,_,_,meqns,b)) = 
           traverseEquations(1,n,removeSimpleEquationsFastFinder,
             (syst,shared,repl,derrepl,{},BackendDAE.emptyBintree,BackendDAEUtil.emptyVars(),{},false));
         // replace der(x)=dx
         (syst,shared) = replaceDerEquations(deqns,syst,shared,derrepl1);
         // replace vars in arrayeqns and algorithms, move vars to knvars and aliasvars, remove eqns
-        (syst,shared) = removeSimpleEquations2(b,syst,shared,repl_1,movedVars,movedAVars,meqns);
+        (syst,shared) = removeSimpleEquationsFast2(b,syst,shared,repl_1,meqns);
       then (syst,(shared,(repl_1,b or b1)));
   end match;
 end removeSimpleEquationsFast1;
 
+protected function removeSimpleEquationsFast2
+"function: removeSimpleEquationsFast2"
+  input Boolean b;
+  input BackendDAE.EqSystem syst;
+  input BackendDAE.Shared shared;
+  input BackendVarTransform.VariableReplacements repl;
+  input list<Integer> meqns;
+  output BackendDAE.EqSystem osyst;
+  output BackendDAE.Shared oshared;
+algorithm
+  (osyst,oshared):=
+  match (b,syst,shared,repl,meqns)
+    local
+      BackendDAE.Variables ordvars,knvars,exobj,knvars1,aliasVars;
+      BackendDAE.EquationArray remeqns,inieqns,eqns,eqns1;
+      array<DAE.Constraint> constrs;
+      array<DAE.ClassAttributes> clsAttrs;
+      Env.Cache cache;
+      Env.Env env;      
+      DAE.FunctionTree funcTree;
+      BackendDAE.EventInfo einfo;
+      BackendDAE.ExternalObjectClasses eoc;
+      BackendDAE.SymbolicJacobians symjacs;
+      BackendDAE.BackendDAEType btp;  
+    case (false,_,_,_,_) then (syst,shared);
+    case (true,BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs),_,_)
+      equation
+        Debug.fcall(Flags.DUMP_REPL, BackendVarTransform.dumpReplacements, repl);
+        Debug.fcall(Flags.DUMP_REPL, BackendVarTransform.dumpExtendReplacements, repl);
+        // remove empty entries from vars
+        ordvars = BackendDAEUtil.listVar1(BackendDAEUtil.varList(ordvars));
+        // remove changed eqns
+        eqns1 = BackendEquation.equationDelete(eqns,meqns);        
+      then 
+        (BackendDAE.EQSYSTEM(ordvars,eqns1,NONE(),NONE(),BackendDAE.NO_MATCHING()),BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs));
+  end match;
+end removeSimpleEquationsFast2;
+
 protected function removeSimpleEquationsFastFinder
 "autor: Frenkel TUD 2012-03"
  input tuple<Integer,tuple<BackendDAE.EqSystem,BackendDAE.Shared,BackendVarTransform.VariableReplacements,HashTable2.HashTable,list<Integer>,BackendDAE.BinTree,BackendDAE.Variables,list<Integer>,Boolean>> inTpl;
@@ -436,25 +472,26 @@ algorithm
         vars1 = BackendEquation.equationVars(eqn,vars);
         varlst = BackendDAEUtil.varList(vars1);
         l = listLength(varlst);
-        ((syst1,shared1,repl_1,derrepl_1,deeqns_1,mvars_1,mavars_1,meqns1,b)) = removeSimpleEquationsFastFinder1((l,pos,varlst,eqn,(syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,b)));
-      then ((syst1,shared1,repl_1,derrepl_1,deeqns_1,mvars_1,mavars_1,meqns1,b));
+        ((syst1,shared1,repl_1,derrepl_1,deeqns_1,meqns1,b)) = removeSimpleEquationsFastFinder1((l,pos,varlst,eqn,(syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,b)));
+      then ((syst1,shared1,repl_1,derrepl_1,deeqns_1,mvars,mavars,meqns1,b));
     case ((_,(syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,b)))
-      then ((syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,b));
+      then 
+        ((syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,b));
    end matchcontinue;
 end removeSimpleEquationsFastFinder;
 
 protected function removeSimpleEquationsFastFinder1
 "autor: Frenkel TUD 2012-03"
  input tuple<Integer,Integer,list<BackendDAE.Var>,BackendDAE.Equation,tuple<BackendDAE.EqSystem,BackendDAE.Shared,BackendVarTransform.VariableReplacements,HashTable2.HashTable,list<Integer>,BackendDAE.BinTree,BackendDAE.Variables,list<Integer>,Boolean>> inTpl;
- output tuple<BackendDAE.EqSystem,BackendDAE.Shared,BackendVarTransform.VariableReplacements,HashTable2.HashTable,list<Integer>,BackendDAE.BinTree,BackendDAE.Variables,list<Integer>,Boolean> outTpl;
+ output tuple<BackendDAE.EqSystem,BackendDAE.Shared,BackendVarTransform.VariableReplacements,HashTable2.HashTable,list<Integer>,list<Integer>,Boolean> outTpl;
 algorithm
   outTpl:=
   matchcontinue (inTpl)
     local
       Integer pos,l,i,eqnType;
       BackendVarTransform.VariableReplacements repl,repl_1;
-      BackendDAE.BinTree mvars,mvars_1;
-      BackendDAE.Variables mavars,mavars_1;
+      BackendDAE.BinTree mvars;
+      BackendDAE.Variables mavars;
       list<Integer> meqns,meqns1,deeqns;
       DAE.ComponentRef cr;
       DAE.Exp exp,e1,e2;
@@ -470,17 +507,18 @@ algorithm
         true = intEq(l,0);  
         true = Expression.isConst(e1);
         true = Expression.expEqual(e1,e2);
-      then ((syst,shared,repl,derrepl,deeqns,mvars,mavars,pos::meqns,b));
+      then ((syst,shared,repl,derrepl,deeqns,pos::meqns,b));
     case ((l,pos,varlst,eqn,(syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,_)))
       equation
         true = intLt(l,3);
         true = intGt(l,0);
-        (cr,i,exp,syst,shared,mvars_1,mavars_1,eqnType) = simpleEquationPast(varlst,pos,eqn,syst,shared,mvars,mavars);
+        (cr,i,exp,syst,shared,_,_,eqnType) = simpleEquationPast(varlst,pos,eqn,syst,shared,mvars,mavars);
         // replace equation if necesarry
         (syst,shared,repl_1,derrepl,deeqns,meqns1) = replacementsInEqnsFast(eqnType,cr,i,exp,pos,repl,derrepl,deeqns,syst,shared,meqns);
-      then ((syst,shared,repl_1,derrepl,deeqns,mvars_1,mavars_1,meqns1,true));
+      then ((syst,shared,repl_1,derrepl,deeqns,meqns1,true));
     case ((_,_,_,_,(syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,b)))
-      then ((syst,shared,repl,derrepl,deeqns,mvars,mavars,meqns,b));
+      then 
+        ((syst,shared,repl,derrepl,deeqns,meqns,b));
    end matchcontinue;
 end removeSimpleEquationsFastFinder1;
 
@@ -519,20 +557,23 @@ algorithm
       BackendDAE.Shared shared,shared1;
       BackendDAE.Matching matching;
       HashTable2.HashTable derrepl;
-      
+    // a = constant
     case (0,cr,i,exp,pos,repl,derrepl,deeqns,syst as BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns,m=m,mT=mT,matching=matching),shared,meqns)
       equation
         // remove var from vars
         (ordvars1,v) = BackendVariable.removeVar(i,ordvars);
         shared1 = BackendVariable.addKnVarDAE(v, shared);
       then (BackendDAE.EQSYSTEM(ordvars1,eqns,m,mT,matching),shared1,repl,derrepl,deeqns,pos::meqns);
+    // a = b alias
     case (1,cr,i,exp,pos,repl,derrepl,deeqns,syst as BackendDAE.EQSYSTEM(orderedVars=ordvars,orderedEqs=eqns,m=m,mT=mT,matching=matching),shared,meqns)
       equation
         // remove var from vars
         (ordvars1,v) = BackendVariable.removeVar(i,ordvars);
+        shared1 = BackendVariable.addAliasVarDAE(v, shared);
         // update Replacements
         repl_1 = BackendVarTransform.addReplacement(repl, cr, exp,NONE());
-      then (BackendDAE.EQSYSTEM(ordvars1,eqns,m,mT,matching),shared,repl_1,derrepl,deeqns,pos::meqns);
+      then (BackendDAE.EQSYSTEM(ordvars1,eqns,m,mT,matching),shared1,repl_1,derrepl,deeqns,pos::meqns);
+    // a = der(b) der replacement
     case (2,cr,i,exp,pos,repl,derrepl,deeqns,syst as BackendDAE.EQSYSTEM(mT=mT),shared,meqns)
       equation
         derrepl = BaseHashTable.add((cr,exp),derrepl);
@@ -1190,7 +1231,7 @@ algorithm
   (osyst,oshared):=
   match (b,syst,shared,repl,movedVars,movedAVars,meqns)
     local
-      BackendDAE.Variables ordvars,knvars,exobj,ordvars1,knvars1,ordvars2,ordvars3,aliasVars;
+      BackendDAE.Variables ordvars,knvars,exobj,ordvars1,knvars1,ordvars2,aliasVars;
       BackendDAE.EquationArray eqns,remeqns,inieqns,eqns1;
       array<DAE.Constraint> constrs;
       array<DAE.ClassAttributes> clsAttrs;
@@ -1212,12 +1253,10 @@ algorithm
         (ordvars2,knvars1) = BackendVariable.moveVariables(ordvars1,knvars,movedVars);
         // remove changed eqns
         eqns1 = BackendEquation.equationDelete(eqns,meqns);
-        // replace moved vars in vars,knvars,aliasVars,ineqns,remeqns
-        (ordvars3,_) = BackendVariable.traverseBackendDAEVarsWithUpdate(ordvars2,replaceVarTraverser,repl);
         // add alias variables
         aliasVars = BackendDAEUtil.addAliasVariables(BackendDAEUtil.varList(movedAVars),aliasVars);
       then 
-        (BackendDAE.EQSYSTEM(ordvars3,eqns1,NONE(),NONE(),BackendDAE.NO_MATCHING()),BackendDAE.SHARED(knvars1,exobj,aliasVars,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs));
+        (BackendDAE.EQSYSTEM(ordvars2,eqns1,NONE(),NONE(),BackendDAE.NO_MATCHING()),BackendDAE.SHARED(knvars1,exobj,aliasVars,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,einfo,eoc,btp,symjacs));
   end match;
 end removeSimpleEquations2;
 
@@ -1249,22 +1288,20 @@ algorithm
     case (false,_,_) then inDAE;
     case (true,BackendDAE.DAE(systs,BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,constrs,clsAttrs,cache,env,funcTree,BackendDAE.EVENT_INFO(whenClauseLst,zeroCrossingLst),eoc,btp,symjacs)),repl)
       equation
-        ordvarslst = BackendVariable.equationSystemsVarsLst(systs,{});
-        ordvars = BackendDAEUtil.listVar(ordvarslst);
         // replace moved vars in knvars,ineqns,remeqns
         (aliasVars,(_,varlst)) = BackendVariable.traverseBackendDAEVarsWithUpdate(aliasVars,replaceAliasVarTraverser,(repl,{}));
         aliasVars = List.fold(varlst,fixAliasConstBindings,aliasVars);
         (knvars1,_) = BackendVariable.traverseBackendDAEVarsWithUpdate(knvars,replaceVarTraverser,repl);
         (inieqns1,_) = BackendEquation.traverseBackendDAEEqnsWithUpdate(inieqns,replaceEquationTraverser,repl);
         (remeqns1,_) = BackendEquation.traverseBackendDAEEqnsWithUpdate(remeqns,replaceEquationTraverser,repl);
         (whenClauseLst1,_) = BackendDAETransform.traverseBackendDAEExpsWhenClauseLst(whenClauseLst,replaceWhenClauseTraverser,repl);
-        systs1 = removeSimpleEquationsUpdateWrapper(systs,{},repl);
+        systs1 = removeSimpleEquationsShared1(systs,{},repl);
       then 
         BackendDAE.DAE(systs1,BackendDAE.SHARED(knvars1,exobj,aliasVars,inieqns1,remeqns1,constrs,clsAttrs,cache,env,funcTree,BackendDAE.EVENT_INFO(whenClauseLst1,zeroCrossingLst),eoc,btp,symjacs));
   end match;
 end removeSimpleEquationsShared;
 
-protected function removeSimpleEquationsUpdateWrapper
+protected function removeSimpleEquationsShared1
   input BackendDAE.EqSystems inSysts;
   input BackendDAE.EqSystems inSysts1;
   input BackendVarTransform.VariableReplacements repl;
@@ -1284,9 +1321,9 @@ algorithm
         (eqns1,_) = BackendEquation.traverseBackendDAEEqnsWithUpdate(eqns,replaceEquationTraverser,repl);
         systs = BackendDAE.EQSYSTEM(v,eqns1,m,mT,matching)::inSysts1;
         then
-          removeSimpleEquationsUpdateWrapper(rest,systs,repl);
+          removeSimpleEquationsShared1(rest,systs,repl);
     end match;
-end removeSimpleEquationsUpdateWrapper;
+end removeSimpleEquationsShared1;
 
 protected function fixAliasConstBindings
   input BackendDAE.Var iAVar;

diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo
@@ -1447,49 +1447,40 @@ algorithm
       array<Option<Var>> arr;
       Var elt;
       BackendDAE.Value n,size;
-      list<Var> lst;
     case (BackendDAE.VARIABLE_ARRAY(numberOfElements = 0,varOptArr = arr)) then {};
     case (BackendDAE.VARIABLE_ARRAY(numberOfElements = 1,varOptArr = arr))
       equation
         SOME(elt) = arr[1];
       then
         {elt};
     case (BackendDAE.VARIABLE_ARRAY(numberOfElements = n,arrSize = size,varOptArr = arr))
-      equation
-        lst = vararrayList2(arr, 1, n);
       then
-        lst;
+        vararrayList2(arr, n, {});
   end matchcontinue;
 end vararrayList;
 
 protected function vararrayList2
 "function: vararrayList2
   Helper function to vararrayList"
-  input array<Option<Var>> inVarOptionArray1;
-  input Integer inInteger2;
-  input Integer inInteger3;
+  input array<Option<Var>> arr;
+  input Integer pos;
+  input list<Var> inVarLst;
   output list<Var> outVarLst;
 algorithm
   outVarLst:=
-  matchcontinue (inVarOptionArray1,inInteger2,inInteger3)
+  matchcontinue (arr,pos,inVarLst)
     local
       Var v;
-      array<Option<Var>> arr;
-      BackendDAE.Value pos,lastpos,pos_1;
       list<Var> res;
-    case (arr,pos,lastpos)
+    case (_,0,_) then inVarLst;
+    case (_,_,_)
       equation
-        (pos == lastpos) = true;
         SOME(v) = arr[pos];
       then
-        {v};
-    case (arr,pos,lastpos)
-      equation
-        pos_1 = pos + 1;
-        SOME(v) = arr[pos];
-        res = vararrayList2(arr, pos_1, lastpos);
+        vararrayList2(arr,pos-1,v::inVarLst);
+    case (_,_,_)
       then
-        (v :: res);
+        vararrayList2(arr,pos-1,inVarLst);
   end matchcontinue;
 end vararrayList2;
 

diff --git a/Compiler/BackEnd/BackendDump.mo b/Compiler/BackEnd/BackendDump.mo
@@ -133,45 +133,6 @@ algorithm
   end matchcontinue;
 end printCallFunction2StrDIVISION;
 
-public function printTuple
-  input list<tuple<DAE.ComponentRef,Integer>> outTuple;
-algorithm
-  _ := matchcontinue(outTuple)
-    local
-      DAE.ComponentRef currVar;
-      Integer currInd;
-      list<tuple<DAE.ComponentRef,Integer>> restTuple;
-    case ({}) then ();
-    case ((currVar,currInd)::restTuple)
-      equation
-        Debug.fcall(Flags.VAR_INDEX,print, ComponentReference.printComponentRefStr(currVar))  ;
-        Debug.fcall(Flags.VAR_INDEX,print,":   ");
-        Debug.fcall(Flags.VAR_INDEX,print,intString(currInd));
-        Debug.fcall(Flags.VAR_INDEX,print,"\n");
-        printTuple(restTuple);
-      then ();
-    case (_) equation
-      Error.addMessage(Error.INTERNAL_ERROR, {"printTuple() failed"});
-    then fail();
-  end matchcontinue;
-end printTuple;
-
-protected function printPrioTuplesStr
-"Debug function for printing the priorities of state selection to a string"
-  input tuple<DAE.ComponentRef,Integer,Real> prioTuples;
-  output String str;
-algorithm
-  str := matchcontinue(prioTuples)
-    local DAE.ComponentRef cr; Real prio; String s1,s2;
-    case((cr,_,prio))
-      equation
-        s1 = ComponentReference.printComponentRefStr(cr);
-        s2 = realString(prio);
-        str = stringAppendList({"(",s1,", ",s2,")"});
-      then str;
-  end matchcontinue;
-end printPrioTuplesStr;
-
 public function printEquations
   input list<Integer> inIntegerLst;
   input BackendDAE.EqSystem syst;

diff --git a/Compiler/BackEnd/BackendEquation.mo b/Compiler/BackEnd/BackendEquation.mo
@@ -1221,7 +1221,6 @@ algorithm
         BackendDAEUtil.listEquation(eqnlst);
     else        
       equation
-        print("BackendDAE.equationDelete failed\n");
         Debug.fprintln(Flags.FAILTRACE, "- BackendDAE.equationDelete failed");
       then
         fail();        
@@ -1252,6 +1251,36 @@ algorithm
   end matchcontinue;
 end equationDelete1;
 
+public function equationRemove "function: equationRemove
+  author: Frenkel TUD 2012-09
+  Removes the equations from the array on the given possitoin but
+  does not scale down the array size"
+  input BackendDAE.EquationArray inEquationArray;
+  input Integer inPos "1 based index";
+  output BackendDAE.EquationArray outEquationArray;
+algorithm
+  outEquationArray := matchcontinue (inEquationArray,inPos)
+    local
+      Integer numberOfElement,arrSize,size,size1,eqnsize;
+      array<Option<BackendDAE.Equation>> equOptArr;
+      BackendDAE.Equation eqn;
+    case (BackendDAE.EQUATION_ARRAY(size=size,numberOfElement=numberOfElement,arrSize=arrSize,equOptArr=equOptArr),_)
+      equation
+        true = intLe(inPos,numberOfElement);
+        SOME(eqn) = equOptArr[inPos];
+        equOptArr = arrayUpdate(equOptArr,inPos,NONE());
+        eqnsize = equationSize(eqn);
+        size1 = size - eqnsize;
+      then
+        BackendDAE.EQUATION_ARRAY(size1,numberOfElement,arrSize,equOptArr);
+    else        
+      equation
+        Debug.fprintln(Flags.FAILTRACE, "- BackendDAE.equationRemove failed");
+      then
+        fail();        
+  end matchcontinue;
+end equationRemove;
+
 public function equationToScalarResidualForm "function: equationToScalarResidualForm
   author: Frenkel TUD 2012-06
   This function transforms an equation to its scalar residual form.

diff --git a/Compiler/BackEnd/BackendVariable.mo b/Compiler/BackEnd/BackendVariable.mo
@@ -2506,6 +2506,36 @@ algorithm
   end match;
 end addKnVarDAE;
 
+public function addAliasVarDAE
+"function: addAliasVarDAE
+  author: Frenkel TUD 2012-09
+  Add a alias variable to Variables of a BackendDAE.Shared
+  If the variable already exists, the function updates the variable."
+  input BackendDAE.Var inVar;
+  input BackendDAE.Shared shared;
+  output BackendDAE.Shared oshared;
+algorithm
+  oshared := match (inVar,shared)
+    local
+      BackendDAE.Var var;
+      BackendDAE.Variables knvars,exobj,aliasVars;
+      BackendDAE.EquationArray remeqns,inieqns;
+      array<DAE.Constraint> constrs;
+      array<DAE.ClassAttributes> clsAttrs;
+      Env.Cache cache;
+      Env.Env env;      
+      DAE.FunctionTree funcs;
+      BackendDAE.EventInfo einfo;
+      BackendDAE.ExternalObjectClasses eoc;
+      BackendDAE.SymbolicJacobians symjacs;
+      BackendDAE.BackendDAEType btp;
+    case (var,BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,constrs,clsAttrs,cache,env,funcs,einfo,eoc,btp,symjacs))
+      equation
+        aliasVars = addVar(var,aliasVars);
+      then BackendDAE.SHARED(knvars,exobj,aliasVars,inieqns,remeqns,constrs,clsAttrs,cache,env,funcs,einfo,eoc,btp,symjacs);
+  end match;
+end addAliasVarDAE;
+
 public function addVars "function: addVars
   author: PA
   Adds a list of BackendDAE.Var to BackendDAE.Variables"