Skip to content

Commit acd9d41

Browse files
author
Jens Frenkel
committed
- Derive: add case for MUL_SCALAR_PRODUCT
- check Flag for actuall index reduction version git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@14518 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
1 parent 2248115 commit acd9d41

File tree

2 files changed

+97
-79
lines changed

2 files changed

+97
-79
lines changed

‎Compiler/BackEnd/Derive.mo‎

Lines changed: 88 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -1242,7 +1242,7 @@ algorithm
12421242
outExp := matchcontinue (inExp,inComponentRef,differentiateIfExp,inFuncs)
12431243
local
12441244
Real rval;
1245-
DAE.ComponentRef cr,crx,tv;
1245+
DAE.ComponentRef cr;
12461246
DAE.Exp e,e1_1,e2_1,e1,e2,const_one,d_e1,d_e2,exp,e_1,cond,zero,call;
12471247
DAE.Type tp;
12481248
Absyn.Path a,path;
@@ -1258,73 +1258,73 @@ algorithm
12581258

12591259
case (DAE.RCONST(real = _),_,_,_) then DAE.RCONST(0.0);
12601260

1261-
case (DAE.CREF(componentRef = cr),crx,_,_)
1261+
case (DAE.CREF(componentRef = cr),_,_,_)
12621262
equation
1263-
true = ComponentReference.crefEqual(cr, crx) "D(x)/dx => 1" ;
1263+
true = ComponentReference.crefEqual(cr, inComponentRef) "D(x)/dx => 1" ;
12641264
rval = intReal(1) "Since bug in MetaModelica Compiler (MMC) makes 1.0 into 0.0" ;
12651265
then
12661266
DAE.RCONST(rval);
12671267

1268-
case ((e as DAE.CREF(componentRef = cr,ty=tp)),crx,_,_)
1268+
case ((e as DAE.CREF(componentRef = cr,ty=tp)),_,_,_)
12691269
equation
1270-
false = ComponentReference.crefEqual(cr, crx) "D(c)/dx => 0" ;
1270+
false = ComponentReference.crefEqual(cr, inComponentRef) "D(c)/dx => 0" ;
12711271
(zero,_) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
12721272
then
12731273
zero;
12741274

1275-
case (DAE.BINARY(exp1 = e1,operator = DAE.ADD(ty = tp),exp2 = e2),tv,_,_)
1275+
case (DAE.BINARY(exp1 = e1,operator = DAE.ADD(ty = tp),exp2 = e2),_,_,_)
12761276
equation
1277-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1278-
e2_1 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1277+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1278+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
12791279
then
12801280
DAE.BINARY(e1_1,DAE.ADD(tp),e2_1);
12811281

1282-
case (DAE.BINARY(exp1 = e1,operator = DAE.ADD_ARR(ty = tp),exp2 = e2),tv,_,_)
1282+
case (DAE.BINARY(exp1 = e1,operator = DAE.ADD_ARR(ty = tp),exp2 = e2),_,_,_)
12831283
equation
1284-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1285-
e2_1 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1284+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1285+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
12861286
then
12871287
DAE.BINARY(e1_1,DAE.ADD_ARR(tp),e2_1);
12881288

1289-
case (DAE.BINARY(exp1 = e1,operator = DAE.SUB(ty = tp),exp2 = e2),tv,_,_)
1289+
case (DAE.BINARY(exp1 = e1,operator = DAE.SUB(ty = tp),exp2 = e2),_,_,_)
12901290
equation
1291-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1292-
e2_1 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1291+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1292+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
12931293
then
12941294
DAE.BINARY(e1_1,DAE.SUB(tp),e2_1);
12951295

1296-
case (DAE.BINARY(exp1 = e1,operator = DAE.SUB_ARR(ty = tp),exp2 = e2),tv,_,_)
1296+
case (DAE.BINARY(exp1 = e1,operator = DAE.SUB_ARR(ty = tp),exp2 = e2),_,_,_)
12971297
equation
1298-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1299-
e2_1 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1298+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1299+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
13001300
then
13011301
DAE.BINARY(e1_1,DAE.SUB_ARR(tp),e2_1);
13021302

