Skip to content
This repository was archived by the owner on May 18, 2019. It is now read-only.

Commit 74a526d

Browse files
hkielOpenModelica-Hudson
hkiel
authored and
OpenModelica-Hudson
committed
some minor optimizations
Belonging to [master]: - #2358
1 parent 368ac8c commit 74a526d

File tree

5 files changed

+59
-61
lines changed

5 files changed

+59
-61
lines changed

‎Compiler/BackEnd/BackendDAEOptimize.mo‎

Lines changed: 17 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1229,7 +1229,7 @@ end checkUnusedParameterExp;
12291229
// =============================================================================
12301230
public function removeUnusedVariables
12311231
"author: Frenkel TUD 2011-04
1232-
This function remove unused variables
1232+
This function removes unused variables
12331233
from BackendDAE.BackendDAE to get speed up for compilation of
12341234
target code"
12351235
input BackendDAE.BackendDAE inDlow;
@@ -1240,16 +1240,17 @@ algorithm
12401240
BackendDAE.Variables globalKnownVars, globalKnownVars1;
12411241
BackendDAE.EqSystems eqs;
12421242
BackendDAE.Shared shared;
1243+
tuple<BackendDAE.Variables,BackendDAE.Variables> tpl;
12431244

12441245
case BackendDAE.DAE(eqs, shared)
12451246
algorithm
12461247
globalKnownVars1 := BackendVariable.emptyVars();
12471248
globalKnownVars := shared.globalKnownVars;
1248-
((_, globalKnownVars1)) := List.fold1(eqs,BackendDAEUtil.traverseBackendDAEExpsEqSystem, checkUnusedVariables, (globalKnownVars,globalKnownVars1));
1249-
((_, globalKnownVars1)) := BackendDAEUtil.traverseBackendDAEExpsVars(globalKnownVars, checkUnusedVariables, (globalKnownVars,globalKnownVars1));
1250-
((_, globalKnownVars1)) := BackendDAEUtil.traverseBackendDAEExpsVars(shared.aliasVars, checkUnusedVariables, (globalKnownVars,globalKnownVars1));
1251-
((_, globalKnownVars1)) := BackendDAEUtil.traverseBackendDAEExpsEqns(shared.removedEqs, checkUnusedVariables, (globalKnownVars,globalKnownVars1));
1252-
((_, globalKnownVars1)) := BackendDAEUtil.traverseBackendDAEExpsEqns(shared.initialEqs, checkUnusedVariables, (globalKnownVars,globalKnownVars1));
1249+
tpl := List.fold1(eqs,BackendDAEUtil.traverseBackendDAEExpsEqSystem, checkUnusedVariables, (globalKnownVars, globalKnownVars1));
1250+
tpl := BackendDAEUtil.traverseBackendDAEExpsVars(globalKnownVars, checkUnusedVariables, tpl);
1251+
tpl := BackendDAEUtil.traverseBackendDAEExpsVars(shared.aliasVars, checkUnusedVariables, tpl);
1252+
tpl := BackendDAEUtil.traverseBackendDAEExpsEqns(shared.removedEqs, checkUnusedVariables, tpl);
1253+
((_, globalKnownVars1)) := BackendDAEUtil.traverseBackendDAEExpsEqns(shared.initialEqs, checkUnusedVariables, tpl);
12531254
shared.globalKnownVars := globalKnownVars1;
12541255
then
12551256
BackendDAE.DAE(eqs, shared);
@@ -1265,11 +1266,11 @@ algorithm
12651266
(outExp,outTpl) := matchcontinue (inExp,inTpl)
12661267
local
12671268
DAE.Exp exp;
1268-
BackendDAE.Variables vars,vars1;
1269-
case (exp,(vars,_))
1269+
tuple<BackendDAE.Variables,BackendDAE.Variables> tpl;
1270+
case (exp,_)
12701271
equation
1271-
(_,(_,vars1)) = Expression.traverseExpBottomUp(exp,checkUnusedVariablesExp,inTpl);
1272-
then (exp,(vars,vars1));
1272+
(_,tpl) = Expression.traverseExpBottomUp(exp,checkUnusedVariablesExp,inTpl);
1273+
then (exp,tpl);
12731274
else (inExp,inTpl);
12741275
end matchcontinue;
12751276
end checkUnusedVariables;
@@ -2014,24 +2015,20 @@ algorithm
20142015
(_,tpl) = Expression.traverseExpList(expLst,function countOperationsExp(shared=shared),inTuple);
20152016
then (e, tpl);
20162017

