Use proper format specifiers (#14446)

- Use proper format specifiers
- Remove some compiler warnings
- Avoid unnecessary tuples

Author: phannebohm

OMCompiler/Compiler/BackEnd/BackendDAE.mo

@@ -441,15 +441,15 @@ end WhenEquation;
 public
 uniontype WhenOperator
   record ASSIGN " left_cr = right_exp"
-    .DAE.Exp left     "left hand side of equation";
-    .DAE.Exp right             "right hand side of equation";
-    .DAE.ElementSource source  "origin of equation";
+    .DAE.Exp left             "left hand side of equation";
+    .DAE.Exp right            "right hand side of equation";
+    .DAE.ElementSource source "origin of equation";
   end ASSIGN;
 
   record REINIT "Reinit Statement"
     .DAE.ComponentRef stateVar "State variable to reinit";
-    .DAE.Exp value             "Value after reinit";
-    .DAE.ElementSource source  "origin of equation";
+    .DAE.Exp value            "Value after reinit";
+    .DAE.ElementSource source "origin of equation";
   end REINIT;
 
   record ASSERT

OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo

@@ -5777,21 +5777,20 @@ end getEqnAndVarsFromInnerEquation;
 
 public function getEqnAndVarsFromInnerEquationLst
   input BackendDAE.InnerEquations innerEquations;
-  output tuple<list<Integer>,list<list<Integer>>,list<BackendDAE.Constraints>> eqnVarConstTpl;
+  output list<Integer> eqns = {};
+  output list<list<Integer>> allVars = {};
+  output list<BackendDAE.Constraints> allConstraints = {};
 protected
   Integer eqn;
-  list<Integer> eqns = {}, vars;
-  list<list<Integer>> allVars = {};
+  list<Integer> vars;
   BackendDAE.Constraints constraints;
-  list<BackendDAE.Constraints> allConstraints = {};
 algorithm
   for innerEq in innerEquations loop
     (eqn,vars,constraints) := getEqnAndVarsFromInnerEquation(innerEq);
     eqns := eqn::eqns;
-    allVars := vars::allVars;
-    allConstraints := constraints::allConstraints;
+    if isPresent(allVars) then allVars := vars::allVars; end if;
+    if isPresent(allConstraints) then allConstraints := constraints::allConstraints; end if;
   end for;
-  eqnVarConstTpl := (eqns,allVars,allConstraints);
 end getEqnAndVarsFromInnerEquationLst;
 
 protected function transformSolvabilityForCasualTearingSet

OMCompiler/Compiler/BackEnd/DataReconciliation.mo

@@ -1050,7 +1050,7 @@ protected
   list<tuple<Integer, BackendDAE.Equation, list<Integer>>> unMeasuredVariablesAndEquations;
 algorithm
   for eq in unMeasuredEqsLst loop
-    (_, varIndex) := getSolvedVariableNumber(eq, solvedEqsAndVarsInfo);
+    varIndex := getSolvedVariableNumber(eq, solvedEqsAndVarsInfo);
     intermediateVars := getVariablesAfterExtraction({eq}, {}, sBltAdjacencyMatrix);
     intermediateVars := listReverse(List.setDifferenceOnTrue(intermediateVars, knownVars, intEq));
     //print("\n equation No: " + anyString(eq) + "==>" + anyString(varIndex));
@@ -1224,7 +1224,7 @@ algorithm
 
     // if status == false, prepare setB = {(var, equation to be removed)}
     if not status then
-      (_, varnumber) := getSolvedVariableNumber(eq, solvedEqsAndVarsInfo);
+      varnumber := getSolvedVariableNumber(eq, solvedEqsAndVarsInfo);
       if listEmpty(minimalSetS) then
         minimalSetS := {eq}; // first equation is detected as boundary condition equation
       end if;
@@ -1389,7 +1389,7 @@ algorithm
       break;
     end if;
 
-    (mappedEq, _) := getSolvedEquationNumber(varIndex, solvedEqsAndVarsInfo);
+    mappedEq := getSolvedEquationNumber(varIndex, solvedEqsAndVarsInfo);
 
     if not listMember(mappedEq, bindingEquations) then
       minimalSetS := mappedEq :: minimalSetS;
@@ -2134,7 +2134,7 @@ protected
   Integer varNumber;
 algorithm
   for eq in constantEquations loop
-    (_, varNumber) := getSolvedVariableNumber(eq, solvedEqsVarInfo);
+    varNumber := getSolvedVariableNumber(eq, solvedEqsVarInfo);
     constantVariables := varNumber :: constantVariables;
   end for;
 end getExactConstantVariables;
@@ -2148,7 +2148,7 @@ protected
   Integer varNumber;
 algorithm
   for eq in boundaryConditionEquations loop
-    (_, varNumber) := getSolvedVariableNumber(eq, solvedEqsVarInfo);
+    varNumber := getSolvedVariableNumber(eq, solvedEqsVarInfo);
     boundaryConditionVariables := varNumber :: boundaryConditionVariables;
   end for;
 end getBoundaryConditionVariables;
@@ -2219,7 +2219,7 @@ protected
   BackendDAE.Var var;
   BackendDAE.Equation tmpEq;
 algorithm
-  (_, varNumber) := getSolvedVariableNumber(eq, solvedEqsVarInfo);
+  varNumber := getSolvedVariableNumber(eq, solvedEqsVarInfo);
   var := BackendVariable.getVarAt(orderedVars, varNumber);
   mappedEq := mapIncRowEqn[eq];
   tmpEq := BackendEquation.get(orderedEqs, mappedEq);
@@ -2244,7 +2244,7 @@ algorithm
     print("\n" + heading + ":" + "(" + intString(listLength(tempSetS))  + ")" + "\n============================================================\n");
   end if;
   for eq in tempSetS loop
-    (_, varNumber) := getSolvedVariableNumber(eq, solvedEqsVarInfo);
+    varNumber := getSolvedVariableNumber(eq, solvedEqsVarInfo);
     var := BackendVariable.getVarAt(orderedVars, varNumber);
     mappedEq := mapIncRowEqn[eq];
     tmpEq := BackendEquation.get(orderedEqs, mappedEq);
@@ -2564,10 +2564,10 @@ public function checkBlueOrRedOrBrownBlocks
   output list<Integer> outIntegerList = {};
   output list<String> outStringList = {};
 protected
-  Integer eqNumber, varNumber;
+  Integer varNumber;
 algorithm
   for i in inlist loop
-    (eqNumber, varNumber) := getSolvedVariableNumber(i, solvedVar);
+    varNumber := getSolvedVariableNumber(i, solvedVar);
     // knownVars are named as knowns and belong to Blue Blocks
     if listMember(varNumber, knowns) then
       outStringList := "knowns" :: outStringList;
@@ -2590,14 +2590,13 @@ public function getSolvedVariableNumber
   "returns solvedvars based on the equation "
   input Integer eqnumber;
   input list<tuple<Integer, Integer>> inlist;
-  output tuple<Integer, Integer> mappedEqVar;
+  output Integer solvedvar;
 protected
-  Integer eq, solvedvar;
+  Integer solvedeq;
 algorithm
   for var in inlist loop
-    (eq, solvedvar):=var;
-    if intEq(eqnumber, eq) then
-      mappedEqVar := (eqnumber, solvedvar);
+    (solvedeq, solvedvar):=var;
+    if intEq(eqnumber, solvedeq) then
       return;
     end if;
   end for;
@@ -2607,14 +2606,13 @@ public function getSolvedEquationNumber
   "returns solvedeqs based on the variables "
   input Integer varnumber;
   input list<tuple<Integer, Integer>> inlist;
-  output tuple<Integer, Integer> mappedEqVar;
+  output Integer solvedeq;
 protected
-  Integer eq, solvedvar;
+  Integer solvedvar;
 algorithm
   for var in inlist loop
-    (eq, solvedvar) := var;
+    (solvedeq, solvedvar) := var;
     if intEq(varnumber, solvedvar) then
-      mappedEqVar := (eq, solvedvar);
       return;
     end if;
   end for;
@@ -2925,8 +2923,8 @@ protected
   list<Integer> t={}, nonsq, e_BltList;
   Integer eqnumber, varnumber;
 algorithm
-  for i in inlist loop
-    (eqnumber,varnumber) := getSolvedVariableNumber(i, solvedvariables);
+  for eqnumber in inlist loop
+    varnumber := getSolvedVariableNumber(eqnumber, solvedvariables);
     (nonsq, outEBLT) := getdirectOccurrencesinEquation(m, eqnumber, varnumber);
     //print(anyString(nonsq));
     for lst in nonsq loop

OMCompiler/Compiler/BackEnd/ExpressionSolve.mo

@@ -1195,7 +1195,6 @@ algorithm
   (x, y, new_x, eqnForNewVars, newVarsCrefs, odepth) := matchcontinue inExp1
     local
       DAE.Exp arg, e1, e_1, e, e2, exP, lhs, e3, e4, e5, e6, rhs, a1,x1, a2,x2, ee1, ee2;
-      tuple<DAE.Exp, DAE.Exp> a, c;
       list<DAE.Exp> z1, z2, z3, z4;
       DAE.ComponentRef cr;
       DAE.Type tp;
@@ -1256,10 +1255,8 @@ algorithm
 
         x2 := makeProductLstSort(z3);
         a2 := if Expression.isAdd(op1) then makeProductLstSort(z4) else Expression.negate(makeProductLstSort(z4));
-        a := simplifyBinaryMulCoeff(x1);
-        c := simplifyBinaryMulCoeff(x2);
-        (e2, e3) := a;
-        (e5, e6) := c;
+        (e2, e3) := simplifyBinaryMulCoeff(x1);
+        (e5, e6) := simplifyBinaryMulCoeff(x2);
         (lhs, rhs, eqnForNewVars_, newVarsCrefs_) := solveQE(a1,e2,e3,a2,e5,e6,inExp2,inExp3,ieqnForNewVars,inewVarsCrefs,uniqueEqIndex,idepth);
       then(lhs, rhs, true, eqnForNewVars_, newVarsCrefs_, idepth + 1);
 
@@ -1501,9 +1498,10 @@ end preprocessingSolveFunctionCall;
 protected function simplifyBinaryMulCoeff
 "generalization of ExpressionSimplify.simplifyBinaryMulCoeff2"
   input DAE.Exp inExp;
-  output tuple<DAE.Exp, DAE.Exp> outRes;
+  output DAE.Exp exp1;
+  output DAE.Exp exp2;
 algorithm
-  outRes := match(inExp)
+  (exp1, exp2) := match(inExp)
     local
       DAE.Exp e,e1,e2;
       DAE.Exp coeff;

OMCompiler/Compiler/BackEnd/HpcOmScheduler.mo

@@ -5206,7 +5206,7 @@ protected function quicksortWithOrder1
 algorithm
   (lstOut,orderOut) := match(lstIn,orderIn,pivotIdx,markedIn,size)
     local
-      Boolean b1,b2,b3;
+      Boolean b1,b2;
       Integer lIdx,rIdx,pivot;
       Real e,p,l,r,b;
       list<Integer> orderTmp;
@@ -5233,8 +5233,13 @@ algorithm
         lstTmp = if b2 then swapEntriesInList(pivotIdx,rIdx,lstTmp) else lstTmp;
         orderTmp = if b1 then swapEntriesInList(pivotIdx,lIdx,orderIn) else orderIn;
         orderTmp = if b2 then swapEntriesInList(pivotIdx,rIdx,orderTmp) else orderTmp;
-        b3 = boolAnd(boolNot(b1),boolNot(b2)); // if both are false(no member left or rigth found) than the pivot has the right place
-        ((marked,pivot)) = if b3 then getNextPivot(lstTmp,markedIn,pivotIdx) else ((markedIn,pivotIdx));
+        // if both are false(no member left or rigth found) than the pivot has the right place
+        if not b1 and not b2 then
+          (marked, pivot) = getNextPivot(lstTmp,markedIn,pivotIdx);
+        else
+          marked = markedIn;
+          pivot = pivotIdx;
+        end if;
 
         (lstTmp,orderTmp) = quicksortWithOrder1(lstTmp,orderTmp,pivot,marked,size);
       then
@@ -5247,13 +5252,14 @@ protected function getNextPivot "author:Waurich TUD 2013-11
   input list<Real> lstIn;
   input list<Real> markedLstIn;
   input Integer pivotIdx;
-  output tuple<list<Real>,Integer> tplOut;
+  output list<Real> marked;
+  output Integer newIdx;
 algorithm
-  tplOut := match(lstIn,markedLstIn,pivotIdx)
+  (marked, newIdx) := match(lstIn,markedLstIn,pivotIdx)
     local
-      Integer newIdx,midIdx;
+      Integer midIdx;
       Real pivotElement,r1,r2,r3,e;
-      list<Real> marked,rest;
+      list<Real> rest;
     case(_,{_},_)
       then
         (({},0));

OMCompiler/Compiler/BackEnd/SymbolicJacobian.mo

@@ -4643,7 +4643,7 @@ uniontype LinearJacobian
         // ToDo: updating the pivot row would also need an update for the rhs!
 
         for j in i+1:arrayLength(linJac.rows) loop
-          row_value := getElementValue(linJac.rows[j], col_index);
+          row_value := UnorderedMap.getOrDefault(col_index, linJac.rows[j], 0.0);
           if not realEq(row_value, 0.0) then
             // set row to processed and perform pivot step
             linJac.eq_marks[j] := true;
@@ -4721,7 +4721,7 @@ uniontype LinearJacobian
   algorithm
     if not realEq(piv_value, 1.0) then
       for idx in UnorderedMap.keyList(pivot_row) loop
-        SOME(value) := UnorderedMap.get(idx, pivot_row);
+        value := UnorderedMap.getOrFail(idx, pivot_row);
         UnorderedMap.add(idx, value/piv_value, pivot_row);
       end for;
     end if;
@@ -4731,32 +4731,18 @@ uniontype LinearJacobian
   "author: kabdelhak FHB 03-2021
    Returns the first element that can be chosen as pivot, fails if none can be chosen."
     input LinearJacobianRow pivot_row;
-    output tuple<Integer, Real> pivot_elem;
-  protected
-    Integer idx;
+    output Integer idx;
+    output Real value;
   algorithm
     if Vector.isEmpty(pivot_row.keys) then
       /* singular row */
       fail();
     else
       idx := UnorderedMap.firstKey(pivot_row);
-      pivot_elem := (idx, Util.getOption(UnorderedMap.get(idx, pivot_row)));
+      value := UnorderedMap.getOrFail(idx, pivot_row);
     end if;
   end getPivot;
 
-  protected function getElementValue
-  "author: kabdelhak FHB 03-2021
-   Returns the value at given column and zero if it does not exist in sparse structure."
-    input LinearJacobianRow row;
-    input Integer col_index;
-    output Real value;
-  algorithm
-    value := match UnorderedMap.get(col_index, row)
-      case SOME(value) then value;
-      else 0.0;
-    end match;
-  end getElementValue;
-
   public function resolveASSC
   "author: kabdelhak FHB 03-2021
    Resolves analytical singularities by replacing the equations with