1303-
case (DAE.BINARY(exp1 = (e1 as DAE.CREF(componentRef = cr)),operator = DAE.POW(ty = tp),exp2 = e2),tv,_,_) /* ax^(a-1) */
1303+
case (DAE.BINARY(exp1 = (e1 as DAE.CREF(componentRef = cr)),operator = DAE.POW(ty = tp),exp2 = e2),_,_,_) /* ax^(a-1) */
13041304
equation
1305-
true = ComponentReference.crefEqual(cr, tv) "x^a => ax^(a-1)" ;
1306-
false = Expression.expContains(e2, Expression.makeCrefExp(tv,tp));
1307-
const_one = differentiateExp(Expression.makeCrefExp(tv,tp), tv, differentiateIfExp,inFuncs);
1305+
true = ComponentReference.crefEqual(cr, inComponentRef) "x^a => ax^(a-1)" ;
1306+
false = Expression.expContains(e2, Expression.makeCrefExp(inComponentRef,tp));
1307+
const_one = differentiateExp(Expression.makeCrefExp(inComponentRef,tp), inComponentRef, differentiateIfExp,inFuncs);
13081308
then
13091309
DAE.BINARY(e2,DAE.MUL(tp),
13101310
DAE.BINARY(e1,DAE.POW(tp),DAE.BINARY(e2,DAE.SUB(tp),const_one)));
13111311

1312-
case (DAE.BINARY(exp1 = e1,operator = DAE.POW(ty = tp),exp2 = e2),tv,_,_) /* ax^(a-1) */
1312+
case (DAE.BINARY(exp1 = e1,operator = DAE.POW(ty = tp),exp2 = e2),_,_,_) /* ax^(a-1) */
13131313
equation
1314-
d_e1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs) "e^x => xder(e)e^x-1" ;
1315-
false = Expression.expContains(e2, Expression.makeCrefExp(tv,tp));
1316-
const_one = differentiateExp(Expression.makeCrefExp(tv,tp), tv, differentiateIfExp,inFuncs);
1314+
d_e1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs) "e^x => xder(e)e^x-1" ;
1315+
false = Expression.expContains(e2, Expression.makeCrefExp(inComponentRef,tp));
1316+
const_one = differentiateExp(Expression.makeCrefExp(inComponentRef,tp), inComponentRef, differentiateIfExp,inFuncs);
13171317
exp = DAE.BINARY(
13181318
DAE.BINARY(d_e1,DAE.MUL(tp),DAE.BINARY(e2,DAE.SUB(tp),DAE.RCONST(1.0))),DAE.MUL(tp),
13191319
DAE.BINARY(e1,DAE.POW(tp),DAE.BINARY(e2,DAE.SUB(tp),const_one)));
13201320
then
13211321
exp;
13221322

