Skip to content

Commit

Permalink
Merge branch 'master' of https://github.com/OpenModelica/OMCompiler
Browse files Browse the repository at this point in the history 
Conflicts:
	Compiler/Template/CodegenCpp.tpl
  • Loading branch information
@niklwors
niklwors committed Oct 23, 2015
2 parents 5b15507 + 56d9b00 commit 03f5aaf
Show file tree
Hide file tree
Showing 11 changed files with 196 additions and 68 deletions.
63 changes: 63 additions & 0 deletions Compiler/BackEnd/BackendDAEUtil.mo
View file
Expand Up @@ -8371,5 +8371,68 @@ algorithm
end for;
end getStrongComponentEquations;

public function isFuncCallWithNoDerAnnotation"checks if the equation is a function call which has a noDerivative annotation.
Outputs the noDerivative binding crefs as well.
author: waurich TUD 10-2015"
input BackendDAE.Equation eq;
input DAE.FunctionTree functionTree;
output Boolean isFuncCallWithNoDerAnno;
output list<DAE.ComponentRef> noDerivativeInputs;
algorithm
(_,(_,noDerivativeInputs)) := BackendEquation.traverseExpsOfEquation(eq,function Expression.traverseExpTopDown(func=isFuncCallWithNoDerAnnotation1),(functionTree,{}));
//(_,(_,noDerivativeInputs)) := BackendEquation.traverseExpsOfEquation(eq,isFuncCallWithNoDerAnnotation1,(functionTree,{}));
isFuncCallWithNoDerAnno := not listEmpty(noDerivativeInputs);
end isFuncCallWithNoDerAnnotation;

public function isFuncCallWithNoDerAnnotation1 "checks if the exp is a function call which has a noDerivative annotation.
Collects all crefs which dont need a derivative.
author: waurich TUD 10-2015"
input DAE.Exp expIn;
input tuple<DAE.FunctionTree, list<DAE.ComponentRef>> tplIn; // <functionTree, foldList to collect noDer-input-vars>
output DAE.Exp expOut;
output Boolean cont;
output tuple<DAE.FunctionTree, list<DAE.ComponentRef>> tplOut;
algorithm
(expOut, cont, tplOut) := matchcontinue(expIn, tplIn)
local
list<Integer> inputPos;
Absyn.Path path;
DAE.derivativeCond cond;
DAE.FunctionDefinition mapper;
DAE.FunctionTree functionTree;
list<DAE.ComponentRef> crefsIn, noDerivativeInputs;
list<DAE.Exp> expLst;
list<tuple<Integer,DAE.derivativeCond>> conditionRefs;
case(DAE.CALL(path=path,expLst=expLst),(functionTree,crefsIn))
algorithm
(mapper, _) := Differentiate.getFunctionMapper(path, functionTree);
DAE.FUNCTION_DER_MAPPER(conditionRefs=conditionRefs) := mapper;
inputPos := getNoDerivativeInputPosition(conditionRefs,{});
expLst := List.map1(inputPos,List.getIndexFirst,expLst);
noDerivativeInputs := List.flatten(List.map(expLst,Expression.getAllCrefs));
//print("crefs: "+stringDelimitList(List.map(noDerivativeInputs,ComponentReference.crefStr),", ")+"\n");
then (expIn,true,(functionTree,listAppend(noDerivativeInputs,crefsIn)));
else
then (expIn,true,tplIn);
end matchcontinue;
end isFuncCallWithNoDerAnnotation1;

protected function getNoDerivativeInputPosition"ge the position idx for the input-var which does not need a derivation from the NoDerivative annotations"
input list<tuple<Integer,DAE.derivativeCond>> conds;
input list<Integer> IdxsIn;
output list<Integer> IdxsOut;
algorithm
IdxsOut := match(conds, IdxsIn)
local
Integer idx;
list<tuple<Integer,DAE.derivativeCond>> rest;
case({},_)
then IdxsIn;
case((idx,DAE.NO_DERIVATIVE(_))::rest,_)
equation
then getNoDerivativeInputPosition(rest, idx::IdxsIn);
end match;
end getNoDerivativeInputPosition;

