[NSim] add stop to sim iterator (#13839)

* [NSim] add stop to sim iterator
* [NB/Nsim] add sub iterator support
* [NB] add resizable for loop sim code and  inner sub iterators
* [NB] add proper order resolving of resizable loops
* [NB,Template] support resizable values for iterator ranges
* [testsuite] add new test case and fix old test

Author: kabdelhak

OMCompiler/Compiler/BackEnd/BackendDAE.mo

@@ -668,14 +668,18 @@ end ZeroCrossing;
 public uniontype SimIterator
   record SIM_ITERATOR_RANGE
     .DAE.ComponentRef name;
-    Integer start;
-    Integer step;
-    Integer size;
+    .DAE.Exp start;
+    .DAE.Exp step;
+    .DAE.Exp stop;
+    .DAE.Exp size;
+    Integer non_resizable_size;
+    list<tuple<.DAE.ComponentRef, array<.DAE.Exp>>> sub_iter;
   end SIM_ITERATOR_RANGE;
   record SIM_ITERATOR_LIST
     .DAE.ComponentRef name;
     list<Integer> lst;
     Integer size;
+    list<tuple<.DAE.ComponentRef, array<.DAE.Exp>>> sub_iter;
   end SIM_ITERATOR_LIST;
 end SimIterator;
 

OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo

@@ -601,7 +601,7 @@ protected
   Integer local_size;
 algorithm
   for iter in iters loop
-    local_size := match iter case BackendDAE.SIM_ITERATOR_RANGE() then iter.size; case BackendDAE.SIM_ITERATOR_LIST() then iter.size; end match;
+    local_size := match iter case BackendDAE.SIM_ITERATOR_RANGE() then iter.non_resizable_size; case BackendDAE.SIM_ITERATOR_LIST() then iter.size; end match;
     size := size * local_size;
   end for;
 end getSimIteratorSize;

OMCompiler/Compiler/BackEnd/BackendDump.mo

@@ -1820,7 +1820,7 @@ public function simIteratorString
   output String str;
 algorithm
   str := match iter
-    case BackendDAE.SIM_ITERATOR_RANGE()  then ComponentReference.printComponentRefStr(iter.name) + " in " + intString(iter.start) + ":" + intString(iter.step) + ":" + intString(iter.start + iter.size);
+    case BackendDAE.SIM_ITERATOR_RANGE()  then ComponentReference.printComponentRefStr(iter.name) + " in " + ExpressionDump.printExpStr(iter.start) + ":" + ExpressionDump.printExpStr(iter.step) + ":" + ExpressionDump.printExpStr(iter.stop);
     case BackendDAE.SIM_ITERATOR_LIST()   then ComponentReference.printComponentRefStr(iter.name) + " in " + List.toString(iter.lst, intString, "", "{", ", ", "}", true, 10);
   end match;
 end simIteratorString;

OMCompiler/Compiler/BackEnd/FindZeroCrossings.mo

@@ -54,6 +54,7 @@ import DAEUtil;
 import Error;
 import Expression;
 import ExpressionDump;
+import ExpressionSimplify;
 import Flags;
 import HashTableExpToIndex;
 import List;
@@ -1950,17 +1951,23 @@ protected function createIterator
 algorithm
   iter := match red_iter.exp
     local
-      DAE.Exp exp;
-      Integer start, step, stop;
+      DAE.Exp exp, step, size;
+      DAE.Type ty;
+      Integer non_resizable_size;
 
     case exp as DAE.RANGE() algorithm
-      start := DAEUtil.getInteger(exp.start);
-      step  := DAEUtil.getInteger(Util.getOptionOrDefault(exp.step, DAE.ICONST(1)));
-      stop  := DAEUtil.getInteger(exp.stop);
-    then BackendDAE.SIM_ITERATOR_RANGE(DAE.CREF_IDENT(red_iter.id, DAE.T_INTEGER_DEFAULT, {}), start, step, intDiv(stop-start, step) + 1);
+      ty    := Expression.typeof(exp.start);
+      step  := Util.getOptionOrDefault(exp.step, DAE.ICONST(1));
+      // build the size expression (stop-start)/step+1
+      size  := DAE.BINARY(exp.stop, DAE.SUB(ty), exp.start);
+      size  := DAE.BINARY(size, DAE.DIV(ty), step);
+      size  := DAE.BINARY(size, DAE.ADD(ty), DAE.ICONST(1));
+      size  := ExpressionSimplify.simplify(size);
+      non_resizable_size := Expression.getEvaluatedConstInteger(size);
+    then BackendDAE.SIM_ITERATOR_RANGE(DAE.CREF_IDENT(red_iter.id, DAE.T_INTEGER_DEFAULT, {}), exp.start, step, exp.stop, size, non_resizable_size, {});
 
     case exp as DAE.ARRAY() algorithm
-    then BackendDAE.SIM_ITERATOR_LIST(DAE.CREF_IDENT(red_iter.id, DAE.T_INTEGER_DEFAULT, {}), list(DAEUtil.getInteger(e) for e in exp.array), listLength(exp.array));
+    then BackendDAE.SIM_ITERATOR_LIST(DAE.CREF_IDENT(red_iter.id, DAE.T_INTEGER_DEFAULT, {}), list(DAEUtil.getInteger(e) for e in exp.array), listLength(exp.array), {});
 
     else algorithm
       Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed for expression: " + ExpressionDump.printExpStr(red_iter.exp) + ".\n"});

OMCompiler/Compiler/NBackEnd/Classes/NBEquation.mo

@@ -67,6 +67,7 @@ public
 
   // New Backend imports
   import DetectStates = NBDetectStates;
+  import NBResizable.EvalOrder;
   import Evaluation = NBEvaluation;
   import Inline = NBInline;
   import Replacements = NBReplacements;
@@ -875,6 +876,61 @@ public
       end match;
     end adaptArray;
 
+    function applyOrder
+      input output Iterator iter;
+      input UnorderedMap<ComponentRef, EvalOrder> order;
+      function applySingleOrder
+        input ComponentRef name;
+        input output Expression range;
+        input UnorderedMap<ComponentRef, EvalOrder> order;
+      protected
+        EvalOrder eo = UnorderedMap.getOrDefault(name, order, NBResizable.EvalOrder.INDEPENDENT);
+        Expression step, res;
+        list<Integer> elements;
+      algorithm
+        range := match range
+
+            // revert a range if needed
+            case Expression.RANGE() algorithm
+              step := Util.getOptionOrDefault(range.step, Expression.INTEGER(1));
+              if (Expression.isNegative(step) and eo == NBResizable.EvalOrder.FORWARD) or (Expression.isPositive(step) and eo == NBResizable.EvalOrder.BACKWARD) then
+                res := Expression.revertRange(range);
+              else
+                res := range;
+              end if;
+            then res;
+
+            // revert an array/list if needed
+            case Expression.ARRAY(literal = true) algorithm
+              if eo == NBResizable.EvalOrder.FORWARD then
+                elements := list(Expression.getInteger(e) for e in range.elements);
+                range.elements := listArray(list(Expression.INTEGER(e) for e in List.sort(elements, intGt)));
+              elseif eo == NBResizable.EvalOrder.BACKWARD then
+                elements := list(Expression.getInteger(e) for e in range.elements);
+                range.elements := listArray(list(Expression.INTEGER(e) for e in List.sort(elements, intLt)));
+              end if;
+            then range;
+
+            // no other allowed
+            else algorithm
+              Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed for unhandled range expression: " + Expression.toString(range)});
+            then fail();
+          end match;
+      end applySingleOrder;
+    algorithm
+      iter := match iter
+        case SINGLE() algorithm
+          iter.range := applySingleOrder(iter.name, iter.range, order);
+        then iter;
+        case NESTED() algorithm
+          for i in 1:arrayLength(iter.names) loop
+            iter.ranges[i] := applySingleOrder(iter.names[i], iter.ranges[i], order);
+          end for;
+        then iter;
+        else iter;
+      end match;
+    end applyOrder;
+
     function toString
       input Iterator iter;
       output String str = "";
@@ -2069,6 +2125,18 @@ public
       end match;
     end getForFrames;
 
+    function applyForOrder
+      input output Equation eqn;
+      input UnorderedMap<ComponentRef, EvalOrder> order;
+    algorithm
+      eqn := match eqn
+        case FOR_EQUATION() algorithm
+          eqn.iter := Iterator.applyOrder(eqn.iter, order);
+        then eqn;
+        else eqn;
+      end match;
+    end applyForOrder;
+
     function isDummy
       input Equation eqn;
       output Boolean b;

OMCompiler/Compiler/NBackEnd/Classes/NBVariable.mo

@@ -680,6 +680,20 @@ public
     end match;
   end updateResizableParameter;
 
+  function getResizableValue
+    input Pointer<Variable> var_ptr;
+    output Integer val;
+  protected
+    Variable var = Pointer.access(var_ptr);
+  algorithm
+    _ := match var.backendinfo
+      case BackendExtension.BACKEND_INFO(varKind = VariableKind.PARAMETER(resize_value = SOME(val))) then val;
+      else algorithm
+        Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because following variable is not a resizable parameter: " + toString(var)});
+      then fail();
+    end match;
+  end getResizableValue;
+
   function isResidual
     extends checkVar;
   algorithm

OMCompiler/Compiler/NBackEnd/Modules/3_Post/NBSolve.mo

@@ -259,6 +259,7 @@ public
           // ToDo 1: resolve the eval order
           // ToDo 2: resolve potential equation slicing
           (eqn, funcTree, solve_status, implicit_index, _) := solveEquation(Pointer.access(Slice.getT(comp.eqn)), comp.var_cref, funcTree, kind, implicit_index, slicing_map);
+          eqn := Equation.applyForOrder(eqn, comp.order);
           comp.eqn := Slice.SLICE(Pointer.create(eqn), comp.eqn.indices);
           comp.status := solve_status;
         then ({comp}, solve_status);
@@ -315,6 +316,7 @@ public
 
       // ToDo: make these actually resizable inside entwined equations (?)
       case StrongComponent.RESIZABLE_COMPONENT(var = var_slice, eqn = eqn_slice) guard(Equation.isForEquation(Slice.getT(eqn_slice))) algorithm
+        eqn_slice := Slice.apply(eqn_slice, function Pointer.apply(func = function Equation.applyForOrder(order = comp.order)));
         (comp, solve_status, funcTree, implicit_index) := solveGenericEquationSlice(var_slice, eqn_slice, comp.var_cref,  funcTree, kind, implicit_index, slicing_map);
       then (comp, solve_status);
 

OMCompiler/Compiler/NBackEnd/Util/NBResizable.mo

@@ -28,7 +28,7 @@
 * See the full OSMC Public License conditions for more details.
 *
 */
-encapsulated uniontype NBResizable<T>
+encapsulated uniontype NBResizable
 " file:         NBResizable.mo
   package:      NBResizable
   description:  This file contains util functions for resizable parameters.
@@ -228,6 +228,18 @@ public
     output Boolean b = eo == EvalOrder.FAILED;
   end orderFailed;
 
+  function orderString
+    input EvalOrder eo;
+    output String str;
+  algorithm
+    str := match eo
+      case EvalOrder.INDEPENDENT then "INDEPENDENT";
+      case EvalOrder.FORWARD then "FORWARD";
+      case EvalOrder.BACKWARD then "BACKWARD";
+      else "FAILED";
+    end match;
+  end orderString;
+
 protected
   type ParameterList = list<ComponentRef>;
   type ConstraintList = list<Expression>;

OMCompiler/Compiler/NFFrontEnd/NFExpression.mo

@@ -5062,8 +5062,8 @@ public
     end match;
   end logicNegate;
 
-  function invertRange
-    "inverts the direction of a range"
+  function revertRange
+    "reverts the direction of a range"
     input output Expression range;
   algorithm
     range := match range
@@ -5076,7 +5076,7 @@ public
           + toString(range)});
       then fail();
     end match;
-  end invertRange;
+  end revertRange;
 
   function sliceRange
     "slices the range with a given zero-based start and one-based step"

OMCompiler/Compiler/NSimCode/NSimCode.mo

@@ -132,11 +132,12 @@ public
     record IDENTIFIER
       Pointer<Equation> eqn;
       ComponentRef var_cref;
+      Boolean resizable;
     end IDENTIFIER;
 
     function toString
       input Identifier ident;
-      output String str = "cref: " + ComponentRef.toString(ident.var_cref) + "\neqn: " + Equation.pointerToString(ident.eqn);
+      output String str = "cref: " + ComponentRef.toString(ident.var_cref) + "\neqn: " + Equation.pointerToString(ident.eqn) + "\n(resizable="+boolString(ident.resizable)+")";
     end toString;
 
     function hash