1323-
case (e as DAE.BINARY(exp1 = e1,operator = DAE.POW(ty = tp),exp2 = e2),tv,_,_) /* a^x => a^x * log(A) */
1323+
case (e as DAE.BINARY(exp1 = e1,operator = DAE.POW(ty = tp),exp2 = e2),_,_,_) /* a^x => a^x * log(A) */
13241324
equation
1325-
false = Expression.expContains(e1, Expression.makeCrefExp(tv,tp));
1326-
true = Expression.expContains(e2,Expression.makeCrefExp(tv,tp));
1327-
d_e2 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1325+
false = Expression.expContains(e1, Expression.makeCrefExp(inComponentRef,tp));
1326+
true = Expression.expContains(e2,Expression.makeCrefExp(inComponentRef,tp));
1327+
d_e2 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
13281328
call = Expression.makeBuiltinCall("log",{e1},tp);
13291329
exp = DAE.BINARY(d_e2,DAE.MUL(tp),DAE.BINARY(e,DAE.MUL(tp),call));
13301330
then
@@ -1333,30 +1333,39 @@ algorithm
13331333
// ax^(a-1)
13341334
case (DAE.BINARY(exp1 = (e1 as DAE.CALL(path = (a as Absyn.IDENT(name = "der")),
13351335
expLst = {(exp as DAE.CREF(componentRef = cr))},attr=attr)),
1336-
operator = DAE.POW(ty = tp),exp2 = e2),tv,_,_)
1336+
operator = DAE.POW(ty = tp),exp2 = e2),_,_,_)
13371337
equation
1338-
true = ComponentReference.crefEqual(cr, tv) "der(e)^x => xder(e,2)der(e)^(x-1)" ;
1339-
false = Expression.expContains(e2, Expression.makeCrefExp(tv,tp));
1340-
const_one = differentiateExp(Expression.makeCrefExp(tv,tp), tv, differentiateIfExp,inFuncs);
1338+
true = ComponentReference.crefEqual(cr, inComponentRef) "der(e)^x => xder(e,2)der(e)^(x-1)" ;
1339+
false = Expression.expContains(e2, Expression.makeCrefExp(inComponentRef,tp));
1340+
const_one = differentiateExp(Expression.makeCrefExp(inComponentRef,tp), inComponentRef, differentiateIfExp,inFuncs);
13411341
then
13421342
DAE.BINARY(
13431343
DAE.BINARY(DAE.CALL(a,{exp,DAE.ICONST(2)},attr),DAE.MUL(tp),e2),DAE.MUL(tp),
13441344
DAE.BINARY(e1,DAE.POW(tp),DAE.BINARY(e2,DAE.SUB(tp),const_one)));
13451345

13461346
// f\'g + fg\'
1347-
case (DAE.BINARY(exp1 = e1,operator = DAE.MUL(ty = tp),exp2 = e2),tv,_,_)
1347+
case (DAE.BINARY(exp1 = e1,operator = DAE.MUL(ty = tp),exp2 = e2),_,_,_)
13481348
equation
1349-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1350-
e2_1 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1349+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1350+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
13511351
then
13521352
DAE.BINARY(DAE.BINARY(e1,DAE.MUL(tp),e2_1),DAE.ADD(tp),
13531353
DAE.BINARY(e1_1,DAE.MUL(tp),e2));
13541354