annotation(__OpenModelica_Interface="backend");
end BackendDAEUtil;
4 changes: 2 additions & 2 deletions Compiler/BackEnd/BackendDump.mo
View file
Expand Up @@ -2747,7 +2747,7 @@ protected
String mlen_str;
list<BackendDAE.AdjacencyMatrixElementEnhanced> m_1;
algorithm
print("Incidence Matrix (row == equation)\n");
print("Adjacency Matrix Enhanced (row == equation)\n");
print("====================================\n");
mlen := arrayLength(m);
mlen_str := intString(mlen);
Expand All @@ -2767,7 +2767,7 @@ protected
String mlen_str;
list<BackendDAE.AdjacencyMatrixElementEnhanced> m_1;
algorithm
print("Transpose Incidence Matrix (row == var)\n");
print("Transpose Adjacency Matrix Enhanced (row == var)\n");
print("=====================================\n");
mlen := arrayLength(m);
mlen_str := intString(mlen);
Expand Down
2 changes: 1 addition & 1 deletion Compiler/BackEnd/BackendEquation.mo
View file
Expand Up @@ -3130,7 +3130,7 @@ algorithm
b := not isAlgorithm(inEqn);
end isNotAlgorithm;

public function markDifferentiated
public function markDifferentiated"sets differentiated=true in EquationAttributes"
input BackendDAE.Equation inEqn;
output BackendDAE.Equation outEqn;
algorithm
Expand Down
2 changes: 1 addition & 1 deletion Compiler/BackEnd/Differentiate.mo
View file
Expand Up @@ -2773,7 +2773,7 @@ algorithm
end match;
end getlowerOrderDerivative;