2017-
case (e as DAE.CALL(path=Absyn.IDENT(name=opName)),_,(i1,i2,i3,i4,i5,i6,i7,i8)) equation
2018-
true = stringEq(opName,"sin") or stringEq(opName,"cos") or stringEq(opName,"tan");
2018+
case (e as DAE.CALL(path=Absyn.IDENT(name=opName)),_,(i1,i2,i3,i4,i5,i6,i7,i8))
2019+
guard stringEq(opName,"sin") or stringEq(opName,"cos") or stringEq(opName,"tan")
20192020
then (e, (i1,i2,i3,i4+1,i5,i6,i7,i8));
20202021

2021-
case (e as DAE.CALL(path=Absyn.IDENT(name=opName)),_,(i1,i2,i3,i4,i5,i6,i7,i8)) equation
2022-
true = stringEq(opName,"der");
2022+
case (e as DAE.CALL(path=Absyn.IDENT(name="der")),_,(i1,i2,i3,i4,i5,i6,i7,i8))
20232023
then (e, (i1,i2,i3,i4,i5,i6,i7,i8));
20242024

2025-
case (e as DAE.CALL(path=Absyn.IDENT(name=opName)),_,(i1,i2,i3,i4,i5,i6,i7,i8)) equation
2026-
true = stringEq(opName,"exp");
2025+
case (e as DAE.CALL(path=Absyn.IDENT(name="exp")),_,(i1,i2,i3,i4,i5,i6,i7,i8))
20272026
then (e, (i1,i2,i3,i4,i5,i6,i7+1,i8));
20282027

2029-
case (e as DAE.CALL(path=Absyn.IDENT(name=opName)),_,(i1,i2,i3,i4,i5,i6,i7,i8)) equation
2030-
true = stringEq(opName,"pre");
2028+
case (e as DAE.CALL(path=Absyn.IDENT(name="pre")),_,(i1,i2,i3,i4,i5,i6,i7,i8))
20312029
then (e, (i1,i2,i3,i4,i5,i6,i7,i8+1));
20322030

2033-
case (e as DAE.CALL(path=Absyn.IDENT(name=opName)),_,(i1,i2,i3,i4,i5,i6,i7,i8)) equation
2034-
true = stringEq(opName,"previous");
2031+
case (e as DAE.CALL(path=Absyn.IDENT(name="previous")),_,(i1,i2,i3,i4,i5,i6,i7,i8))
20352032
then (e, (i1,i2,i3,i4,i5,i6,i7,i8+1));
20362033

20372034
case (e as DAE.CALL(path=path),_,_) equation

‎Compiler/BackEnd/BackendEquation.mo‎

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -2448,7 +2448,7 @@ algorithm
24482448
local
24492449
DAE.ComponentRef cr1, cr2;
24502450
DAE.Exp e1, e2;
2451-
DAE.Type ty;
2451+
DAE.Operator op;
24522452
list<DAE.Exp> elst1, elst2;
24532453
list<list<DAE.Exp>> elstlst1, elstlst2;
24542454
list<DAE.Var> varLst1, varLst2;
@@ -2459,18 +2459,18 @@ algorithm
24592459
then (cr1, cr2, lhs, rhs, false)::inTpls;
24602460

24612461
// a = -b;
2462-
case (DAE.CREF(componentRef = cr1), DAE.UNARY(DAE.UMINUS(ty), DAE.CREF(componentRef = cr2)), _)
2463-
then (cr1, cr2, DAE.UNARY(DAE.UMINUS(ty), lhs), rhs, true)::inTpls;
2462+
case (DAE.CREF(componentRef = cr1), DAE.UNARY(op as DAE.UMINUS(_), DAE.CREF(componentRef = cr2)), _)
2463+
then (cr1, cr2, DAE.UNARY(op, lhs), rhs, true)::inTpls;
24642464