1355+
/* f\'g + fg\' */
1356+
case (DAE.BINARY(exp1 = e1,operator = DAE.MUL_SCALAR_PRODUCT(ty = tp),exp2 = e2),_,_,_)
1357+
equation
1358+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1359+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
1360+
then
1361+
DAE.BINARY(DAE.BINARY(e1,DAE.MUL_SCALAR_PRODUCT(tp),e2_1),DAE.ADD_ARR(tp),
1362+
DAE.BINARY(e1_1,DAE.MUL_SCALAR_PRODUCT(tp),e2));
1363+
13551364
// (f'g - fg' ) / g^2
1356-
case (DAE.BINARY(exp1 = e1,operator = DAE.DIV(ty = tp),exp2 = e2),tv,_,_)
1365+
case (DAE.BINARY(exp1 = e1,operator = DAE.DIV(ty = tp),exp2 = e2),_,_,_)
13571366
equation
1358-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1359-
e2_1 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1367+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1368+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
13601369
then
13611370
DAE.BINARY(
13621371
DAE.BINARY(
@@ -1366,69 +1375,69 @@ algorithm
13661375
DAE.DIV(tp),
13671376
DAE.BINARY(e2,DAE.MUL(tp),e2));
13681377

1369-
case (DAE.UNARY(operator = op,exp = e),tv,_,_)
1378+
case (DAE.UNARY(operator = op,exp = e),_,_,_)
13701379
equation
1371-
e_1 = differentiateExp(e, tv, differentiateIfExp,inFuncs);
1380+
e_1 = differentiateExp(e, inComponentRef, differentiateIfExp,inFuncs);
13721381
then
13731382
DAE.UNARY(op,e_1);
13741383

1375-
case ((e as DAE.LBINARY(exp1 = e1,operator = op,exp2 = e2)),tv,_,_)
1384+
case ((e as DAE.LBINARY(exp1 = e1,operator = op,exp2 = e2)),_,_,_)
13761385
equation
13771386
e_str = ExpressionDump.printExpStr(e) "The derivative of logic expressions are non-existent" ;
13781387
Error.addMessage(Error.NON_EXISTING_DERIVATIVE, {e_str});
13791388
then
13801389
fail();
13811390

1382-
case (DAE.LUNARY(operator = op,exp = e),tv,_,_)
1391+
case (DAE.LUNARY(operator = op,exp = e),_,_,_)
13831392
equation
1384-
e_1 = differentiateExp(e, tv, differentiateIfExp,inFuncs);
1393+
e_1 = differentiateExp(e, inComponentRef, differentiateIfExp,inFuncs);
13851394
then
13861395
DAE.LUNARY(op,e_1);
13871396

1388-
case (DAE.CALL(path=Absyn.IDENT(name),attr=DAE.CALL_ATTR(builtin=true),expLst={exp}),tv,_,_)
1397+
case (DAE.CALL(path=Absyn.IDENT(name),attr=DAE.CALL_ATTR(builtin=true),expLst={exp}),_,_,_)
13891398
equation
1390-
true = Expression.expContains(exp,Expression.crefExp(tv));
1391-
then differentiateCallExp1Arg(name,exp,tv,differentiateIfExp,inFuncs);
1399+
true = Expression.expContains(exp,Expression.crefExp(inComponentRef));
1400+
then differentiateCallExp1Arg(name,exp,inComponentRef,differentiateIfExp,inFuncs);
13921401

1393-
case (DAE.CALL(path = Absyn.IDENT("der"), expLst = {DAE.CREF(componentRef = cr)}), crx, _,_)
1402+
case (DAE.CALL(path = Absyn.IDENT("der"), expLst = {DAE.CREF(componentRef = cr)}), _, _,_)
13941403
equation
13951404
cr = ComponentReference.crefPrefixDer(cr);
1396-
true = ComponentReference.crefEqual(cr, crx);
1405+
true = ComponentReference.crefEqual(cr, inComponentRef);
13971406
rval = intReal(1);
13981407
then
13991408
DAE.RCONST(rval);
14001409

14011410
// der(x)
14021411
case (DAE.CALL(path = (a as Absyn.IDENT(name = "der")),expLst =
1403-
{(exp as DAE.CREF(componentRef = cr))},attr=attr),tv,_,_)
1412+
{(exp as DAE.CREF(componentRef = cr))},attr=attr),_,_,_)
14041413
equation
1405-
true = ComponentReference.crefEqual(cr, tv);
1414+
true = ComponentReference.crefEqual(cr, inComponentRef);
14061415
then
14071416
DAE.CALL(a,{exp,DAE.ICONST(2)},attr);
14081417

14091418
// der(arctan2(y,0)) = der(sign(y)*pi/2) = 0
1410-
case (DAE.CALL(path = Absyn.IDENT("atan2"),expLst = {e,e1}),tv,_,_)
1419+
case (DAE.CALL(path = Absyn.IDENT("atan2"),expLst = {e,e1}),_,_,_)
14111420
equation
1412-
true = Expression.expContains(e, Expression.crefExp(tv));
1421+
true = Expression.expContains(e, Expression.crefExp(inComponentRef));
14131422
true = Expression.isZero(e1);
14141423
(exp,_) = Expression.makeZeroExpression({});
14151424
then exp;
14161425