protected function getFunctionMapper "Author: Frenkel TUD"
public function getFunctionMapper "Author: Frenkel TUD"
input Absyn.Path fname;
input DAE.FunctionTree functions;
output DAE.FunctionDefinition mapper;
Expand Down
93 changes: 46 additions & 47 deletions Compiler/BackEnd/IndexReduction.mo
View file
Expand Up @@ -267,7 +267,7 @@ algorithm
matchcontinue (unassignedStates,unassignedEqns,alleqns,eqns,actualEqn,inSystem,inShared,inAssignments1,inAssignments2,mark,markarr,inArg,iNotDiffableMSS)
local
list<Integer> eqns1;
BackendDAE.StateOrder so,so1;
BackendDAE.StateOrder so;
BackendDAE.ConstraintEquations orgEqnsLst,orgEqnsLst1;
BackendDAE.EqSystem syst;
BackendDAE.Shared shared;
Expand All @@ -290,17 +290,17 @@ algorithm
eqns1 = List.select1(eqns1,intLe,noofeqns);
//ueqns1 = List.select1(ueqns1,intLe,noofeqns);
if Flags.isSet(Flags.BLT_DUMP) then
print("marked equations: ");
print("Differentiate equations in MSSS("+stringDelimitList(List.map(eqns,intString),",")+"):");
BackendDump.debuglst(eqns1,intString," ","\n");
end if;
// eqnstr = bcallret2(Flags.isSet(Flags.BLT_DUMP), BackendDump.dumpMarkedEqns, inSystem, ueqns1,"");
// fcall(Flags.BLT_DUMP, print, eqnstr);
// remove allready diffed equations
//_ = List.fold1r(ueqns1,arrayUpdate,mark,markarr);
(eqnstpl, shared) = differentiateEqnsLst(eqns1,vars,eqnsarray,inShared,{});
(syst,shared,ass1,ass2,so1,orgEqnsLst1,mapEqnIncRow,mapIncRowEqn,notDiffableMSS) = differentiateEqns(eqnstpl,eqns1,unassignedStates,unassignedEqns,inSystem, shared,inAssignments1,inAssignments2,so,orgEqnsLst,mapEqnIncRow,mapIncRowEqn,iNotDiffableMSS);
(syst,shared,ass1,ass2,orgEqnsLst1,mapEqnIncRow,mapIncRowEqn,notDiffableMSS) = differentiateEqns(eqnstpl,eqns1,unassignedStates,unassignedEqns,inSystem, shared,inAssignments1,inAssignments2,orgEqnsLst,mapEqnIncRow,mapIncRowEqn,iNotDiffableMSS);
then
(syst,shared,ass1,ass2,(so1,orgEqnsLst1,mapEqnIncRow,mapIncRowEqn,noofeqns),notDiffableMSS);
(syst,shared,ass1,ass2,(so,orgEqnsLst1,mapEqnIncRow,mapIncRowEqn,noofeqns),notDiffableMSS);
else
equation
Error.addMessage(Error.INTERNAL_ERROR, {"- IndexReduction.pantelidesIndexReductionMSS failed! Use +d=bltdump to get more information."});
Expand Down Expand Up @@ -572,7 +572,6 @@ protected function differentiateEqns
input BackendDAE.Shared inShared;
input array<Integer> inAss1;
input array<Integer> inAss2;
input BackendDAE.StateOrder inStateOrd;
input BackendDAE.ConstraintEquations inOrgEqnsLst;
input array<list<Integer>> imapEqnIncRow;
input array<Integer> imapIncRowEqn;
Expand All @@ -581,18 +580,17 @@ protected function differentiateEqns
output BackendDAE.Shared oshared;
output array<Integer> outAss1;
output array<Integer> outAss2;
output BackendDAE.StateOrder outStateOrd;
output BackendDAE.ConstraintEquations outOrgEqnsLst;
output array<list<Integer>> omapEqnIncRow;
output array<Integer> omapIncRowEqn;
output list<tuple<list<Integer>,list<Integer>,list<Integer>>> oNotDiffableMSS;
algorithm
(osyst,oshared,outAss1,outAss2,outStateOrd,outOrgEqnsLst,omapEqnIncRow,omapIncRowEqn,oNotDiffableMSS) :=
(osyst,oshared,outAss1,outAss2,outOrgEqnsLst,omapEqnIncRow,omapIncRowEqn,oNotDiffableMSS) :=
match (inEqnsTpl, inSystem)
local
Integer eqnss,eqnss1;
Integer numEqs,numEqs1;
BackendDAE.EquationArray eqns_1,eqns;
list<Integer> ilst,eqnslst,eqnslst1,ilst1;
list<Integer> changedVars,eqnslst,eqnslst1,assEqs;
BackendDAE.Variables v,v1;
BackendDAE.StateOrder so;
BackendDAE.ConstraintEquations orgEqnsLst;
Expand All @@ -608,21 +606,21 @@ algorithm
// all equations are differentiated
case (_::_, syst as BackendDAE.EQSYSTEM(orderedVars=v, orderedEqs=eqns, m=SOME(m), mT=SOME(mt)))
equation
eqnss = BackendDAEUtil.equationArraySize(eqns);
(v1,eqns_1,so,ilst,orgEqnsLst) = replaceDifferentiatedEqns(inEqnsTpl,v,eqns,inStateOrd,mt,imapIncRowEqn,{},inOrgEqnsLst);
eqnss1 = BackendDAEUtil.equationArraySize(eqns_1);
eqnslst = if intGt(eqnss1,eqnss) then List.intRange2(eqnss+1,eqnss1) else {};
// set equation assigned variable assignemts zero
ilst1 = List.map1r(ilst,arrayGet,inAss1);
ilst1 = List.select1(ilst1,intGt,0);
ass2 = List.fold1r(ilst1,arrayUpdate,-1,inAss2);
// set changed variables assignments to zero
ass1 = List.fold1r(ilst,arrayUpdate,-1,inAss1);
eqnslst1 = collectVarEqns(ilst,{},mt,arrayLength(mt),arrayLength(m));
numEqs = BackendDAEUtil.equationArraySize(eqns);
(v1,eqns_1,changedVars,orgEqnsLst) = replaceDifferentiatedEqns(inEqnsTpl,v,eqns,mt,imapIncRowEqn,{},inOrgEqnsLst);
numEqs1 = BackendDAEUtil.equationArraySize(eqns_1);
eqnslst = if intGt(numEqs1,numEqs) then List.intRange2(numEqs+1,numEqs1) else {};
// set the assignments for the changed vars and for the assigned equations to -1
assEqs = List.map1r(changedVars,arrayGet,inAss1);
assEqs = List.select1(assEqs,intGt,0);
ass2 = List.fold1r(assEqs,arrayUpdate,-1,inAss2);
ass1 = List.fold1r(changedVars,arrayUpdate,-1,inAss1);
//get adjacent equations for the changed vars
eqnslst1 = collectVarEqns(changedVars,{},mt,arrayLength(mt),arrayLength(m));
syst.orderedVars = v1;
syst.orderedEqs = eqns_1;
eqnslst1 = List.map1r(eqnslst1,arrayGet,imapIncRowEqn);
eqnslst1 = List.uniqueIntN(listAppend(inEqns,eqnslst1),eqnss1);
eqnslst1 = List.uniqueIntN(listAppend(inEqns,eqnslst1),numEqs1);
eqnslst1 = listAppend(eqnslst1,eqnslst);
if Flags.isSet(Flags.BLT_DUMP) then
print("Update Incidence Matrix: ");
Expand All @@ -632,11 +630,11 @@ algorithm
(syst,mapEqnIncRow,mapIncRowEqn) =
BackendDAEUtil.updateIncidenceMatrixScalar(syst, BackendDAE.SOLVABLE(), SOME(funcs), eqnslst1, imapEqnIncRow, imapIncRowEqn);
then
(syst,inShared,ass1,ass2,so,orgEqnsLst,mapEqnIncRow,mapIncRowEqn,iNotDiffableMSS);
(syst,inShared,ass1,ass2,orgEqnsLst,mapEqnIncRow,mapIncRowEqn,iNotDiffableMSS);
// not all equations are differentiated
case ({},_)
then
(inSystem,inShared,inAss1,inAss2,inStateOrd,inOrgEqnsLst,imapEqnIncRow,imapIncRowEqn,(inEqns,unassignedStates,unassignedEqns)::iNotDiffableMSS);
(inSystem,inShared,inAss1,inAss2,inOrgEqnsLst,imapEqnIncRow,imapIncRowEqn,(inEqns,unassignedStates,unassignedEqns)::iNotDiffableMSS);
end match;
end differentiateEqns;

