Skip to content

Commit

Permalink
- Fixed builtin listEmpty and replaced List.isEmpty with it.
Browse files Browse the repository at this point in the history 
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@22199 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
@perost
perost committed Sep 9, 2014
1 parent b6136b9 commit d276a6d
Show file tree
Hide file tree
Showing 37 changed files with 107 additions and 117 deletions.
10 changes: 5 additions & 5 deletions Compiler/BackEnd/BackendDAEOptimize.mo
View file
Expand Up @@ -7612,39 +7612,39 @@ algorithm

case (BackendDAE.MIXEDEQUATIONSYSTEM(disc_vars=vlst)::rest, _) equation
varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
false = List.isEmpty(varlst);
false = listEmpty(varlst);

warning = "Iteration variables of mixed equation system:\n" +& warnAboutVars(varlst);
warningList = listAllIterationVariables2(rest, inVars);
then warning::warningList;

case (BackendDAE.EQUATIONSYSTEM(vars=vlst, jacType=BackendDAE.JAC_NONLINEAR())::rest, _) equation
varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
false = List.isEmpty(varlst);
false = listEmpty(varlst);

warning = "Iteration variables of nonlinear equation system:\n" +& warnAboutVars(varlst);
warningList = listAllIterationVariables2(rest, inVars);
then warning::warningList;

case (BackendDAE.EQUATIONSYSTEM(vars=vlst, jacType=BackendDAE.JAC_GENERIC())::rest, _) equation
varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
false = List.isEmpty(varlst);
false = listEmpty(varlst);

warning = "Iteration variables of equation system w/o analytic Jacobian:\n" +& warnAboutVars(varlst);
warningList = listAllIterationVariables2(rest, inVars);
then warning::warningList;

case (BackendDAE.EQUATIONSYSTEM(vars=vlst, jacType=BackendDAE.JAC_NO_ANALYTIC())::rest, _) equation
varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
false = List.isEmpty(varlst);
false = listEmpty(varlst);

warning = "Iteration variables of equation system w/o analytic Jacobian:\n" +& warnAboutVars(varlst);
warningList = listAllIterationVariables2(rest, inVars);
then warning::warningList;

case (BackendDAE.TORNSYSTEM(tearingvars=vlst, linear=linear)::rest, _) equation
varlst = List.map1r(vlst, BackendVariable.getVarAt, inVars);
false = List.isEmpty(varlst);
false = listEmpty(varlst);

str = Util.if_(linear, "linear", "nonlinear");
warning = "Iteration variables of torn " +& str +& " equation system:\n" +& warnAboutVars(varlst);
Expand Down
10 changes: 5 additions & 5 deletions Compiler/BackEnd/DynamicOptimization.mo
View file
Expand Up @@ -86,7 +86,7 @@ algorithm
mayer1 = findMayerTerm(inVars, knvars);
mayer1 = mergeObjectVars(mayer1,mayer);
objectEqn = BackendEquation.generateSolvedEqnsfromOption(leftcref, mayer1, DAE.emptyElementSource, BackendDAE.UNKNOWN_EQUATION_KIND());
b = not List.isEmpty(objectEqn);
b = not listEmpty(objectEqn);

v = Util.if_(b, BackendVariable.addNewVar(dummyVar, v), v);
e = Util.if_(b, listAppend(e, objectEqn), e);
Expand All @@ -96,7 +96,7 @@ algorithm
lagrange1 = findLagrangeTerm(inVars, knvars);
lagrange1 = mergeObjectVars(lagrange1,lagrange);
objectEqn = BackendEquation.generateSolvedEqnsfromOption(leftcref, lagrange1, DAE.emptyElementSource, BackendDAE.UNKNOWN_EQUATION_KIND());
b = not List.isEmpty(objectEqn);
b = not listEmpty(objectEqn);