2465-
case (DAE.CREF(componentRef = cr1), DAE.UNARY(DAE.UMINUS_ARR(ty), DAE.CREF(componentRef = cr2)), _)
2466-
then (cr1, cr2, DAE.UNARY(DAE.UMINUS_ARR(ty), lhs), rhs, true)::inTpls;
2465+
case (DAE.CREF(componentRef = cr1), DAE.UNARY(op as DAE.UMINUS_ARR(_), DAE.CREF(componentRef = cr2)), _)
2466+
then (cr1, cr2, DAE.UNARY(op, lhs), rhs, true)::inTpls;
24672467

24682468
// -a = b;
2469-
case (DAE.UNARY(DAE.UMINUS(ty), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _)
2470-
then (cr1, cr2, lhs, DAE.UNARY(DAE.UMINUS(ty), rhs), true)::inTpls;
2469+
case (DAE.UNARY(op as DAE.UMINUS(_), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _)
2470+
then (cr1, cr2, lhs, DAE.UNARY(op, rhs), true)::inTpls;
24712471

2472-
case (DAE.UNARY(DAE.UMINUS_ARR(ty), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _)
2473-
then (cr1, cr2, lhs, DAE.UNARY(DAE.UMINUS_ARR(ty), rhs), true)::inTpls;
2472+
case (DAE.UNARY(op as DAE.UMINUS_ARR(_), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _)
2473+
then (cr1, cr2, lhs, DAE.UNARY(op, rhs), true)::inTpls;
24742474

24752475
// -a = -b;
24762476
case (DAE.UNARY(DAE.UMINUS(_), e1 as DAE.CREF(componentRef = cr1)), DAE.UNARY(DAE.UMINUS(_), e2 as DAE.CREF(componentRef = cr2)), _)
@@ -2480,12 +2480,12 @@ algorithm
24802480
then (cr1, cr2, e1, e2, false)::inTpls;
24812481

24822482
// a = not b;
2483-
case (DAE.CREF(componentRef = cr1), DAE.LUNARY(DAE.NOT(ty), DAE.CREF(componentRef = cr2)), _)
2484-
then (cr1, cr2, DAE.LUNARY(DAE.NOT(ty), lhs), rhs, true)::inTpls;
2483+
case (DAE.CREF(componentRef = cr1), DAE.LUNARY(op as DAE.NOT(_), DAE.CREF(componentRef = cr2)), _)
2484+
then (cr1, cr2, DAE.LUNARY(op, lhs), rhs, true)::inTpls;
24852485

24862486
// not a = b;
2487-
case (DAE.LUNARY(DAE.NOT(ty), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _)
2488-
then (cr1, cr2, lhs, DAE.LUNARY(DAE.NOT(ty), rhs), true)::inTpls;
2487+
case (DAE.LUNARY(op as DAE.NOT(_), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _)
2488+
then (cr1, cr2, lhs, DAE.LUNARY(op, rhs), true)::inTpls;
24892489

24902490
// not a = not b;
24912491
case (DAE.LUNARY(DAE.NOT(_), e1 as DAE.CREF(componentRef = cr1)), DAE.LUNARY(DAE.NOT(_), e2 as DAE.CREF(componentRef = cr2)), _)
@@ -2543,20 +2543,19 @@ algorithm
25432543
//case (DAE.LUNARY(DAE.NOT(_), DAE.ARRAY(array = elst1, ty=ty)), DAE.LUNARY(DAE.NOT(_), e2 as DAE.CREF(componentRef = cr2)), _)
25442544

25452545
// a = Record(b1, b2, b3, ..)
2546-
case (DAE.CREF(componentRef = cr1), DAE.CALL(path=pathb, expLst=elst2, attr=DAE.CALL_ATTR(ty=DAE.T_COMPLEX(varLst=varLst2, complexClassType=ClassInf.RECORD(pathb1)))), _) equation
2547-
true = Absyn.pathEqual(pathb, pathb1);
2546+
case (DAE.CREF(componentRef = cr1), DAE.CALL(path=pathb, expLst=elst2, attr=DAE.CALL_ATTR(ty=DAE.T_COMPLEX(varLst=varLst2, complexClassType=ClassInf.RECORD(pathb1)))), _)
2547+
guard Absyn.pathEqual(pathb, pathb1)
25482548
then aliasRecord(cr1, varLst2, elst2, inTpls);
25492549

25502550
// Record(a1, a2, a3, ..) = b
2551-
case (DAE.CALL(path=patha, expLst=elst1, attr=DAE.CALL_ATTR(ty=DAE.T_COMPLEX(varLst=varLst1, complexClassType=ClassInf.RECORD(patha1)))), DAE.CREF(componentRef = cr2), _) equation
2552-
true = Absyn.pathEqual(patha, patha1);
2551+
case (DAE.CALL(path=patha, expLst=elst1, attr=DAE.CALL_ATTR(ty=DAE.T_COMPLEX(varLst=varLst1, complexClassType=ClassInf.RECORD(patha1)))), DAE.CREF(componentRef = cr2), _)
2552+
guard Absyn.pathEqual(patha, patha1)
25532553
then aliasRecord(cr2, varLst1, elst1, inTpls);
25542554

25552555
// Record(a1, a2, a3, ..) = Record(b1, b2, b3, ..)
25562556
case (DAE.CALL(path=patha, expLst=elst1, attr=DAE.CALL_ATTR(ty=DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(patha1)))),
2557-
DAE.CALL(path=pathb, expLst=elst2, attr=DAE.CALL_ATTR(ty=DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(pathb1)))), _) equation
2558-
true = Absyn.pathEqual(patha, patha1);
2559-
true = Absyn.pathEqual(pathb, pathb1);
2557+
DAE.CALL(path=pathb, expLst=elst2, attr=DAE.CALL_ATTR(ty=DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(pathb1)))), _)
2558+
guard Absyn.pathEqual(patha, patha1) and Absyn.pathEqual(pathb, pathb1)
25602559
then List.threadFold(elst1, elst2, aliasEquation1, inTpls);
25612560

25622561
// matchcontinue part
@@ -2620,6 +2619,7 @@ algorithm
26202619
DAE.ComponentRef cr1, cr2;
26212620
DAE.Exp e1, e2;
26222621
DAE.Type ty, ty1;
2622+
DAE.Operator op;
26232623
list<DAE.Exp> elst;
26242624
list<DAE.Var> vlst;
26252625
DAE.Ident ident;
@@ -2634,20 +2634,20 @@ algorithm
26342634
then aliasRecord(cr, vlst, elst, (cr1, cr2, e1, e2, false)::inTpls);
26352635

26362636
// a = -b
2637-
case (_, DAE.TYPES_VAR(name=ident, ty=ty)::vlst, (e2 as DAE.UNARY(DAE.UMINUS(ty1), DAE.CREF(componentRef = cr2)))::elst, _) equation
2637+
case (_, DAE.TYPES_VAR(name=ident, ty=ty)::vlst, (e2 as DAE.UNARY(op as DAE.UMINUS(ty1), DAE.CREF(componentRef = cr2)))::elst, _) equation
26382638
cr1 = ComponentReference.crefPrependIdent(cr, ident, {}, ty);
2639-
e1 = DAE.UNARY(DAE.UMINUS(ty1), DAE.CREF(cr1, ty));
2639+
e1 = DAE.UNARY(op, DAE.CREF(cr1, ty));
26402640
then aliasRecord(cr, vlst, elst, (cr1, cr2, e1, e2, true)::inTpls);
26412641

2642-
case (_, DAE.TYPES_VAR(name=ident, ty=ty)::vlst, (e2 as DAE.UNARY(DAE.UMINUS_ARR(ty1), DAE.CREF(componentRef = cr2)))::elst, _) equation
2642+
case (_, DAE.TYPES_VAR(name=ident, ty=ty)::vlst, (e2 as DAE.UNARY(op as DAE.UMINUS_ARR(ty1), DAE.CREF(componentRef = cr2)))::elst, _) equation
26432643
cr1 = ComponentReference.crefPrependIdent(cr, ident, {}, ty);
2644-
e1 = DAE.UNARY(DAE.UMINUS_ARR(ty1), DAE.CREF(cr1, ty));
2644+
e1 = DAE.UNARY(op, DAE.CREF(cr1, ty));
26452645
then aliasRecord(cr, vlst, elst, (cr1, cr2, e1, e2, true)::inTpls);
26462646

26472647
// a = not b
2648-
case (_, DAE.TYPES_VAR(name=ident, ty=ty)::vlst, (e2 as DAE.LUNARY(DAE.NOT(ty1), DAE.CREF(componentRef = cr2)))::elst, _) equation
2648+
case (_, DAE.TYPES_VAR(name=ident, ty=ty)::vlst, (e2 as DAE.LUNARY(op as DAE.NOT(ty1), DAE.CREF(componentRef = cr2)))::elst, _) equation
26492649
cr1 = ComponentReference.crefPrependIdent(cr, ident, {}, ty);
2650-
e1 = DAE.LUNARY(DAE.NOT(ty1), DAE.CREF(cr1, ty));
2650+
e1 = DAE.LUNARY(op, DAE.CREF(cr1, ty));
26512651
then aliasRecord(cr, vlst, elst, (cr1, cr2, e1, e2, true)::inTpls);
26522652

26532653
// a = {b1, b2, b3}

‎Compiler/BackEnd/Differentiate.mo‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2839,17 +2839,17 @@ algorithm
28392839

28402840
// check conditions, order=1
28412841
case (_,DAE.FUNCTION_DER_MAPPER(derivativeFunction=inDFuncName,derivativeOrder=derivativeOrder,conditionRefs=cr),DAE.T_FUNCTION(funcArg=funcArg),_,_)
2842+
guard intEq(1,derivativeOrder)
28422843
equation
2843-
true = intEq(1,derivativeOrder);
28442844
tplst = List.map(funcArg,Types.funcArgType);
28452845
ba = Array.mapList(tplst, diffableTypes);
28462846
bl = checkDerFunctionConds(ba,cr,expl,inDiffArgs);
28472847
then
28482848
(inDFuncName,bl);
28492849
// check conditions, order>1
28502850
case (_,DAE.FUNCTION_DER_MAPPER(derivativeFunction=inDFuncName,derivativeOrder=derivativeOrder,conditionRefs=cr),tp,_,(_,_,_,functions))
2851+
guard not intEq(1,derivativeOrder)
28512852
equation
2852-
failure(true = intEq(1,derivativeOrder));
28532853
// get n-1 func name
28542854
fname = getlowerOrderDerivative(inFuncName,functions);
28552855
// get mapper

‎Compiler/BackEnd/RemoveSimpleEquations.mo‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1025,24 +1025,25 @@ algorithm
10251025
DAE.Type ty;
10261026
list<DAE.Exp> elst1, elst2;
10271027
list<list<DAE.Exp>> elstlst1, elstlst2;
1028+
DAE.Operator op;
10281029

10291030
// a = b;
10301031
case (DAE.CREF(componentRef = cr1), DAE.CREF(componentRef = cr2), _, _, _)
10311032
then addSimpleEquationAcausal(cr1, lhs, false, cr2, rhs, false, eqnAttributes, selfCalled, inTpl);
10321033

10331034
// a = -b;
1034-
case (DAE.CREF(componentRef = cr1), DAE.UNARY(DAE.UMINUS(ty), DAE.CREF(componentRef = cr2)), _, _, _)
1035-
then addSimpleEquationAcausal(cr1, DAE.UNARY(DAE.UMINUS(ty), lhs), false, cr2, rhs, true, eqnAttributes, selfCalled, inTpl);
1035+
case (DAE.CREF(componentRef = cr1), DAE.UNARY(op as DAE.UMINUS(_), DAE.CREF(componentRef = cr2)), _, _, _)
1036+
then addSimpleEquationAcausal(cr1, DAE.UNARY(op, lhs), false, cr2, rhs, true, eqnAttributes, selfCalled, inTpl);
10361037

1037-
case (DAE.CREF(componentRef = cr1), DAE.UNARY(DAE.UMINUS_ARR(ty), DAE.CREF(componentRef = cr2)), _, _, _)
1038-
then addSimpleEquationAcausal(cr1, DAE.UNARY(DAE.UMINUS_ARR(ty), lhs), false, cr2, rhs, true, eqnAttributes, selfCalled, inTpl);
1038+
case (DAE.CREF(componentRef = cr1), DAE.UNARY(op as DAE.UMINUS_ARR(_), DAE.CREF(componentRef = cr2)), _, _, _)
1039+
then addSimpleEquationAcausal(cr1, DAE.UNARY(op, lhs), false, cr2, rhs, true, eqnAttributes, selfCalled, inTpl);
10391040

10401041
// -a = b;
1041-
case (DAE.UNARY(DAE.UMINUS(ty), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _, _, _)
1042-
then addSimpleEquationAcausal(cr1, lhs, true, cr2, DAE.UNARY(DAE.UMINUS(ty), rhs), false, eqnAttributes, selfCalled, inTpl);
1042+
case (DAE.UNARY(op as DAE.UMINUS(_), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _, _, _)
1043+
then addSimpleEquationAcausal(cr1, lhs, true, cr2, DAE.UNARY(op, rhs), false, eqnAttributes, selfCalled, inTpl);
10431044

1044-
case (DAE.UNARY(DAE.UMINUS_ARR(ty), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _, _, _)
1045-
then addSimpleEquationAcausal(cr1, lhs, true, cr2, DAE.UNARY(DAE.UMINUS_ARR(ty), rhs), false, eqnAttributes, selfCalled, inTpl);
1045+
case (DAE.UNARY(op as DAE.UMINUS_ARR(_), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _, _, _)
1046+
then addSimpleEquationAcausal(cr1, lhs, true, cr2, DAE.UNARY(op, rhs), false, eqnAttributes, selfCalled, inTpl);
10461047

10471048
// -a = -b;
10481049
case (DAE.UNARY(DAE.UMINUS(_), e1 as DAE.CREF(componentRef = cr1)), DAE.UNARY(DAE.UMINUS(_), e2 as DAE.CREF(componentRef = cr2)), _, _, _)
@@ -1052,12 +1053,12 @@ algorithm
10521053
then addSimpleEquationAcausal(cr1, e1, false, cr2, e2, false, eqnAttributes, selfCalled, inTpl);
10531054

10541055
// a = not b;
1055-
case (DAE.CREF(componentRef = cr1), DAE.LUNARY(DAE.NOT(ty), DAE.CREF(componentRef = cr2)), _, _, _)
1056-
then addSimpleEquationAcausal(cr1, DAE.LUNARY(DAE.NOT(ty), lhs), false, cr2, rhs, true, eqnAttributes, selfCalled, inTpl);
1056+
case (DAE.CREF(componentRef = cr1), DAE.LUNARY(op as DAE.NOT(_), DAE.CREF(componentRef = cr2)), _, _, _)
1057+
then addSimpleEquationAcausal(cr1, DAE.LUNARY(op, lhs), false, cr2, rhs, true, eqnAttributes, selfCalled, inTpl);
10571058

10581059
// not a = b;
1059-
case (DAE.LUNARY(DAE.NOT(ty), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _, _, _)
1060-
then addSimpleEquationAcausal(cr1, lhs, true, cr2, DAE.LUNARY(DAE.NOT(ty), lhs), false, eqnAttributes, selfCalled, inTpl);
1060+
case (DAE.LUNARY(op as DAE.NOT(_), DAE.CREF(componentRef = cr1)), DAE.CREF(componentRef = cr2), _, _, _)
1061+
then addSimpleEquationAcausal(cr1, lhs, true, cr2, DAE.LUNARY(op, lhs), false, eqnAttributes, selfCalled, inTpl);
10611062

10621063
// not a = not b;
10631064
case (DAE.LUNARY(DAE.NOT(_), e1 as DAE.CREF(componentRef = cr1)), DAE.LUNARY(DAE.NOT(_), e2 as DAE.CREF(componentRef = cr2)), _, _, _)

‎SimulationRuntime/c/simulation/solver/omc_math.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -675,7 +675,7 @@ _omc_matrix* _omc_subtractMatrixMatrix(_omc_matrix* mat1, _omc_matrix* mat2)
675675
return mat1;
676676
}
677677

678-
/*! \fn _omc_scalar* _omc_multiplyMatrixMatrix(_omc_matrix* mat1, _omc_matrix* mat2)
678+
/*! \fn _omc_matrix* _omc_multiplyMatrixMatrix(_omc_matrix* mat1, _omc_matrix* mat2)
679679
*
680680
* _omc_matrix multiplication of two matrixes into matrix one
681681
*

0 commit comments

Comments
 (0)