Expand Down Expand Up @@ -706,7 +704,7 @@ protected function differentiateEqnsLst
input BackendDAE.Variables vars;
input BackendDAE.EquationArray eqns;
input BackendDAE.Shared inShared;
input list<tuple<Integer,Option<BackendDAE.Equation>,BackendDAE.Equation>> inEqnTpl;
input list<tuple<Integer,Option<BackendDAE.Equation>,BackendDAE.Equation>> inEqnTpl; //<originalIdx, SOME<derivedEq>, OrigEq>
output list<tuple<Integer,Option<BackendDAE.Equation>,BackendDAE.Equation>> outEqnTpl;
output BackendDAE.Shared oshared;
algorithm
Expand All @@ -731,9 +729,9 @@ algorithm
case (e::es,_,_,_,_)
equation
eqn = BackendEquation.equationNth1(eqns, e);
//if Flags.isSet(Flags.BLT_DUMP) then print("differentiate equation " + intString(e) + " " + BackendDump.equationString(eqn) + "\n"); end if;
//if Flags.isSet(Flags.BLT_DUMP) then print("differentiate equation " + intString(e) + " " + BackendDump.equationString(eqn) + "\n"); end if;
(eqn_1, shared) = Differentiate.differentiateEquationTime(eqn, vars, inShared);
//if Flags.isSet(Flags.BLT_DUMP) then print("differentiated equation " + intString(e) + " " + BackendDump.equationString(eqn_1) + "\n"); end if;
//if Flags.isSet(Flags.BLT_DUMP) then print("differentiated equation " + intString(e) + " " + BackendDump.equationString(eqn_1) + "\n"); end if;
eqn = BackendEquation.markDifferentiated(eqn);
(eqntpl, shared) = differentiateEqnsLst(es,vars,eqns,shared,(e,SOME(eqn_1),eqn)::inEqnTpl);
then
Expand All @@ -744,22 +742,20 @@ end differentiateEqnsLst;