v = Util.if_(b, BackendVariable.addNewVar(dummyVar, v), v);
e = Util.if_(b, listAppend(e, objectEqn), e);
Expand All @@ -115,7 +115,7 @@ algorithm
dummyVar = BackendDAE.VAR(leftcref, BackendDAE.VARIABLE(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
mayer1 = findMayerTerm(inVars, knvars);
objectEqn = BackendEquation.generateSolvedEqnsfromOption(leftcref, mayer1, DAE.emptyElementSource, BackendDAE.UNKNOWN_EQUATION_KIND());
b = not List.isEmpty(objectEqn);
b = not listEmpty(objectEqn);

v = Util.if_(b, BackendVariable.addNewVar(dummyVar, v), v);
e = Util.if_(b, listAppend(e, objectEqn), e);
Expand All @@ -124,7 +124,7 @@ algorithm
dummyVar = BackendDAE.VAR(leftcref, BackendDAE.VARIABLE(), DAE.OUTPUT(), DAE.NON_PARALLEL(), DAE.T_REAL_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), DAE.NON_CONNECTOR());
lagrange1 = findLagrangeTerm(inVars, knvars);
objectEqn = BackendEquation.generateSolvedEqnsfromOption(leftcref, lagrange1, DAE.emptyElementSource, BackendDAE.UNKNOWN_EQUATION_KIND());
b = not List.isEmpty(objectEqn);
b = not listEmpty(objectEqn);
v = Util.if_(b, BackendVariable.addNewVar(dummyVar, v), v);
e = Util.if_(b, listAppend(e, objectEqn), e);

Expand Down Expand Up @@ -388,4 +388,4 @@ algorithm
end match;
end findFinalConstraints;

end DynamicOptimization;
end DynamicOptimization;
14 changes: 7 additions & 7 deletions Compiler/BackEnd/EvaluateFunctions.mo
View file
Expand Up @@ -365,9 +365,9 @@ algorithm
//print("varScalarCrefs 1\n"+&stringDelimitList(List.map(varScalarCrefs,ComponentReference.printComponentRefStr),"\n")+&"\n");

// is it completely constant or partially?
funcIsConst = List.isEmpty(varScalarCrefs) and List.isEmpty(varComplexCrefs);
funcIsConst = listEmpty(varScalarCrefs) and listEmpty(varComplexCrefs);
funcIsPartConst = (List.isNotEmpty(varScalarCrefs) or List.isNotEmpty(varComplexCrefs)) and (List.isNotEmpty(constScalarCrefs) or List.isNotEmpty(constComplexCrefs)) and not funcIsConst;
isConstRec = intEq(listLength(constScalarCrefs),listLength(List.flatten(scalarOutputs))) and List.isEmpty(varScalarCrefs) and List.isEmpty(varComplexCrefs) and List.isEmpty(constComplexCrefs);
isConstRec = intEq(listLength(constScalarCrefs),listLength(List.flatten(scalarOutputs))) and listEmpty(varScalarCrefs) and listEmpty(varComplexCrefs) and listEmpty(constComplexCrefs);

//Debug.bcall1(isConstRec,print,"the function output is completely constant and its a record\n");
Debug.bcall1(Flags.isSet(Flags.EVAL_FUNC_DUMP) and funcIsConst,print,"the function output is completely constant\n");
Expand Down Expand Up @@ -700,8 +700,8 @@ algorithm
({},lhsExpIn,{});
case(_,_,_,_,_,_,DAE.TUPLE(PR=expLst))
equation
true = List.isEmpty(List.flatten(scalarOutputs));
true = List.isNotEmpty(constScalarCrefs);
true = listEmpty(List.flatten(scalarOutputs));
true = not listEmpty(constScalarCrefs);
varScalarCrefsInFunc = {};
allOutputCrefs = List.map(allOutputs,DAEUtil.varCref);
(protCrefs,_,outputCrefs) = List.intersection1OnTrue(constScalarCrefs,allOutputCrefs,ComponentReference.crefEqual);
Expand Down Expand Up @@ -848,7 +848,7 @@ algorithm
cref = DAEUtil.varCref(elem);
scalars = getScalarsForComplexVar(elem);
// function output is one dimensional
true = List.isEmpty(scalars);
true = listEmpty(scalars);
const = listMember(cref,constCrefs);
constCompl = Util.if_(const,cref::constComplexLstIn,constComplexLstIn);
varCompl = Util.if_(not const,cref::varComplexLstIn,varComplexLstIn);
Expand Down Expand Up @@ -1490,7 +1490,7 @@ algorithm
// if its not definite which case, try to predict a constant output, maybe its partially constant, then remove function outputs replacements
Debug.bcall1(Flags.isSet(Flags.EVAL_FUNC_DUMP) and not isEval,print,"-->try to predict the outputs \n");
((stmtsNew,addStmts),FUNCINFO(repl,funcTree,idx)) = Debug.bcallret2_2(not isEval ,predictIfOutput,alg,FUNCINFO(replIn,funcTree,idx),(stmts1,{}),FUNCINFO(replIn,funcTree,idx));
predicted = List.isNotEmpty(addStmts) or List.isEmpty(stmtsNew) and not isEval;
predicted = List.isNotEmpty(addStmts) or listEmpty(stmtsNew) and not isEval;
Debug.bcall1(Flags.isSet(Flags.EVAL_FUNC_DUMP) and not isEval,print,"could it be predicted? "+&boolString(predicted)+&"\n");

// if nothing can be done, remove the replacements for the variables assigned in the if stmt
Expand Down Expand Up @@ -2465,7 +2465,7 @@ algorithm
Debug.bcall1(Flags.isSet(Flags.EVAL_FUNC_DUMP),print,"--> the predicted const outputs:\n"+&stringDelimitList(List.map(outExps,ExpressionDump.printExpStr),"\n"));
(constOutExps,_,varOutExps) = List.intersection1OnTrue(outExps,allLHS,Expression.expEqual);

predicted = List.isNotEmpty(constOutExps) and List.isEmpty(varOutExps);
predicted = List.isNotEmpty(constOutExps) and listEmpty(varOutExps);
//repl = Debug.bcallret3(not predicted, BackendVarTransform.removeReplacements,replIn,varCrefs,NONE(),replIn);
//Debug.bcall(not predicted,print,"remove the replacement for: "+&stringDelimitList(List.map(varCrefs,ComponentReference.crefStr),"\n")+&"\n");
repl = replIn;
Expand Down
12 changes: 6 additions & 6 deletions Compiler/BackEnd/FindZeroCrossings.mo
View file
Expand Up @@ -520,7 +520,7 @@ algorithm
e_1 = DAE.LUNARY(op, e1);
{zc} = makeZeroCrossings({e_1}, {eq_count}, {wc_count});
zc_lst = List.select1(zeroCrossings, sameZeroCrossing, zc);
zeroCrossings = Util.if_(List.isEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
zeroCrossings = Util.if_(listEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
Debug.fcall(Flags.RELIDX, BackendDump.debugExpStr, (e_1, "\n"));
then (e_1, false, ((zeroCrossings, relations, samples, numRelations, numMathFunctions), (eq_count, wc_count, vars, knvars)));
case ((e as DAE.LBINARY(exp1 = e1, operator = op, exp2 = e2)), ((zeroCrossings, relations, samples, numRelations, numMathFunctions), (eq_count, wc_count, vars, knvars)))
Expand All @@ -533,7 +533,7 @@ algorithm
e_1 = DAE.LBINARY(e_1, op, e_2);
{zc} = makeZeroCrossings({e_1}, {eq_count}, {wc_count});
zc_lst = List.select1(zeroCrossings, sameZeroCrossing, zc);
zeroCrossings = Util.if_(List.isEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
zeroCrossings = Util.if_(listEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
print(Debug.fcallret1(Flags.RELIDX, BackendDump.zeroCrossingListString, zeroCrossings, ""));
then (e_1, false, ((zeroCrossings, relations, samples, numRelations1, numMathFunctions), (eq_count, wc_count, vars, knvars)));
// function with discrete expressions generate no zerocrossing
Expand Down Expand Up @@ -685,7 +685,7 @@ algorithm
e_1 = DAE.LUNARY(op, e1);
{zc} = makeZeroCrossings({e_1}, {alg_indx}, {});
zc_lst = List.select1(zeroCrossings, sameZeroCrossing, zc);
zeroCrossings = Util.if_(List.isEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
zeroCrossings = Util.if_(listEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
Debug.fcall(Flags.RELIDX, BackendDump.debugExpStr, (e_1, "\n"));
then (e_1, false, (iterator, le, range, (zeroCrossings, relations, samples, numRelations, numMathFunctions), (alg_indx, vars, knvars)));
case ((e as DAE.LBINARY(exp1 = e1, operator = op, exp2 = e2)), (iterator, le, range, (zeroCrossings, relations, samples, numRelations, numMathFunctions), (alg_indx, vars, knvars)))
Expand All @@ -698,7 +698,7 @@ algorithm
e_1 = DAE.LBINARY(e_1, op, e_2);
{zc} = makeZeroCrossings({e_1}, {alg_indx}, {});
zc_lst = List.select1(zeroCrossings, sameZeroCrossing, zc);
zeroCrossings = Util.if_(List.isEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
zeroCrossings = Util.if_(listEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
print(Debug.fcallret1(Flags.RELIDX, BackendDump.zeroCrossingListString, zeroCrossings, ""));
then (e_1, false, (iterator, le, range, (zeroCrossings, relations, samples, numRelations1, numMathFunctions), (alg_indx, vars, knvars)));
// function with discrete expressions generate no zerocrossing
Expand Down Expand Up @@ -868,7 +868,7 @@ algorithm
e_1 = DAE.LUNARY(op, e1);
{zc} = makeZeroCrossings({e_1}, {alg_indx}, {});
zc_lst = List.select1(zeroCrossings, sameZeroCrossing, zc);
zeroCrossings = Util.if_(List.isEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
zeroCrossings = Util.if_(listEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
Debug.fcall(Flags.RELIDX, print, "collectZCAlgsFor LUNARY result zc : ");
Debug.fcall(Flags.RELIDX, BackendDump.debugExpStr, (e_1, "\n"));
then (e_1, false, (iterator, inExpLst, range, (zeroCrossings, relations, samples, numRelations, numMathFunctions), (alg_indx, vars, knvars)));
Expand Down Expand Up @@ -903,7 +903,7 @@ algorithm
e_1 = DAE.LBINARY(e_1, op, e_2);
{zc} = makeZeroCrossings({e_1}, {alg_indx}, {});
zc_lst = List.select1(zeroCrossings, sameZeroCrossing, zc);
zeroCrossings = Util.if_(List.isEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
zeroCrossings = Util.if_(listEmpty(zc_lst), listAppend(zeroCrossings, {zc}), zeroCrossings);
Debug.fcall(Flags.RELIDX, print, "collectZCAlgsFor LBINARY2 result zc : ");
Debug.fcall(Flags.RELIDX, print, BackendDump.zeroCrossingListString(zeroCrossings));
then (e_1, false, (iterator, inExpLst, range, (zeroCrossings, relations, samples, numRelations1, numMathFunctions), (alg_indx, vars, knvars)));
Expand Down
12 changes: 6 additions & 6 deletions Compiler/BackEnd/HpcOmEqSystems.mo
View file
Expand Up @@ -877,8 +877,8 @@ algorithm
rhs = varExp(a_ii);
hs_ii = BackendDAE.EQUATION(lhs,rhs,DAE.emptyElementSource,BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN);
// update th a_i_lst and the hs_i_lst
a_i_lstTmp = Debug.bcallret1(List.isEmpty(a_i_lstIn), List.create, {a_ii},varInFrontList(a_ii,a_i_lstIn));
hs_i_lstTmp = Debug.bcallret1(List.isEmpty(hs_i_lstIn), List.create, {hs_ii}, eqInFrontList(hs_ii,hs_i_lstIn));
a_i_lstTmp = Debug.bcallret1(listEmpty(a_i_lstIn), List.create, {a_ii},varInFrontList(a_ii,a_i_lstIn));
hs_i_lstTmp = Debug.bcallret1(listEmpty(hs_i_lstIn), List.create, {hs_ii}, eqInFrontList(hs_ii,hs_i_lstIn));
//next residual equation
(hs_i_lstTmp,a_i_lstTmp) = getTornSystemCoefficients1(resIdxRest,iIdx,resVal_iIn,hs_i_lstTmp,a_i_lstTmp,tornSysIdx);
then
Expand All @@ -904,8 +904,8 @@ algorithm
lhs = varExp(r_ii);
hs_ii = BackendDAE.EQUATION(lhs,rhs,DAE.emptyElementSource,BackendDAE.EQ_ATTR_DEFAULT_UNKNOWN);
// update th a_i_lst and the hs_i_lst
a_i_lstTmp = Debug.bcallret1(List.isEmpty(a_i_lstIn), List.create, {a_ii},varInFrontList(a_ii, a_i_lstIn));
hs_i_lstTmp = Debug.bcallret1(List.isEmpty(hs_i_lstIn), List.create, {hs_ii}, eqInFrontList(hs_ii, hs_i_lstIn));
a_i_lstTmp = Debug.bcallret1(listEmpty(a_i_lstIn), List.create, {a_ii},varInFrontList(a_ii, a_i_lstIn));
hs_i_lstTmp = Debug.bcallret1(listEmpty(hs_i_lstIn), List.create, {hs_ii}, eqInFrontList(hs_ii, hs_i_lstIn));
// next residual equation
(hs_i_lstTmp, a_i_lstTmp) = getTornSystemCoefficients1(resIdxRest, iIdx, resVal_iIn, hs_i_lstTmp, a_i_lstTmp,tornSysIdx);
then
Expand Down Expand Up @@ -1052,8 +1052,8 @@ algorithm
resVal := BackendDAE.VAR(resCRef,BackendDAE.VARIABLE(),DAE.BIDIR(),DAE.NON_PARALLEL(),ty,NONE(),NONE(),{},DAE.emptyElementSource,NONE(),NONE(),DAE.NON_CONNECTOR());
(resEq,(resExp,_)) := BackendEquation.traverseBackendDAEExpsEqn(resEq,addResidualVarToEquation2,(resExp,false));
// update the resEq and resVar lists
r_i_lst := Debug.bcallret1(List.isEmpty(r_i_lst), List.create, {resVal},varInFrontList(resVal,r_i_lst));
h_i_lst := Debug.bcallret1(List.isEmpty(h_i_lst), List.create, {resEq}, eqInFrontList(resEq,h_i_lst));
r_i_lst := Debug.bcallret1(listEmpty(r_i_lst), List.create, {resVal},varInFrontList(resVal,r_i_lst));
h_i_lst := Debug.bcallret1(listEmpty(h_i_lst), List.create, {resEq}, eqInFrontList(resEq,h_i_lst));
tplOut := (h_i_lst,r_i_lst);
end addResidualVarToEquation1;

Expand Down
16 changes: 8 additions & 8 deletions Compiler/BackEnd/HpcOmScheduler.mo
View file
Expand Up @@ -1184,7 +1184,7 @@ algorithm
graphT := BackendDAEUtil.transposeMatrix(iGraph,arrayLength(iGraph));

// assign initial level
//(_,startNodes) := List.filterOnTrueSync(arrayList(graphT),List.isEmpty,List.intRange(arrayLength(graphT)));
//(_,startNodes) := List.filterOnTrueSync(arrayList(graphT),listEmpty,List.intRange(arrayLength(graphT)));
//level := getGraphLevel(iGraph,{startNodes});
level := HpcOmTaskGraph.getLevelNodes(iGraph);
levelAss := arrayCreate(arrayLength(inComps),-1);
Expand Down Expand Up @@ -1490,7 +1490,7 @@ algorithm
clusterCostsTmp = List.map(mergedNodesIn,Util.tuple22);
clusterTmp = listReverse(List.map(mergedNodesIn,Util.tuple21));
cluster::clusterTmp = clusterTmp; // reverse the first cluster if there is only one cluster
cluster = Util.if_(List.isEmpty(clusterTmp),listReverse(cluster),cluster);
cluster = Util.if_(listEmpty(clusterTmp),listReverse(cluster),cluster);
clusterTmp = cluster::clusterTmp;
then (clusterTmp,clusterCostsTmp);
case(node::nodeRest,cost::costRest,_, {})
Expand Down Expand Up @@ -1568,7 +1568,7 @@ algorithm
HpcOmTaskGraph.TASKGRAPHMETA(inComps=inComps,varCompMapping=varCompMapping,eqCompMapping=eqCompMapping,rootNodes=rootNodes,nodeNames=nodeNames,nodeDescs=nodeDescs,exeCosts=exeCosts, commCosts=commCosts) := iMeta;

graphT := BackendDAEUtil.transposeMatrix(iGraph,arrayLength(iGraph));
//(_,startNodes) := List.filterOnTrueSync(arrayList(graphT),List.isEmpty,List.intRange(arrayLength(graphT)));
//(_,startNodes) := List.filterOnTrueSync(arrayList(graphT),listEmpty,List.intRange(arrayLength(graphT)));
//startNodes := HpcOmTaskGraph.getRootNodes(iGraph);
//print("startnodes "+&stringDelimitList(List.map(startNodes,intString),",")+&"\n");
//level := getGraphLevel(iGraph,{startNodes});
Expand Down Expand Up @@ -3842,7 +3842,7 @@ algorithm
parentAssgmnts = List.map1(parentsNofpred,Util.arrayGetIndexFirst,taskAssIn);
(_,unAssParents) = List.filter1OnTrueSync(parentAssgmnts,intEq,-1,parentsNofpred); // not yet assigned parents
// if there are unassigned parents, use them, otherwise all parents including fpred. take the one with the least execution cost
parents = Util.if_(List.isEmpty(unAssParents),parents,unAssParents);
parents = Util.if_(listEmpty(unAssParents),parents,unAssParents);
parentExeCost = List.map1(parents,HpcOmTaskGraph.getExeCostReqCycles,iTaskGraphMeta);
maxExeCost = List.fold(parentExeCost,realMax,0.0);
pos = List.position(maxExeCost,parentExeCost) + 1;
Expand Down Expand Up @@ -3923,7 +3923,7 @@ algorithm
case(_,_,_,_,_)
equation
parents = arrayGet(graphT,nodeIdx);
true = List.isEmpty(parents);
true = listEmpty(parents);
fpredOut = arrayUpdate(fpredIn,nodeIdx,0);
then fpredOut;
end matchcontinue;
Expand Down Expand Up @@ -4718,7 +4718,7 @@ algorithm
equation
// the current Node is a leaf node
childNodes = arrayGet(iTaskGraph,nodeIdx);
true = List.isEmpty(childNodes);
true = listEmpty(childNodes);
nodeExeCost = HpcOmTaskGraph.getExeCostReqCycles(nodeIdx,iTaskGraphMeta);
alap = arrayUpdate(alapIn,nodeIdx,nodeExeCost);
last = arrayUpdate(lastIn,nodeIdx,nodeExeCost);
Expand Down Expand Up @@ -5236,7 +5236,7 @@ algorithm
parentLst = arrayGet(taskGraphTIn,taskID);
// gets the parentIdcs which are not yet checked and computes the latest finishingTime of all parentNodes
((parentLst, latestTask)) = List.fold1(parentLst, updateFinishingTime1, checkedTasksIn, ({},HpcOmSimCode.TASKEMPTY()));
isComputable = List.isEmpty(parentLst);
isComputable = listEmpty(parentLst);
taskIdxNew = Util.if_(isComputable,taskIdxIn+1,taskIdxIn);
//update the threadTasks and checked Tasks
((threadTasks,checkedTasks)) = Debug.bcallret1(isComputable, computeFinishingTimeForOneTask, (threadTasksIn,checkedTasksIn,taskIdxIn,threadIdxIn,latestTask,taskGraphMetaIn),(threadTasksIn,checkedTasksIn));
Expand Down Expand Up @@ -5493,7 +5493,7 @@ protected function intListString
output String s;
algorithm
s := stringDelimitList(List.map(lstIn,intString)," , ");
s := Util.if_(List.isEmpty(lstIn),"{}",s);
s := Util.if_(listEmpty(lstIn),"{}",s);
end intListString;

protected function intListListString
Expand Down

0 comments on commit d276a6d

Please sign in to comment.