14171426
// der(arctan2(y,x)) = der(y/x)/1+(y/x)^2
1418-
case (DAE.CALL(path = Absyn.IDENT("atan2"),expLst = {e,e1}),tv,_,_)
1427+
case (DAE.CALL(path = Absyn.IDENT("atan2"),expLst = {e,e1}),_,_,_)
14191428
equation
1420-
true = Expression.expContains(e, Expression.crefExp(tv));
1429+
true = Expression.expContains(e, Expression.crefExp(inComponentRef));
14211430
false = Expression.isZero(e1);
14221431
exp = Expression.makeDiv(e,e1);
1423-
e_1 = differentiateExp(exp, tv, differentiateIfExp,inFuncs);
1432+
e_1 = differentiateExp(exp, inComponentRef, differentiateIfExp,inFuncs);
14241433
then
14251434
DAE.BINARY(e_1,DAE.DIV(DAE.T_REAL_DEFAULT),DAE.BINARY(DAE.RCONST(1.0),DAE.ADD(DAE.T_REAL_DEFAULT),DAE.BINARY(e,DAE.MUL(DAE.T_REAL_DEFAULT),e)));
14261435

14271436
// der(record constructur(..)) = record constructur(der(.),der(.))
1428-
case (DAE.CALL(path=a,expLst=expl,attr=attr as DAE.CALL_ATTR(ty= DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(path)))),tv,_,_)
1437+
case (DAE.CALL(path=a,expLst=expl,attr=attr as DAE.CALL_ATTR(ty= DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(path)))),_,_,_)
14291438
equation
14301439
true = Absyn.pathEqual(a, path);
1431-
expl_1 = List.map3(expl, differentiateExp, tv, differentiateIfExp,inFuncs);
1440+
expl_1 = List.map3(expl, differentiateExp, inComponentRef, differentiateIfExp,inFuncs);
14321441
then DAE.CALL(a,expl_1,attr);
14331442

14341443
/*
@@ -1443,34 +1452,34 @@ algorithm
14431452
DAE.RELATION(e1_1,rel,e2_1);
14441453
*/
14451454

1446-
case (DAE.ARRAY(ty = tp,scalar = b,array = expl),tv,_,_)
1455+
case (DAE.ARRAY(ty = tp,scalar = b,array = expl),_,_,_)
14471456
equation
1448-
expl_1 = List.map3(expl, differentiateExp, tv, differentiateIfExp,inFuncs);
1457+
expl_1 = List.map3(expl, differentiateExp, inComponentRef, differentiateIfExp,inFuncs);
14491458
then
14501459
DAE.ARRAY(tp,b,expl_1);
14511460

1452-
case (DAE.TUPLE(PR = expl),tv,_,_)
1461+
case (DAE.TUPLE(PR = expl),_,_,_)
14531462
equation
1454-
expl_1 = List.map3(expl, differentiateExp, tv, differentiateIfExp,inFuncs);
1463+
expl_1 = List.map3(expl, differentiateExp, inComponentRef, differentiateIfExp,inFuncs);
14551464
then
14561465
DAE.TUPLE(expl_1);
14571466

1458-
case (DAE.CAST(ty = tp,exp = e),tv,_,_)
1467+
case (DAE.CAST(ty = tp,exp = e),_,_,_)
14591468
equation
1460-
e_1 = differentiateExp(e, tv, differentiateIfExp,inFuncs);
1469+
e_1 = differentiateExp(e, inComponentRef, differentiateIfExp,inFuncs);
14611470
then
14621471
DAE.CAST(tp,e_1);
14631472

1464-
case (DAE.ASUB(exp = e,sub = sub),tv,_,_)
1473+
case (DAE.ASUB(exp = e,sub = sub),_,_,_)
14651474
equation
1466-
e_1 = differentiateExp(e, tv, differentiateIfExp,inFuncs);
1475+
e_1 = differentiateExp(e, inComponentRef, differentiateIfExp,inFuncs);
14671476
then
14681477
Expression.makeASUB(e_1,sub);
14691478

14701479
// TODO: Check if we are differentiating a local iterator?
1471-
case (DAE.REDUCTION(reductionInfo=reductionInfo,expr = e1,iterators = riters),tv,_,_)
1480+
case (DAE.REDUCTION(reductionInfo=reductionInfo,expr = e1,iterators = riters),_,_,_)
14721481
equation
1473-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1482+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
14741483
then
14751484
DAE.REDUCTION(reductionInfo,e1_1,riters);
14761485