protected function replaceDifferentiatedEqns
"author: Frenkel TUD 2012-11
replace the original equations with the derived"
input list<tuple<Integer, Option<BackendDAE.Equation>, BackendDAE.Equation>> inEqnTplLst;
replace the original equations with the derived, updated var-types, stores all former equations in inOrgEqnsLst"
input list<tuple<Integer, Option<BackendDAE.Equation>, BackendDAE.Equation>> inEqnTplLst; //<origIdx, SOME<derivedEq>, original Eq>
input BackendDAE.Variables vars;
input BackendDAE.EquationArray eqns;
input BackendDAE.StateOrder inStateOrd;
input BackendDAE.IncidenceMatrix mt;
input array<Integer> imapIncRowEqn;
input list<Integer> inChangedVars;
input BackendDAE.ConstraintEquations inOrgEqnsLst;
output BackendDAE.Variables outVars;
output BackendDAE.EquationArray outEqns;
output BackendDAE.StateOrder outStateOrd;
output list<Integer> outChangedVars;
output BackendDAE.ConstraintEquations outOrgEqnsLst;
algorithm
(outVars, outEqns, outStateOrd, outChangedVars, outOrgEqnsLst) := matchcontinue (inEqnTplLst)
(outVars, outEqns, outChangedVars, outOrgEqnsLst) := matchcontinue (inEqnTplLst)
local
list<tuple<Integer, Option<BackendDAE.Equation>,BackendDAE.Equation>> rest;
Integer e;
Expand All @@ -768,26 +764,29 @@ algorithm
BackendDAE.EquationArray eqns1;
BackendDAE.Variables vars1;
BackendDAE.ConstraintEquations orgEqnsLst;

case {}
then (vars, eqns, inStateOrd, inChangedVars, inOrgEqnsLst);
then (vars, eqns, inChangedVars, inOrgEqnsLst);

case (e, SOME(eqn_1), eqn)::rest equation
// replace der-calls with the derivatives
(eqn_1, _) = BackendEquation.traverseExpsOfEquation(eqn_1, replaceStateOrderExp, vars);
(eqn_1, (_, (vars1, eqns1, _, changedVars, _, _, _))) = BackendEquation.traverseExpsOfEquation(eqn_1, Expression.traverseSubexpressionsHelper, (changeDerVariablesToStatesFinder, (vars, eqns, inStateOrd, inChangedVars, e, imapIncRowEqn, mt)));
// change the variable types (algebraic -> state, 1.der -> 2.der, ...)
(eqn_1, (_, (vars1, eqns1, changedVars, _, _, _))) = BackendEquation.traverseExpsOfEquation(eqn_1, Expression.traverseSubexpressionsHelper, (changeDerVariablesToStatesFinder, (vars, eqns, inChangedVars, e, imapIncRowEqn, mt)));
if Flags.isSet(Flags.BLT_DUMP) then
print("replaced differentiated eqs:");
debugdifferentiateEqns((eqn, eqn_1));
end if;
eqns1 = BackendEquation.setAtIndex(eqns1, e, eqn_1);
//collect original equations
orgEqnsLst = addOrgEqn(inOrgEqnsLst, e, eqn);
(outVars, outEqns, outStateOrd, outChangedVars, outOrgEqnsLst) = replaceDifferentiatedEqns(rest, vars1, eqns1, inStateOrd, mt, imapIncRowEqn, changedVars, orgEqnsLst);
then (outVars, outEqns, outStateOrd, outChangedVars, outOrgEqnsLst);
(outVars, outEqns, outChangedVars, outOrgEqnsLst) = replaceDifferentiatedEqns(rest, vars1, eqns1, mt, imapIncRowEqn, changedVars, orgEqnsLst);
then (outVars, outEqns, outChangedVars, outOrgEqnsLst);

case (_, NONE(), _)::rest equation
//orgEqnsLst = BackendDAETransform.addOrgEqn(inOrgEqnsLst, e, eqn);
orgEqnsLst = inOrgEqnsLst;
(outVars, outEqns, outStateOrd, outChangedVars, outOrgEqnsLst) = replaceDifferentiatedEqns(rest, vars, eqns, inStateOrd, mt, imapIncRowEqn, inChangedVars, orgEqnsLst);
then (outVars, outEqns, outStateOrd, outChangedVars, outOrgEqnsLst);
(outVars, outEqns, outChangedVars, outOrgEqnsLst) = replaceDifferentiatedEqns(rest, vars, eqns, mt, imapIncRowEqn, inChangedVars, orgEqnsLst);
then (outVars, outEqns, outChangedVars, outOrgEqnsLst);

else equation
Error.addMessage(Error.INTERNAL_ERROR, {"IndexReduction.replaceDifferentiatedEqns failed!"});
Expand Down Expand Up @@ -819,6 +818,7 @@ algorithm
DAE.ComponentRef dcr,cr;
DAE.CallAttributes attr;
Integer index;
//if der(x) = y, replace all der(x) with y
case (DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),vars)
equation
({BackendDAE.VAR(varKind=BackendDAE.STATE(derName=SOME(dcr)))},_) = BackendVariable.getVar(cr,vars);
Expand Down Expand Up @@ -3939,9 +3939,9 @@ protected function changeDerVariablesToStatesFinder
"author: Frenkel TUD 2011-05
helper for changeDerVariablestoStates"
input DAE.Exp inExp;
input tuple<BackendDAE.Variables,BackendDAE.EquationArray,BackendDAE.StateOrder,list<Integer>,Integer,array<Integer>,BackendDAE.IncidenceMatrix> inTpl;
input tuple<BackendDAE.Variables,BackendDAE.EquationArray,list<Integer>,Integer,array<Integer>,BackendDAE.IncidenceMatrix> inTpl;
output DAE.Exp outExp;
output tuple<BackendDAE.Variables,BackendDAE.EquationArray,BackendDAE.StateOrder,list<Integer>,Integer,array<Integer>,BackendDAE.IncidenceMatrixT> outTpl;
output tuple<BackendDAE.Variables,BackendDAE.EquationArray,list<Integer>,Integer,array<Integer>,BackendDAE.IncidenceMatrixT> outTpl;
algorithm
(outExp,outTpl) := match (inExp,inTpl)
local
Expand All @@ -3953,29 +3953,28 @@ algorithm
array<Integer> mapIncRowEqn;
BackendDAE.IncidenceMatrixT mt;
BackendDAE.EquationArray eqns;
BackendDAE.StateOrder so;
Integer index,eindx;
/* der(var), change algebraic to states */
case (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),(vars,eqns,so,ilst,eindx,mapIncRowEqn,mt))
case (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),(vars,eqns,ilst,eindx,mapIncRowEqn,mt))
equation
(varlst,changedVars) = BackendVariable.getVar(cr,vars);
(vars,ilst) = algebraicState(varlst,changedVars,vars,ilst);
then
(e, (vars,eqns,so,ilst,eindx,mapIncRowEqn,mt));
(e, (vars,eqns,ilst,eindx,mapIncRowEqn,mt));
/* der(der(var)), set differentiation counter = 2 */
case (DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {e as DAE.CREF(componentRef = cr)})}),(vars,eqns,so,ilst,eindx,mapIncRowEqn,mt))
case (DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {e as DAE.CREF(componentRef = cr)})}),(vars,eqns,ilst,eindx,mapIncRowEqn,mt))
equation
(varlst,changedVars) = BackendVariable.getVar(cr,vars);
(vars,ilst) = increaseDifferentiation(varlst,changedVars,2,vars,ilst);
then
(DAE.CALL(Absyn.IDENT("der"),{e,DAE.ICONST(2)},DAE.callAttrBuiltinReal), (vars,eqns,so,ilst,eindx,mapIncRowEqn,mt));
(DAE.CALL(Absyn.IDENT("der"),{e,DAE.ICONST(2)},DAE.callAttrBuiltinReal), (vars,eqns,ilst,eindx,mapIncRowEqn,mt));
/* der(var,index), set differentiation counter = index+1 */
case (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr),DAE.ICONST(index)}),(vars,eqns,so,ilst,eindx,mapIncRowEqn,mt))
case (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr),DAE.ICONST(index)}),(vars,eqns,ilst,eindx,mapIncRowEqn,mt))
equation
(varlst,changedVars) = BackendVariable.getVar(cr,vars);
(vars,ilst) = increaseDifferentiation(varlst,changedVars,index,vars,ilst);
then
(e, (vars,eqns,so,ilst,eindx,mapIncRowEqn,mt));
(e, (vars,eqns,ilst,eindx,mapIncRowEqn,mt));
else (inExp,inTpl);
end match;
end changeDerVariablesToStatesFinder;
Expand Down

0 comments on commit 03f5aaf

Please sign in to comment.