@@ -1494,39 +1503,39 @@ algorithm
14941503
then
14951504
DAE.IFEXP(cond,e1_1,e2_1);
14961505
*/
1497-
case (e as DAE.CALL(path=_),tv,_,_)
1506+
case (e as DAE.CALL(path=_),_,_,_)
14981507
equation
14991508
// try to inline
15001509
(e1,_,true) = Inline.forceInlineExp(e,(inFuncs,{DAE.NORM_INLINE(),DAE.NO_INLINE()}),DAE.emptyElementSource/*TODO:Can we propagate source?*/);
15011510
e1 = Expression.addNoEventToRelations(e1);
15021511
then
1503-
differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1512+
differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
15041513

1505-
case (e,cr,_,_)
1514+
case (_,_,_,_)
15061515
equation
1507-
false = Expression.expContains(e, Expression.crefExp(cr))
1516+
false = Expression.expContains(inExp, Expression.crefExp(inComponentRef))
15081517
"If the expression does not contain the variable,
15091518
the derivative is zero. For efficiency reasons this rule
15101519
is last. Otherwise expressions is always traversed twice
15111520
when differentiating.";
1512-
tp = Expression.typeof(e);
1521+
tp = Expression.typeof(inExp);
15131522
(zero,_) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
15141523
then
15151524
zero;
15161525

15171526
// Differentiate if-expressions if last argument true
1518-
case (DAE.IFEXP(cond,e1,e2),tv,true,_)
1527+
case (DAE.IFEXP(cond,e1,e2),_,true,_)
15191528
equation
1520-
e1_1 = differentiateExp(e1, tv, differentiateIfExp,inFuncs);
1521-
e2_1 = differentiateExp(e2, tv, differentiateIfExp,inFuncs);
1529+
e1_1 = differentiateExp(e1, inComponentRef, differentiateIfExp,inFuncs);
1530+
e2_1 = differentiateExp(e2, inComponentRef, differentiateIfExp,inFuncs);
15221531
then
15231532
DAE.IFEXP(cond,e1_1,e2_1);
15241533

1525-
case (e,cr,_,_)
1534+
case (_,_,_,_)
15261535
equation
15271536
true = Flags.isSet(Flags.FAILTRACE);
1528-
s = ExpressionDump.printExpStr(e);
1529-
s2 = ComponentReference.printComponentRefStr(cr);
1537+
s = ExpressionDump.printExpStr(inExp);
1538+
s2 = ComponentReference.printComponentRefStr(inComponentRef);
15301539
str = stringAppendList({"- Derive.differentiateExp ",s," w.r.t: ",s2," failed\n"});
15311540
//print(str);
15321541
Debug.fprint(Flags.FAILTRACE, str);

‎Compiler/BackEnd/IndexReduction.mo‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2002,6 +2002,15 @@ algorithm
20022002
BackendDAE.AdjacencyMatrixTEnhanced meT;
20032003
case (_,_,_,_,_,_,_,_,_,_,_,_,_)
20042004
equation
2005+
false = Flags.getConfigBool(Flags.DYNAMIC_PIVOT);
2006+
true = intEq(freeStates,neqns);
2007+
dummyStates = List.map(varlst,BackendVariable.varCref);
2008+
dummyStates = listAppend(dummyStates,inDummyStates);
2009+
then
2010+
(varlst,dummyStates,isyst,ishared,iSetIndex);
2011+
case (_,_,_,_,_,_,_,_,_,_,_,_,_)
2012+
equation
2013+
true = Flags.getConfigBool(Flags.DYNAMIC_PIVOT);
20052014
true = intEq(freeStates,neqns);
20062015
dummyStates = List.map(varlst,BackendVariable.varCref);
20072016
dummyStates = listAppend(dummyStates,inDummyStates);

0 commit comments

Comments
 (0)