OMCompiler/Compiler/NBackEnd/Util/NBSlice.mo - Linux GNU 11.4.0 Code Coverage Report

Directory:	./
Coverage:	low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
	Coverage	Exec / Excl / Total
Lines:	49.1%	286 / 0 / 583
Functions:	-%	0 / 1 / 1
Branches:	38.0%	212 / 0 / 558
    OMCompiler/Compiler/NBackEnd/Util/NBSlice.mo
    
        Line
        Branch
        Exec
        Source
      
        /*
      
         * This file is part of OpenModelica.
      
         *
      
         * Copyright (c) 1998-2026, Open Source Modelica Consortium (OSMC),
      
         * c/o Linköpings universitet, Department of Computer and Information Science,
      
         * SE-58183 Linköping, Sweden.
      
         *
      
         * All rights reserved.
      
         *
      
         * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF AGPL VERSION 3 LICENSE OR
      
         * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.8.
      
         * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES
      
         * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GNU AGPL
      
         * VERSION 3, ACCORDING TO RECIPIENTS CHOICE.
      
         *
      
         * The OpenModelica software and the OSMC (Open Source Modelica Consortium)
      
         * Public License (OSMC-PL) are obtained from OSMC, either from the above
      
         * address, from the URLs:
      
         * http://www.openmodelica.org or
      
         * https://github.com/OpenModelica/ or
      
         * http://www.ida.liu.se/projects/OpenModelica,
      
         * and in the OpenModelica distribution.
      
         *
      
         * GNU AGPL version 3 is obtained from:
      
         * https://www.gnu.org/licenses/licenses.html#GPL
      
         *
      
         * This program is distributed WITHOUT ANY WARRANTY; without
      
         * even the implied warranty of MERCHANTABILITY or FITNESS
      
         * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH
      
         * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL.
      
         *
      
         * See the full OSMC Public License conditions for more details.
      
         *
      
         */
      
        encapsulated uniontype NBSlice<T>
      
        " file:         NBSlice.mo
      
          package:      NBSlice
      
          description:  This file contains util functions for slicing operations.
      
        "
      
        protected
      
          import Slice = NBSlice;
      
          // NF imports
      
          import Call = NFCall;
      
          import ComplexType = NFComplexType;
      
          import ComponentRef = NFComponentRef;
      
          import Dimension = NFDimension;
      
          import Expression = NFExpression;
      
          import Operator = NFOperator;
      
          import SimplifyExp = NFSimplifyExp;
      
          import Subscript = NFSubscript;
      
          import Type = NFType;
      
          import NFPrefixes.Variability;
      
          import Variable = NFVariable;
      
          // NB imports
      
          import NBAdjacency.{IntMatrix, Mapping, Mode, ModeTable, Modes, Dependency};
      
          import BackendUtil = NBBackendUtil;
      
          import NBEquation.{Equation, Iterator, Frame, FrameLocation, RecollectStatus, FrameOrderingStatus};
      
          import Replacements = NBReplacements;
      
          import BVariable = NBVariable;
      
          import NBVariable.VariablePointers;
      
          // Util imports
      
          import List;
      
          import UnorderedMap;
      
        public
      
          type IntLst = list<Integer>;
      
          record SLICE
      
            T t;
      
            IntLst indices;
      
          end SLICE;
      
          // ############################################################
      
          //                Member Functions
      
          // ############################################################
      
          function getT
      
            input Slice<T> slice;
      
            output T t = slice.t;
      
          end getT;
      
          function hash
      
            input Slice<T> slice;
      
            input hashT func;
      
            output Integer h = func(slice.t);
      
          algorithm
      
            // first index should be unique enough
      
          2/2✓ Branch 1 taken 78 times.
✓ Branch 2 taken 6457 times.

        6535
            for i in List.firstOrEmpty(slice.indices) loop
      
        78
              h := stringHashDjb2Continue(intString(i), h);
      
            end for;
      
          end hash;
      
          function isEqual
      
            input Slice<T> slice1;
      
            input Slice<T> slice2;
      
            input isEqualT func;
      
            output Boolean b = func(slice1.t, slice2.t) and List.isEqualOnTrue(slice1.indices, slice2.indices, intEq);
      
          end isEqual;
      
          function toString
      
            input Slice<T> slice;
      
            input toStringT func;
      
            input Integer maxLength = 10;
      
            output String str;
      
          algorithm
      
          2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 27 times.

        48
            str := func(slice.t);
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
✓ Branch 2 taken 48 times.
✗ Branch 3 not taken.

        48
            if maxLength > 0 and not listEmpty(slice.indices) then
      
        ✗
              str := str + "\n\tslice: " + List.toStringCustom(inList = slice.indices, inPrintFunc = intString, maxLength = maxLength);
      
            end if;
      
          end toString;
      
          function lstToString
      
            input list<Slice<T>> lst;
      
            input toStringT_ func;
      
            input String indent = "";
      
            input Integer maxLength = 10;
      
            partial function toStringT_ = toStringT "ugly hack to make type T known to subfunction";
      
            output String str = List.toStringCustom(lst, function toString(func = func, maxLength = maxLength), "", indent, "\n" + indent, "", false);
      
          end lstToString;
      
          function isFull
      
            input Slice<T> slice;
      
            output Boolean b = listEmpty(slice.indices);
      
          end isFull;
      
          function size
      
            input Slice<T> slice;
      
            input sizeT func;
      
            output Integer s;
      
          algorithm
      
          2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 302 times.

        422
            if listEmpty(slice.indices) then
      
          1/2✓ Branch 0 taken 120 times.
✗ Branch 1 not taken.

        120
              s := func(slice.t);
      
            else
      
        302
              s := listLength(slice.indices);
      
            end if;
      
          end size;
      
          function simplify
      
            "only to be used for unordered purposes!
      
            lists of all indices are meaningful if they are not in the natural ascending order
      
            and can indicate range reversal in for loops."
      
            input output Slice<T> slice;
      
            input sizeT func;
      
          algorithm
      
          3/4✓ Branch 1 taken 8234 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 8160 times.
✓ Branch 6 taken 74 times.

        8234
            if listLength(slice.indices) == func(slice.t) then
      
        8160
              slice.indices := {};
      
            else
      
        74
              slice.indices := List.sort(slice.indices, intGt);
      
            end if;
      
          end simplify;
      
          function addToSliceMap
      
            input T t;
      
            input Integer i;
      
            input UnorderedMap<T, IntLst> map;
      
          algorithm
      
        37576
            UnorderedMap.add(t, i :: UnorderedMap.getOrDefault(t, map, {}), map);
      
          end addToSliceMap;
      
          function fromTpl
      
            input tuple<T, IntLst> tpl;
      
            output Slice<T> slice;
      
          protected
      
            T t;
      
            IntLst lst;
      
          algorithm
      
        8234
            (t, lst) := tpl;
      
        8234
            slice := SLICE(t, lst);
      
          end fromTpl;
      
          function fromMap
      
            input UnorderedMap<T, IntLst> map;
      
            output list<Slice<T>> slices = list(fromTpl(tpl) for tpl in UnorderedMap.toList(map));
      
          end fromMap;
      
          function apply
      
            input output Slice<T> slice;
      
            input applyT func;
      
          algorithm
      
          1/2✓ Branch 0 taken 1849 times.
✗ Branch 1 not taken.

        1849
            slice.t := func(slice.t);
      
          end apply;
      
          function applyMutable
      
            input Slice<T> slice;
      
            input applyMutableT func;
      
          algorithm
      
          1/2✓ Branch 0 taken 276 times.
✗ Branch 1 not taken.

        276
            func(slice.t);
      
          end applyMutable;
      
          function check<T2>
      
            input Slice<T> slice;
      
            input checkT func;
      
            output T2 t2 = func(slice.t);
      
          end check;
      
          // ############################################################
      
          //                Partial Functions
      
          // ############################################################
      
          partial function toStringT
      
            input T t;
      
            output String str;
      
          end toStringT;
      
          partial function sizeT
      
            input T t;
      
            output Integer s;
      
          end sizeT;
      
          partial function hashT
      
            input T t;
      
            output Integer i;
      
          end hashT;
      
          partial function isEqualT
      
            input T t1;
      
            input T t2;
      
            output Boolean b;
      
          end isEqualT;
      
          partial function applyT
      
            input output T t;
      
          end applyT;
      
          partial function applyMutableT
      
            input T t;
      
          end applyMutableT;
      
          partial function checkT<T2>
      
            input T t;
      
            output T2 t2;
      
          end checkT;
      
          partial function filterCref
      
            "partial function that needs to be provided.
      
            decides if the the cref is added to the list pointer."
      
            input output ComponentRef cref;
      
            input UnorderedSet<ComponentRef> acc;
      
          end filterCref;
      
          partial function getDependentCrefIndices
      
            input list<ComponentRef> dependencies                   "dependent var crefs";
      
            input UnorderedMap<ComponentRef, Integer> map           "unordered map to check for relevance";
      
            input Mapping mapping                                   "array <-> scalar index mapping";
      
            input Integer eqn_arr_idx;
      
            output array<list<Integer>> indices;
      
            output array<array<Integer>> mode_to_var;
      
          end getDependentCrefIndices;
      
          // ############################################################
      
          //                cref accumulation Functions
      
          // use with:
      
          //    Equation.collectCrefs()
      
          //    filterExp()
      
          // ############################################################
      
          function filterExp
      
            "wrapper function that applies filter cref to
      
            a cref expression."
      
            input output Expression exp;
      
            input filterCref filter;
      
            input UnorderedSet<ComponentRef> acc;
      
          algorithm
      
            () := match exp
      
              local
      
                Expression call_exp;
      
                Call call;
      
          2/2✓ Branch 0 taken 26939 times.
✓ Branch 1 taken 507 times.

        27446
              case Expression.CREF() algorithm filter(exp.cref, acc); then ();
      
              case Expression.CALL(call = call as Call.TYPED_REDUCTION(exp = call_exp)) algorithm
      
          2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.

        18
                for iter in call.iters loop
      
        9
                  call_exp := Expression.replaceIterator(call_exp, Util.tuple21(iter), Util.tuple22(iter));
      
                end for;
      
        9
                Expression.mapShallow(call_exp, function filterExp(filter = filter, acc = acc));
      
              then ();
      
              else algorithm
      
        31958
                Expression.mapShallow(exp, function filterExp(filter = filter, acc = acc));
      
              then ();
      
            end match;
      
          end filterExp;
      
          function getContinuous
      
            extends filterCref;
      
            input Boolean init;
      
          algorithm
      
          3/4✓ Branch 0 taken 189 times.
✗ Branch 1 not taken.
✓ Branch 5 taken 6 times.
✓ Branch 6 taken 183 times.

        378
            if BVariable.checkCref(cref, function BVariable.isContinuous(staticAsContinuous = init), sourceInfo()) then
      
        183
              UnorderedSet.add(cref, acc);
      
            end if;
      
          end getContinuous;
      
          function getSliceCandidates
      
            "Used to collect all slices of a certain variable name.
      
            Note: the name has to be stripped of all subscripts for this to work."
      
          extends filterCref;
      
            input ComponentRef name "the name of the variable";
      
          protected
      
            ComponentRef checkCref = ComponentRef.stripSubscriptsAll(cref);
      
          algorithm
      
            // check if the cref, the stripped version or the record parent are equal
      
          5/6✓ Branch 1 taken 23017 times.
✓ Branch 2 taken 2748 times.
✓ Branch 4 taken 21903 times.
✓ Branch 5 taken 1114 times.
✓ Branch 7 taken 21903 times.
✗ Branch 8 not taken.

        25765
            if ComponentRef.isEqual(name, checkCref) or ComponentRef.isEqual(name, cref) or ComponentRef.isEqualRecordChild(name, checkCref) then
      
        3862
              UnorderedSet.add(cref, acc);
      
            end if;
      
          end getSliceCandidates;
      
          function resolveSlicedCref
      
            "finds the cref referencing base_cref's variable inside eqn whose subscripted size
      
            matches target_size, e.g. picking i_s[{1, 2}] (size 2) out from a co-occurring whole
      
            reference i_s (size 3) in the same equation. Falls back to base_cref if no unique
      
            match is found."
      
            input ComponentRef base_cref "variable name, stripped of subscripts";
      
            input Equation eqn;
      
            input Integer target_size;
      
            output ComponentRef cref = base_cref;
      
          protected
      
            list<ComponentRef> candidates, filtered;
      
          algorithm
      
        ✗
            if target_size > 0 then
      
        ✗
              candidates := Equation.collectCrefs(eqn, function getSliceCandidates(name = base_cref));
      
        ✗
              filtered := list(c for c guard(Type.sizeOf(ComponentRef.getSubscriptedType(c), true) == target_size) in candidates);
      
        ✗
              if List.hasOneElement(filtered) then
      
        ✗
                cref := listHead(filtered);
      
              end if;
      
            end if;
      
          end resolveSlicedCref;
      
          function getDependentCref
      
            "checks if crefs are relevant in the given context and collects them."
      
          extends filterCref;
      
            input UnorderedMap<ComponentRef, Integer> map "unordered map to check for relevance";
      
            input Boolean pseudo;
      
          protected
      
            ComponentRef checkCref, childCref;
      
            list<Pointer<Variable>> record_children;
      
          algorithm
      
            // if causalized in pseudo array mode, the variables will only have subscript-free variables
      
          1/2✓ Branch 0 taken 1781 times.
✗ Branch 1 not taken.

        1781
            checkCref := if pseudo then ComponentRef.stripSubscriptsAll(cref) else cref;
      
        1781
            record_children := BVariable.getRecordChildren(BVariable.getVarPointer(checkCref, sourceInfo()));
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1781 times.

        1781
            if listEmpty(record_children) then
      
              // not a record
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1781 times.

        1781
              if UnorderedMap.contains(checkCref, map) then
      
        ✗
                UnorderedSet.add(cref, acc);
      
              end if;
      
            else
      
              // its a record, instead parse all the children
      
        ✗
              for child in record_children loop
      
        ✗
                childCref := BVariable.getVarName(child);
      
        ✗
                if UnorderedMap.contains(childCref, map) then
      
        ✗
                  UnorderedSet.add(childCref, acc);
      
                end if;
      
              end for;
      
            end if;
      
          end getDependentCref;
      
          function getDependentCrefCausalized
      
            "checks if crefs are relevant in the given context and collects them.
      
            previously found crefs are replaced by their dependencies! only works on causalized systems."
      
          extends filterCref;
      
            input UnorderedSet<ComponentRef> set "unordered set to check for array crefs for relevance";
      
          protected
      
            ComponentRef checkCref, childCref;
      
            list<Pointer<Variable>> record_children;
      
          algorithm
      
            // always remove subscripts here, this analysis is for sparsity pattern -> currently always scalarized!
      
        ✗
            checkCref := ComponentRef.stripSubscriptsAll(cref);
      
        ✗
            record_children := BVariable.getRecordChildren(BVariable.getVarPointer(checkCref, sourceInfo()));
      
        ✗
            if listEmpty(record_children) then
      
              // not a record
      
        ✗
              if UnorderedSet.contains(checkCref, set) then
      
        ✗
                UnorderedSet.add(cref, acc);
      
              end if;
      
            else
      
              // its a record, instead parse all the children
      
        ✗
              for child in record_children loop
      
        ✗
                childCref := BVariable.getVarName(child);
      
        ✗
                if UnorderedSet.contains(childCref, set) then
      
        ✗
                  UnorderedSet.add(childCref, acc);
      
                end if;
      
              end for;
      
            end if;
      
          end getDependentCrefCausalized;
      
          function getUnsolvableExpCrefs
      
            "finds all unsolvable crefs in an expression."
      
            input output Expression exp                   "the exp to check for unsolvable crefs";
      
            input UnorderedSet<ComponentRef> acc          "accumulator for relevant crefs";
      
            input UnorderedMap<ComponentRef, Integer> map "unordered map to check for relevance";
      
            input Boolean pseudo;
      
          algorithm
      
            // put all unsolvable logic here!
      
            exp := match exp
      
        ✗
              case Expression.RANGE()     then Expression.mapShallow(exp, function filterExp(filter = function getDependentCref(map = map, pseudo = pseudo), acc = acc));
      
        ✗
              case Expression.LBINARY()   then Expression.mapShallow(exp, function filterExp(filter = function getDependentCref(map = map, pseudo = pseudo), acc = acc));
      
        ✗
              case Expression.RELATION()  then Expression.mapShallow(exp, function filterExp(filter = function getDependentCref(map = map, pseudo = pseudo), acc = acc));
      
              else exp;
      
            end match;
      
          end getUnsolvableExpCrefs;
      
          function getDependentCrefIndicesPseudoScalar
      
            "Scalar equations.
      
            Turns cref dependencies into index lists, used for adjacency."
      
            input list<ComponentRef> dependencies         "dependent var crefs";
      
            input UnorderedMap<ComponentRef, Integer> map "unordered map to check for relevance";
      
            input Mapping mapping                         "array <-> scalar index mapping";
      
            output list<Integer> indices = {};
      
          protected
      
            list<ComponentRef> scalarized_dependencies = List.flatten(list(ComponentRef.scalarizeAll(dep, true) for dep in dependencies));
      
            ComponentRef stripped;
      
            Integer var_arr_idx, var_start, var_scal_idx;
      
            list<Integer> sizes, int_subs;
      
          algorithm
      
        ✗
            for cref in scalarized_dependencies loop
      
        ✗
              stripped := ComponentRef.stripSubscriptsAll(cref);
      
        ✗
              var_arr_idx := UnorderedMap.getSafe(stripped, map, sourceInfo());
      
        ✗
              (var_start, _) := mapping.var_AtS[var_arr_idx];
      
              // the sizes of the scalarization (resized, like the mapping)
      
        ✗
              sizes := ComponentRef.sizes(stripped, false, true);
      
        ✗
              int_subs := ComponentRef.subscriptsToInteger(cref);
      
        ✗
              var_scal_idx := locationToIndex(sizes, int_subs, var_start);
      
              indices := var_scal_idx :: indices;
      
            end for;
      
            // remove duplicates and sort
      
        ✗
            if not listEmpty(indices) then
      
        ✗
              indices := List.sort(List.uniqueIntN(indices, max(i for i in indices)), intLt);
      
            end if;
      
          end getDependentCrefIndicesPseudoScalar;
      
          function getDependentCrefIndicesPseudoFull
      
            "equations that will get full dependency.
      
            Turns cref dependencies into index lists, used for adjacency."
      
            extends getDependentCrefIndices;
      
          protected
      
            list<ComponentRef> scalarized_dependencies = List.flatten(list(ComponentRef.scalarizeAll(dep, true) for dep in dependencies));
      
            ComponentRef stripped;
      
            Integer eqn_start, eqn_size, var_arr_idx, var_scal_idx, mode = 1;
      
            list<Integer> scal_lst;
      
            Integer idx;
      
            array<Integer> mode_to_var_row;
      
            list<Subscript> subs;
      
            list<Dimension> dims;
      
            Type ty;
      
          algorithm
      
        ✗
            (eqn_start, eqn_size) := mapping.eqn_AtS[eqn_arr_idx];
      
        ✗
            indices := arrayCreate(eqn_size, {});
      
        ✗
            mode_to_var := arrayCreate(eqn_size, arrayCreate(0,0));
      
            // create unique array for each equation
      
        ✗
            for i in 1:eqn_size loop
      
        ✗
              mode_to_var[i] := arrayCreate(listLength(scalarized_dependencies),-1);
      
            end for;
      
        ✗
            for cref in scalarized_dependencies loop
      
        ✗
              stripped := ComponentRef.stripSubscriptsAll(cref);
      
        ✗
              var_arr_idx := UnorderedMap.getSafe(stripped, map, sourceInfo());
      
              // build range in reverse, it will be flipped anyway
      
        ✗
              subs := ComponentRef.subscriptsAllWithWholeFlat(cref);
      
        ✗
              ty := ComponentRef.getSubscriptedType(stripped, true);
      
        ✗
              dims := Type.arrayDims(ty);
      
        ✗
              scal_lst := Mapping.getVarScalIndices(var_arr_idx, mapping, subs, dims, true);
      
        ✗
              if intMod(eqn_size, listLength(scal_lst)) <> 0 then
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName()
      
                  + " failed because flattened indices " + intString(listLength(scal_lst))
      
                  + " could not be repeated to fit equation size " + intString(eqn_size) + ". lst: " + List.toString(scal_lst, intString)});
      
        ✗
                fail();
      
              else
      
                // fill the equation with repeated scalar lists
      
        ✗
                scal_lst := List.repeat(scal_lst, intDiv(eqn_size, listLength(scal_lst)));
      
              end if;
      
              idx := 1;
      
        ✗
              for var_scal_idx in listReverse(scal_lst) loop
      
        ✗
                mode_to_var_row := mode_to_var[idx];
      
        ✗
                arrayUpdate(mode_to_var_row, mode, var_scal_idx);
      
        ✗
                arrayUpdate(mode_to_var, idx, mode_to_var_row);
      
        ✗
                indices[idx] := var_scal_idx :: indices[idx];
      
        ✗
                idx := idx + 1;
      
              end for;
      
        ✗
              mode := mode + 1;
      
            end for;
      
            // sort
      
        ✗
            for i in 1:arrayLength(indices) loop
      
        ✗
              indices[i] := List.sort(UnorderedSet.unique_list(indices[i], Util.id, intEq), intLt);
      
            end for;
      
          end getDependentCrefIndicesPseudoFull;
      
          function getDependentCrefIndicesPseudoFor
      
            "For-Loop equations.
      
            Turns cref dependencies into index lists, used for adjacency."
      
            extends getDependentCrefIndices;
      
            input Iterator iter                                     "iterator frames";
      
          protected
      
            list<ComponentRef> names;
      
            list<Expression> ranges;
      
            list<Option<Iterator>> maps;
      
            list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            Integer eqn_size, iter_size, body_size, mode = 1;
      
            updateDependencies func;
      
          algorithm
      
            // get iterator size and frames
      
        ✗
            iter_size := Iterator.size(iter);
      
        ✗
            (names, ranges, maps) := Iterator.getFrames(iter);
      
        ✗
            frames := List.zip3(names, ranges, maps);
      
            // get eqn size and create the adjacency matrix and causalization mode arrays
      
        ✗
            (_, eqn_size) := mapping.eqn_AtS[eqn_arr_idx];
      
        ✗
            indices := arrayCreate(eqn_size, {});
      
        ✗
            mode_to_var := arrayCreate(eqn_size, arrayCreate(0,0));
      
            // sanity check for eqn size and get size of body equation
      
        ✗
            if mod(eqn_size, iter_size) == 0 then
      
        ✗
              body_size := intDiv(eqn_size, iter_size);
      
            else
      
        ✗
              Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName()
      
                + " failed because the equation size " + intString(eqn_size)
      
                + " could not be divided by the iterator size " + intString(iter_size) + " without rest."});
      
        ✗
              fail();
      
            end if;
      
            // create unique array for each equation
      
        ✗
            for i in 1:eqn_size loop
      
        ✗
              mode_to_var[i] := arrayCreate(listLength(dependencies),-1);
      
            end for;
      
            // create rows
      
        ✗
            for dep in dependencies loop
      
        ✗
              func := function updateDependenciesInteger(mode = mode, mode_to_var = mode_to_var, indices = indices);
      
              // var_arr_idx not needed for this
      
        ✗
              fillDependencyArray(dep, body_size, frames, mapping, map, func, 0, true);
      
              // increase mode index
      
        ✗
              mode := mode + 1;
      
            end for;
      
            // sort (kabdelhak: is this needed? try to FixMe)
      
        ✗
            for i in 1:arrayLength(indices) loop
      
        ✗
              indices[i] := List.sort(UnorderedSet.unique_list(indices[i], Util.id, intEq), intLt);
      
            end for;
      
          end getDependentCrefIndicesPseudoFor;
      
          function getDependentCrefsPseudoForCausalized
      
            "(Jacobian) For-Loop equations.
      
            Turns cref dependencies into index lists, used for adjacency."
      
            input ComponentRef row_cref                                   "cref representing the current row";
      
            input list<ComponentRef> dependencies                         "dependent var crefs";
      
            input VariablePointers var_rep                                "scalarized variable representatives";
      
            input VariablePointers eqn_rep                                "scalarized equation representatives";
      
            input Mapping var_rep_mapping                                 "index mapping for variable representatives";
      
            input Mapping eqn_rep_mapping                                 "index mapping for equation representatives";
      
            input Iterator iter                                           "iterator frames";
      
            input Integer eqn_size                                        "full equation size (not considering the slice)";
      
            input list<Integer> slice = {}                                "optional slice, empty list implies full slice";
      
            input Boolean implicit = false                                "do not compute row cref indices if implicit";
      
            output list<tuple<ComponentRef, list<ComponentRef>>> tpl_lst  "cref -> dependencies for each scalar cref";
      
          protected
      
            list<ComponentRef> names;
      
            list<Expression> ranges;
      
            list<Option<Iterator>> maps;
      
            list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            Integer iter_size, body_size, var_arr_idx;
      
            list<ComponentRef> row_crefs;
      
            list<Integer> row_scal_lst;
      
            list<list<Integer>> accum_row_lst = {};
      
            array<list<ComponentRef>> accum_dep_arr;
      
            list<list<ComponentRef>> accum_dep_lst;
      
            updateDependencies func_var, func_eqn;
      
            ComponentRef final_dep;
      
          algorithm
      
            // create the array of maximum equation size and slice afterwards
      
        ✗
            accum_dep_arr := arrayCreate(eqn_size, {});
      
            // get iterator size and frames
      
        ✗
            iter_size := Iterator.size(iter);
      
        ✗
            (names, ranges, maps) := Iterator.getFrames(iter);
      
        ✗
            frames := List.zip3(names, ranges, maps);
      
            // sanity check for eqn size and get size of body equation
      
        ✗
            if mod(eqn_size, iter_size) == 0 then
      
        ✗
              body_size := intDiv(eqn_size, iter_size);
      
            else
      
        ✗
              Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName()
      
                + " failed because the equation size " + intString(eqn_size)
      
                + " could not be divided by the iterator size " + intString(iter_size) + " without rest."});
      
        ✗
              fail();
      
            end if;
      
            // get row cref lst
      
        ✗
            if implicit then
      
        ✗
              row_crefs := ComponentRef.scalarizeSlice(row_cref, slice, false);
      
            else
      
        ✗
              for cref in ComponentRef.scalarizeAll(row_cref, false) loop
      
        ✗
                row_scal_lst  := getCrefInFrameIndices(cref, frames, eqn_rep_mapping, eqn_rep.map, false);
      
                accum_row_lst := row_scal_lst :: accum_row_lst;
      
              end for;
      
        ✗
              row_scal_lst  := List.flatten(accum_row_lst);
      
        ✗
              row_scal_lst  := if listEmpty(slice) or listLength(slice) > listLength(row_scal_lst) then row_scal_lst else List.getAtIndexLst(row_scal_lst, slice, true);
      
        ✗
              row_crefs     := list(VariablePointers.varSlice(eqn_rep, i, eqn_rep_mapping.var_StA[i], eqn_rep_mapping, false) for i in row_scal_lst);
      
            end if;
      
            // prepare the functions to update dependencies
      
        ✗
            func_var := function updateDependenciesCref(accum_dep_arr = accum_dep_arr, vars = var_rep, mapping = var_rep_mapping, resize = false);
      
        ✗
            func_eqn := function updateDependenciesCref(accum_dep_arr = accum_dep_arr, vars = eqn_rep, mapping = eqn_rep_mapping, resize = false);
      
        ✗
            for dep in dependencies loop
      
        ✗
              if UnorderedMap.contains(dep, var_rep.map) then
      
        ✗
                (final_dep, var_arr_idx) := getVarArrIdx(dep, var_rep_mapping, var_rep.map);
      
        ✗
                fillDependencyArray(final_dep, body_size, frames, var_rep_mapping, var_rep.map, func_var, var_arr_idx, false);
      
              elseif UnorderedMap.contains(dep, eqn_rep.map) then
      
        ✗
                (final_dep, var_arr_idx) := getVarArrIdx(dep, eqn_rep_mapping, eqn_rep.map);
      
        ✗
                fillDependencyArray(final_dep, body_size, frames, eqn_rep_mapping, eqn_rep.map, func_eqn, var_arr_idx, false);
      
              end if;
      
            end for;
      
        ✗
            accum_dep_lst := listReverse(arrayList(accum_dep_arr));
      
        ✗
            accum_dep_lst := if listEmpty(slice) or listLength(slice) > listLength(accum_dep_lst) then accum_dep_lst else List.getAtIndexLst(accum_dep_lst, slice, true);
      
        ✗
            tpl_lst := List.zip(row_crefs, accum_dep_lst);
      
          end getDependentCrefsPseudoForCausalized;
      
          function fillDependencyArray
      
            "body function of getDependentCrefsPseudoFor and getDependentCrefsPseudoForCausalized
      
            this generates all entries to jacobian or adjacency matrices for a specific dependency.
      
            This dependency might be an array cref, part of a reduction or contain slices."
      
            input ComponentRef dep;
      
            input Integer body_size;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            input Mapping mapping;
      
            input UnorderedMap<ComponentRef, Integer> map;
      
            input updateDependencies func;
      
            input Integer var_arr_idx;
      
            input Boolean resize;
      
          protected
      
            ComponentRef scal_cref;
      
            Integer scal_length, body_repeat, element_repeat, eqn_idx;
      
            list<Integer> scal_lst;
      
            list<tuple<ComponentRef, list<Integer>>> scal_tpl_lst = {};
      
          algorithm
      
            // get all dependencies for each scalarized cref
      
            // Note: scalarization does not remove the iterators, therefore it can still yield
      
            //   multiple scalar indices when evaluated along the iterator frames
      
        ✗
            for scal_cref in ComponentRef.scalarizeAll(dep, true) loop
      
        ✗
              scal_lst := getCrefInFrameIndices(scal_cref, frames, mapping, map, resize);
      
        ✗
              scal_tpl_lst := (scal_cref, scal_lst) :: scal_tpl_lst;
      
            end for;
      
            // check wether or not the element has to be repeated to fit the body
      
        ✗
            scal_length := listLength(scal_tpl_lst);
      
        ✗
            if mod(scal_length, body_size) == 0 then
      
              // body has to be repeated
      
        ✗
              body_repeat := intDiv(scal_length, body_size);
      
              element_repeat := 1;
      
            elseif mod(body_size, scal_length) == 0 then
      
              // element has to be repeated
      
              body_repeat := 1;
      
        ✗
              element_repeat := intDiv(body_size, scal_length);
      
            else
      
        ✗
              Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName()
      
                + " failed because number of flattened indices " + intString(scal_length)
      
                + " for dependency " + ComponentRef.toString(dep)
      
                + " could not be divided by or repeated to fit the body size " + intString(body_size) + " without rest."});
      
        ✗
              fail();
      
            end if;
      
            eqn_idx := 1;
      
            // repeat the elements to fit the equation
      
        ✗
            for i in 1:element_repeat loop
      
        ✗
              for tpl in listReverse(scal_tpl_lst) loop
      
        ✗
                (scal_cref, scal_lst) := tpl;
      
                // reverse the scalar index list to traverse it in the correct order
      
        ✗
                scal_lst := listReverse(scal_lst);
      
                // check if body_repeat > 1 to set the causalization mode to -1 for unsolvable
      
        ✗
                if body_repeat > 1 then
      
                  // reset the counter to 1 if the body is supposed to be repeated
      
                  // ToDo: reductions are only tested for body equations of size 1!
      
                  eqn_idx := 1;
      
                end if;
      
        ✗
                for var_idx in scal_lst loop
      
                  // we now know that there is a dependency of equation (eqn_idx) to variable (var_idx)
      
                  // call the function that adds this specific variable to the correct structure
      
        ✗
                  if var_idx > 0 then
      
        ✗
                    eqn_idx := func(eqn_idx, var_idx, var_arr_idx);
      
                  end if;
      
                end for;
      
              end for;
      
            end for;
      
          end fillDependencyArray;
      
          partial function updateDependencies
      
            input output Integer eqn_idx;
      
            input Integer var_idx;
      
            input Integer var_arr_idx;
      
          end updateDependencies;
      
          function updateDependenciesCref
      
            "(jacobian) adds the variable of (var_idx) as a dependency to (eqn_idx)
      
            jacobian depencies are stored as component references"
      
            extends updateDependencies;
      
            input array<list<ComponentRef>> accum_dep_arr;
      
            input VariablePointers vars;
      
            input Mapping mapping;
      
            input Boolean resize;
      
          algorithm
      
        ✗
            arrayUpdate(accum_dep_arr, eqn_idx, VariablePointers.varSlice(vars, var_idx, var_arr_idx, mapping, resize) :: accum_dep_arr[eqn_idx]);
      
        ✗
            eqn_idx := eqn_idx + 1;
      
          end updateDependenciesCref;
      
          function updateDependenciesInteger
      
            "(adjacency) adds the variable of (var_idx) as a dependency to (eqn_idx)
      
            adjacency dependencies are stored as integers
      
            also updates the causalization modes"
      
            extends updateDependencies;
      
            input Integer mode;
      
            input array<array<Integer>> mode_to_var;  //mutable
      
            input array<list<Integer>> indices;       //mutable
      
          protected
      
            array<Integer> mode_to_var_row;
      
          algorithm
      
            // get the clean pointer to the scalar row to avoid double indexing (meta modelica jank)
      
        ✗
            mode_to_var_row := mode_to_var[eqn_idx];
      
            // set the dependency mode for this scalar equation to the scalar variable
      
        ✗
            arrayUpdate(mode_to_var_row, mode, var_idx);
      
            // this is the adjacency matrix row. each dependency cref
      
            // will add exactly one integer to each row belonging to this for-equation
      
        ✗
            arrayUpdate(indices, eqn_idx, var_idx :: indices[eqn_idx]);
      
        ✗
            eqn_idx := eqn_idx + 1;
      
          end updateDependenciesInteger;
      
          function getDependentCrefsPseudoArrayCausalized
      
            "Array equations.
      
            Turns cref dependencies into index lists, used for adjacency."
      
            input ComponentRef row_cref                                   "cref representing the current row";
      
            input list<ComponentRef> dependencies                         "dependent var crefs";
      
            input list<Integer> slice = {}                                "optional slice, empty list means all";
      
            output list<tuple<ComponentRef, list<ComponentRef>>> tpl_lst  "cref -> dependencies for each scalar cref";
      
          protected
      
            list<ComponentRef> row_cref_scal, dependencies_resizable;
      
            Integer row_size;
      
            list<list<ComponentRef>> dependencies_scal;
      
            Pointer<list<ComponentRef>> full_deps = Pointer.create({});
      
            function fixSingleDep
      
              "helper function to properly add a single dependency"
      
              input Integer row_size;
      
              input output list<ComponentRef> single_dep;
      
              input Pointer<list<ComponentRef>> full_deps;
      
            protected
      
              Integer dep_size = listLength(single_dep);
      
            algorithm
      
        ✗
              if row_size > dep_size then
      
                // repeat the element until it fits
      
        ✗
                if intMod(row_size, dep_size) == 0 then
      
        ✗
                  single_dep := List.repeat(single_dep, intDiv(row_size, dep_size));
      
                else
      
        ✗
                  Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because dependencies of size " + intString(dep_size)
      
                    + " could not be repeated to fit row size " + intString(row_size) + "."});
      
        ✗
                  fail();
      
                end if;
      
              elseif row_size < dep_size then
      
                // assume full dependency (not entirely correct but practical)
      
        ✗
                Pointer.update(full_deps, listAppend(single_dep, Pointer.access(full_deps)));
      
                single_dep := {};
      
              end if;
      
            end fixSingleDep;
      
          algorithm
      
        ✗
            row_cref_scal := ComponentRef.scalarizeSlice(row_cref, slice, false);
      
        ✗
            row_size      := listLength(row_cref_scal);
      
        ✗
            dependencies_resizable  := list(ComponentRef.simplifySubscripts(ComponentRef.mapExp(dep, Expression.replaceResizableParameterWithOriginal)) for dep in dependencies);
      
        ✗
            dependencies_scal       := list(ComponentRef.scalarizeSlice(dep, slice, false) for dep in dependencies_resizable);
      
        ✗
            if not listEmpty(dependencies_scal) then
      
              // repeat lists that are too short to fit the equation size and collect full dependencies
      
        ✗
              dependencies_scal := list(fixSingleDep(row_size, d, full_deps) for d in dependencies_scal);
      
        ✗
              dependencies_scal := list(d for d guard(not listEmpty(d)) in dependencies_scal);
      
              // transpose it such that each list now represents one row
      
        ✗
              if listEmpty(dependencies_scal) then
      
        ✗
                dependencies_scal := List.fill(Pointer.access(full_deps), row_size);
      
              else
      
        ✗
                dependencies_scal := list(listAppend(Pointer.access(full_deps), d) for d in List.transposeList(dependencies_scal));
      
              end if;
      
        ✗
              tpl_lst := List.zip(row_cref_scal, dependencies_scal);
      
            else
      
        ✗
              tpl_lst := list((cref, {}) for cref in row_cref_scal);
      
            end if;
      
          end getDependentCrefsPseudoArrayCausalized;
      
          function locationToIndex
      
            "reverse function to indexToLocation()
      
            maps a frame location to a scalar index starting from first index (one based!)"
      
            input list<Integer> sizes;
      
            input list<Integer> values;
      
            input output Integer index;
      
          protected
      
            Integer factor = 1, val, siz;
      
            list<Integer> val_trav = values, siz_trav = sizes;
      
          algorithm
      
          3/4✓ Branch 0 taken 10419 times.
✓ Branch 1 taken 4893 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10419 times.

        15312
            while not (listEmpty(val_trav) or listEmpty(siz_trav)) loop
      
        10419
              val :: val_trav := val_trav;
      
        10419
              siz :: siz_trav := siz_trav;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10419 times.

        10419
              if val > siz then
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because value of " + intString(val)
      
                  + " is too large for size " + intString(siz) + "."});
      
        ✗
                fail();
      
              end if;
      
        10419
              index := index + (val - 1) * factor;
      
        10419
              factor := factor * siz;
      
            end while;
      
          end locationToIndex;
      
          function indexToLocation
      
            "reverse function to locationToIndex()
      
            maps a scalar index to its frame location (zero based!)"
      
            input Integer index;
      
            input list<Integer> sizes;
      
            output list<Integer> vals = {};
      
          protected
      
            Integer iterator = index;
      
            Integer divisor = product(s for s in sizes);
      
          algorithm
      
          2/2✓ Branch 0 taken 2975 times.
✓ Branch 1 taken 7095 times.

        10070
            for size in sizes loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2975 times.

        2975
              divisor   := intDiv(divisor, size);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2975 times.

        2975
              vals      := intDiv(iterator, divisor) :: vals;
      
              iterator  := mod(iterator, divisor);
      
            end for;
      
          end indexToLocation;
      
          function transposeLocations
      
            "transpose the location indices.
      
            Before:   Each inner list of indices represents a scalar equations
      
                      location inside all of the dimensions
      
            After:    Each inner array of indices represents the location of all
      
                      scalar equations for just one of the dimensions.
      
                      (still in order from Sorting)"
      
            input list<list<Integer>> locations;
      
            input Integer out_size;
      
            output list<array<Integer>> locations_transposed;
      
          protected
      
            array<list<Integer>> lT_tmp = arrayCreate(out_size, {});
      
            array<array<Integer>> lT_tmp2 = arrayCreate(out_size, arrayCreate(0,0));
      
            Integer idx;
      
          algorithm
      
        ✗
            for location in locations loop
      
              idx := 1;
      
        ✗
              for i in location loop
      
        ✗
                lT_tmp[idx] := i :: lT_tmp[idx];
      
        ✗
                idx := idx + 1;
      
              end for;
      
            end for;
      
        ✗
            for j in 1:arrayLength(lT_tmp) loop
      
        ✗
              lT_tmp2[j] := listArray(listReverse(lT_tmp[j]));
      
            end for;
      
        ✗
            locations_transposed := listReverse(arrayList(lT_tmp2));
      
          end transposeLocations;
      
          function orderTransposedFrameLocations
      
            "order the frame locations by ascending inertia.
      
            (the longer the chain of equal values at the start, the higher the inertia)
      
            This is done to perform necessary reordering of nested for-loops"
      
            input output list<FrameLocation> frame_locations_transposed;
      
            output UnorderedMap<ComponentRef, Expression> replacements = UnorderedMap.new<Expression>(ComponentRef.hash, ComponentRef.isEqual);
      
            output FrameOrderingStatus status;
      
          protected
      
            list<tuple<Integer, FrameLocation>> frame_inertia_lst;
      
          algorithm
      
            // get inertia for each frame
      
        ✗
            frame_inertia_lst := list((frameLocationInertia(frame), frame) for frame in frame_locations_transposed);
      
            // sort by inertia (ascending)
      
        ✗
            frame_inertia_lst := List.sort(frame_inertia_lst, Util.compareTupleIntGt);
      
            // resolve equal inertia (diagonal slices)
      
        ✗
            (frame_inertia_lst, status) := resolveEqualInertia(frame_inertia_lst, replacements);
      
        ✗
            frame_locations_transposed := list(Util.tuple22(frame_inertia) for frame_inertia in frame_inertia_lst);
      
          end orderTransposedFrameLocations;
      
          protected function frameLocationInertia
      
            "the longer the chain of equal values at the start, the higher the inertia"
      
            input FrameLocation frameLocation;
      
            output Integer inertia = 1;
      
          protected
      
            array<Integer> dim;
      
          algorithm
      
        ✗
            dim := Util.tuple21(frameLocation);
      
        ✗
            while inertia < arrayLength(dim) and dim[inertia] == dim[inertia+1] loop
      
              inertia := inertia + 1;
      
            end while;
      
          end frameLocationInertia;
      
          protected function resolveEqualInertia
      
            "Squashing all equal inertia frames (nested loops) into one.
      
            Equal inertia for frames shows that they 'fire' at the same time.
      
            These frames have to change in one step, therefore they should be merged to
      
            a single one."
      
            input list<tuple<Integer, FrameLocation>> frame_inertia_lst;
      
            input UnorderedMap<ComponentRef, Expression> replacements;
      
            output list<tuple<Integer, FrameLocation>> resolved = {};
      
            output FrameOrderingStatus status = NBEquation.FrameOrderingStatus.UNCHANGED;
      
          protected
      
            tuple<Integer, FrameLocation> tpl1, tpl2;
      
            list<tuple<Integer, FrameLocation>> rest;
      
          algorithm
      
        ✗
            tpl1 :: rest := frame_inertia_lst;
      
        ✗
            while not listEmpty(rest) loop
      
        ✗
              tpl2 :: rest := rest;
      
              tpl1 := match (tpl1, tpl2)
      
                local
      
                  Integer inertia1, inertia2, m, b;
      
                  array<Integer> loc1, loc2;
      
                  ComponentRef name1, name2;
      
                  Operator addOp, mulOp;
      
                  Expression linMap;
      
                // equal inertia, combine the frames
      
                case ((inertia1, (loc1, (name1, _, _))), (inertia2, (loc2, (name2, _, _)))) guard(inertia1 == inertia2) algorithm
      
        ✗
                  addOp := Operator.fromClassification((NFOperator.MathClassification.ADDITION, NFOperator.SizeClassification.SCALAR), Type.INTEGER());
      
        ✗
                  mulOp := Operator.fromClassification((NFOperator.MathClassification.MULTIPLICATION, NFOperator.SizeClassification.SCALAR), Type.INTEGER());
      
        ✗
                  if arrayLength(loc1) <> arrayLength(loc2) then
      
                    status := NBEquation.FrameOrderingStatus.FAILURE;
      
        ✗
                    return;
      
                  elseif arrayLength(loc1) == 1 then
      
        ✗
                    b := loc2[1] - loc1[1];
      
        ✗
                    linMap := Expression.fromCref(name1);
      
        ✗
                    if b <> 0 then
      
        ✗
                      linMap := Expression.MULTARY({Expression.INTEGER(b), linMap}, {}, addOp);
      
                    end if;
      
        ✗
                    UnorderedMap.add(name2, linMap, replacements);
      
                    status := NBEquation.FrameOrderingStatus.CHANGED;
      
                  else
      
                    // compute linear map from frame1 to frame2 (y = m*x + b)
      
                    // ToDo: integer to real conversion might be wrong?
      
        ✗
                    m := realInt((loc2[1]-loc2[1+inertia2])/(loc1[1]-loc1[1+inertia1]));
      
        ✗
                    b := loc2[1]-m*loc1[1];
      
                    // check if linear map holds
      
        ✗
                    for i in 2:arrayLength(loc1) loop
      
        ✗
                      if loc2[i] <> m*loc1[i] + b then
      
                        status := NBEquation.FrameOrderingStatus.FAILURE;
      
        ✗
                        return;
      
                      end if;
      
                    end for;
      
        ✗
                    linMap := Expression.fromCref(name1);
      
        ✗
                    if m <> 1 then
      
        ✗
                      linMap := Expression.MULTARY({Expression.INTEGER(m), linMap}, {}, mulOp);
      
                    end if;
      
        ✗
                    if b <> 0 then
      
        ✗
                      linMap := Expression.MULTARY({Expression.INTEGER(b), linMap}, {}, addOp);
      
                    end if;
      
        ✗
                    UnorderedMap.add(name2, linMap, replacements);
      
                    status := NBEquation.FrameOrderingStatus.CHANGED;
      
                  end if;
      
                then tpl1;
      
                // different inertia
      
                else algorithm
      
                  resolved := tpl1 :: resolved;
      
                then tpl2;
      
              end match;
      
            end while;
      
        ✗
            resolved := listReverse(tpl1 :: resolved);
      
          end resolveEqualInertia;
      
          public function recollectRangesHeuristic
      
            "consecutively builds up the new frames from frame locations.
      
            Assumes that slicing along the dimensions is possible.
      
            Basic Idea:
      
              1. iterate over each frame location
      
              2. take first (start) and second (stop) element of frame dim to start the search for a pattern (step = stop - start)
      
              3. shift the stop location further until the step changes and safe the start-step-stop pattern
      
                3.1 iterate over the rest of the dim and check if the pattern holds for all of it
      
                3.2 if it not holds search a missing diagonal for this dimension (reconstruct diagonal)
      
              4. increase the shift for the length of the previous pattern and go to next frame location (shifting happens inherently in step 3)"
      
            input list<FrameLocation> frame_locations_transposed;
      
            output list<Frame> frames = {};
      
            output Option<UnorderedMap<ComponentRef, Expression>> removed_diagonal = NONE();
      
            output RecollectStatus status;
      
          protected
      
            array<Integer> dim;
      
            Frame frame;
      
            Integer check_shift, pre_shift, shift = 1;
      
            Integer start, step, stop, max_size, new_step, new_stop, check_stop;
      
            Boolean fail_;
      
            list<Integer> starts = {}, stops = {}, steps = {}, shifts = {};
      
            list<Boolean> failed = {};
      
            Integer min_dim, max_dim;
      
            list<FrameLocation> diagonal;
      
            UnorderedMap<ComponentRef, Expression> replacements;
      
            FrameOrderingStatus fos;
      
          algorithm
      
        ✗
            for tpl in frame_locations_transposed loop
      
              // 1. iterate over each frame location
      
              fail_ := false;
      
        ✗
              (dim, frame) := tpl;
      
              pre_shift := shift;
      
              max_size := arrayLength(dim);
      
        ✗
              if max_size == 1 then
      
                // if there is only one frame, it is a single equation at that exact point
      
        ✗
                frames := applyNewFrameRange(frame, (dim[1], 1, dim[1])) :: frames;
      
                starts := dim[1] :: starts;
      
                steps := 0 :: steps;
      
                stops := dim[1] :: stops;
      
                shifts := shift :: shifts;
      
              else
      
                // 2. take first (start) and second (stop) element of frame dim to start the search for a pattern (step = stop - start)
      
        ✗
                start := dim[1];
      
        ✗
                stop := dim[1 + shift];
      
        ✗
                step := stop - start;
      
        ✗
                if step == 0 then
      
                  // if the step size is zero, this range only has a single entry
      
                  // this should not happen?
      
        ✗
                  frames := applyNewFrameRange(frame, (start, 1, stop)) :: frames;
      
                  starts := start :: starts;
      
                  steps := step :: steps;
      
                  stops := stop :: stops;
      
                  shifts := shift :: shifts;
      
                else
      
                  // 3. shift the stop location further until the step changes and safe the start-step-stop pattern
      
                  new_step := step;
      
                  new_stop := stop;
      
        ✗
                  while (new_step == step) and (shift + pre_shift < max_size) loop
      
                    stop := new_stop;
      
                    shift := shift + pre_shift;
      
        ✗
                    new_stop := dim[1 + shift];
      
        ✗
                    new_step := new_stop - stop;
      
                  end while;
      
        ✗
                  if new_step == step then
      
                    // if new_step and step are still equal we hit the end (max_size)
      
                    stop := new_stop;
      
        ✗
                    shift := shift + pre_shift; //not necessary but more correct
      
                  else
      
                    // 3.1 iterate over the rest of the dim and check if the pattern holds for all of it
      
                    check_shift := shift;
      
        ✗
                    while (check_shift + pre_shift < max_size) loop
      
                      new_step := step;
      
        ✗
                      while (new_step == step) and (check_shift + pre_shift < max_size) loop
      
                        check_stop := new_stop;
      
                        check_shift := check_shift + pre_shift;
      
        ✗
                        new_stop := dim[1 + check_shift];
      
        ✗
                        new_step := new_stop - check_stop;
      
                      end while;
      
                      // has to be the same amount of steps after the step size changes
      
        ✗
                      if (check_shift + pre_shift == max_size) then
      
                        check_shift := check_shift + pre_shift;
      
                      end if;
      
        ✗
                      if not intMod(check_shift, shift) == 0 then
      
                        fail_ := true;
      
                        break;
      
                      end if;
      
                    end while;
      
                  end if;
      
                  // use max/min dim instead of start and stop because the start or end
      
                  // could be missing (missing diagonals)
      
        ✗
                  min_dim := min(d for d in dim);
      
        ✗
                  max_dim := max(d for d in dim);
      
        ✗
                  if fail_ then
      
        ✗
                    if step > 0 then
      
        ✗
                      frames := applyNewFrameRange(frame, (min_dim, step, max_dim)) :: frames;
      
                    else
      
        ✗
                      frames := applyNewFrameRange(frame, (max_dim, step, min_dim)) :: frames;
      
                    end if;
      
                  else
      
        ✗
                    frames := applyNewFrameRange(frame, (start, step, stop)) :: frames;
      
                  end if;
      
                  steps := step :: steps;
      
        ✗
                  starts := if step > 0 then min_dim :: starts else max_dim :: starts;
      
        ✗
                  stops := if step > 0 then max_dim :: stops else min_dim :: stops;
      
                  shifts := shift :: shifts;
      
        ✗
                  failed := fail_ :: failed;
      
                end if;
      
              end if;
      
            end for;
      
            // 3.2 if it not holds search a missing diagonal for this dimension (reconstruct diagonal)
      
            // if any dimension was not consistent, try to find a missing diagonal
      
            // it is stored in an unordered map as linear map for the indices
      
        ✗
            if List.fold(failed, boolOr, false) then
      
        ✗
              diagonal := reconstructDiagonal(frame_locations_transposed, listReverse(starts), listReverse(steps), listReverse(stops), listReverse(shifts), listReverse(failed));
      
        ✗
              (diagonal, replacements, fos) := orderTransposedFrameLocations(diagonal);
      
        ✗
              if fos == NBEquation.FrameOrderingStatus.CHANGED then
      
        ✗
                removed_diagonal := SOME(replacements);
      
                status := NBEquation.RecollectStatus.SUCCESS;
      
              else
      
                // no equal inertia to resolve or unable to resolve
      
                status := NBEquation.RecollectStatus.FAILURE;
      
              end if;
      
            else
      
              status := NBEquation.RecollectStatus.SUCCESS;
      
            end if;
      
          end recollectRangesHeuristic;
      
          function reconstructDiagonal
      
            "reconstructs a supposed missing diagonal if it exists.
      
            ToDo1: create multiple diagonals if missing indices are found in one go without reset"
      
            input list<FrameLocation> frame_locations_transposed;
      
            input list<Integer> starts;
      
            input list<Integer> steps;
      
            input list<Integer> stops;
      
            input list<Integer> shifts;
      
            input list<Boolean> failed;
      
            output list<FrameLocation> diagonal = {};
      
          protected
      
            Integer start, step, stop, pos, shift = 1;
      
            Boolean fail_;
      
            list<Integer> start_rest = starts, step_rest = steps, stop_rest = stops, shift_rest = shifts;
      
            list<Boolean> fail_rest = failed;
      
            array<Integer> dim;
      
            list<Integer> missing_dims;
      
            Frame frame;
      
          algorithm
      
            // ToDo: all lists have to be of equal length!
      
            // default first shift to 1
      
        ✗
            for tpl in frame_locations_transposed loop
      
              // get dims and frame from tpl
      
        ✗
              (dim, frame) := tpl;
      
              // take out start, step, stop, fail
      
        ✗
              start :: start_rest := start_rest;
      
        ✗
              step :: step_rest := step_rest;
      
        ✗
              stop :: stop_rest := stop_rest;
      
        ✗
              fail_ :: fail_rest := fail_rest;
      
              // initialize missing dims and pos
      
              missing_dims := {};
      
              pos := start;
      
        ✗
              if fail_ then
      
        ✗
                for i in 1:shift:arrayLength(dim) loop
      
        ✗
                  while dim[i] <> pos loop
      
                    // ToDo1
      
                    missing_dims := pos :: missing_dims;
      
        ✗
                    pos := pos + step;
      
        ✗
                    if (sign(step)*pos > sign(step)*stop) then
      
                      break;
      
                    end if;
      
                  end while;
      
        ✗
                  if (sign(step)*(pos+step) > sign(step)*stop) then
      
                    pos := start;
      
                  else
      
                    pos := pos + step;
      
                  end if;
      
                end for;
      
        ✗
                while sign(step)*pos <= sign(step)*stop loop
      
                  missing_dims := pos :: missing_dims;
      
        ✗
                  pos := pos + step;
      
                end while;
      
              else
      
        ✗
                for i in 1:shift:arrayLength(dim) loop
      
        ✗
                  missing_dims := dim[i] :: missing_dims;
      
                end for;
      
              end if;
      
        ✗
              diagonal := (listArray(listReverse(missing_dims)), frame) :: diagonal;
      
              // take out shift from shifts
      
        ✗
              shift :: shift_rest := shift_rest;
      
            end for;
      
        ✗
            diagonal := listReverse(diagonal);
      
          end reconstructDiagonal;
      
          function naiveSeparation
      
            input list<Integer> indices "assumed to be sorted";
      
            output list<list<Integer>> index_clusters = {};
      
          protected
      
            Integer i;
      
            list<Integer> rest, current = {};
      
          algorithm
      
        ✗
            if not listEmpty(indices) then
      
        ✗
              i :: rest := listReverse(indices);
      
              current := {i};
      
        ✗
              for i2 in rest loop
      
        ✗
                if i-i2 == 1 then
      
                  current := i2 :: current;
      
                else
      
                  index_clusters := current :: index_clusters;
      
                  current := {i2};
      
                end if;
      
                i := i2;
      
              end for;
      
              index_clusters := current :: index_clusters;
      
            end if;
      
          end naiveSeparation;
      
          // #### KAB ### new adjacency util
      
          function upgradeRowFull
      
            "Scalar equations.
      
            Turns cref dependencies into index lists, used for adjacency."
      
            input list<ComponentRef> dependencies         "dependent var crefs";
      
            input UnorderedMap<ComponentRef, Integer> map "unordered map to check for relevance";
      
            input Mapping mapping                         "array <-> scalar index mapping";
      
            output list<Integer> indices = {};
      
          protected
      
            list<ComponentRef> scalarized_dependencies = List.flatten(list(ComponentRef.scalarizeAll(dep, true) for dep in dependencies));
      
            ComponentRef replaced, stripped;
      
            Integer var_arr_idx, var_start, var_scal_idx;
      
          algorithm
      
          2/2✓ Branch 0 taken 233 times.
✓ Branch 1 taken 747 times.

        980
            for cref in scalarized_dependencies loop
      
        233
              (replaced, stripped)  := getReplacedAndStripped(cref);
      
        233
              var_arr_idx           := UnorderedMap.getSafe(stripped, map, sourceInfo());
      
        233
              (var_start, _)        := mapping.var_AtS[var_arr_idx];
      
        233
              var_scal_idx          := indexFromReplacedStripped(replaced, stripped, var_start, resize = true);
      
              indices               := var_scal_idx :: indices;
      
            end for;
      
          end upgradeRowFull;
      
          function upgradeRow
      
            "For-Loop equations.
      
            Turns cref dependencies into index lists, used for adjacency."
      
            input ComponentRef eqn_name;
      
            input Integer eqn_arr_idx;
      
            input Iterator iter                                     "iterator frames";
      
            input Type ty;
      
            input list<ComponentRef> dependencies                   "dependent var crefs";
      
            input UnorderedMap<ComponentRef, Dependency> dep        "dependency map";
      
            input UnorderedSet<ComponentRef> rep                    "repetition set";
      
            input UnorderedMap<ComponentRef, Integer> map           "unordered map to check for relevance";
      
            input UnorderedMap<ComponentRef, Integer> fullmap       "unordered map to check for general relevance";
      
            input IntMatrix.Builder m;
      
            input Mapping mapping                                   "array <-> scalar index mapping";
      
            input ModeTable modes;
      
          algorithm
      
          2/2✓ Branch 0 taken 24044 times.
✓ Branch 1 taken 23441 times.

        47485
            for cref in dependencies loop
      
        24044
              resolveDependency(cref, eqn_name, eqn_arr_idx, iter, ty, dep, rep, map, fullmap, m, mapping, modes);
      
            end for;
      
          end upgradeRow;
      
          function getSingleIndex
      
            input ComponentRef cref;
      
            output Integer index;
      
          protected
      
            ComponentRef replaced, stripped;
      
          algorithm
      
        ✗
            (replaced, stripped)  := getReplacedAndStripped(cref);
      
        ✗
            index                 := indexFromReplacedStripped(replaced, stripped, 0);
      
          end getSingleIndex;
      
          // ############################################################
      
          //                Protected Functions
      
          // ############################################################
      
        protected
      
          function getReplacedAndStripped
      
            input ComponentRef cref;
      
            output ComponentRef replaced;
      
            output ComponentRef stripped;
      
          algorithm
      
            // remove all resizable parameters from cref
      
        233
            replaced  := ComponentRef.mapExp(cref, Expression.replaceResizableParameter);
      
        233
            replaced  := ComponentRef.simplifySubscripts(replaced);
      
            // remove all subscripts from cref
      
        233
            stripped  := ComponentRef.stripSubscriptsAll(replaced);
      
          end getReplacedAndStripped;
      
          function indexFromReplacedStripped
      
            input ComponentRef replaced;
      
            input ComponentRef stripped;
      
            input Integer var_start;
      
            input Boolean resize = false "the sizes of resizable dimensions as resized, like scalarizeAll(cref, true)";
      
            output Integer index;
      
          protected
      
            list<Integer> sizes, int_subs;
      
          algorithm
      
            // get the sizes and subscripts as integers and compute the final scalar index
      
        233
            sizes     := ComponentRef.sizes(stripped, false, resize);
      
        233
            int_subs  := ComponentRef.subscriptsToInteger(replaced);
      
        233
            index     := locationToIndex(sizes, int_subs, var_start);
      
          end indexFromReplacedStripped;
      
          function resolveSkipsLst
      
            input Integer index;
      
            input Type ty;
      
            input list<list<Integer>> skips;
      
            input ComponentRef cref;
      
            input UnorderedMap<ComponentRef, Integer> fullmap       "unordered map to check for general relevance";
      
            output list<tuple<Integer, Type>> skip_lst = {};
      
          protected
      
            list<list<Integer>> combinations = List.combination(skips);
      
            Integer sub_idx;
      
            Type sub_ty;
      
          algorithm
      
          2/2✓ Branch 0 taken 611 times.
✓ Branch 1 taken 21965 times.

        22576
            if listEmpty(combinations) then
      
        21965
              skip_lst := {(index, ty)};
      
            else
      
          2/2✓ Branch 0 taken 926 times.
✓ Branch 1 taken 611 times.

        1537
              for com in combinations loop
      
        926
                (sub_idx, sub_ty) := resolveSkips(index, ty, com, cref, fullmap);
      
        926
                skip_lst := (sub_idx, sub_ty) :: skip_lst;
      
              end for;
      
            end if;
      
          end resolveSkipsLst;
      
          function resolveSkips
      
            input output Integer index;
      
            input output Type ty;
      
            input list<Integer> skips;
      
            input ComponentRef cref;
      
            input UnorderedMap<ComponentRef, Integer> fullmap       "unordered map to check for general relevance";
      
          algorithm
      
            (index, ty) := match (ty, skips)
      
              local
      
                Integer skip;
      
                list<Integer> rest, tail;
      
                list<Dimension> rest_dim, tail_dim;
      
                Type sub_ty;
      
                list<Type> rest_ty;
      
                Pointer<Variable> parent;
      
                list<ComponentRef> crefs;
      
                ComponentRef field;
      
                list<list<Subscript>> subs;
      
              // 0 skips are full dependencies
      
              case (Type.TUPLE(), 0::_) then (index, ty);
      
              // skip to a tuple element
      
              case (Type.TUPLE(types = rest_ty), skip::rest) guard(skip <= listLength(rest_ty)) algorithm
      
                // skip to the desired sub type and shift the starting index accordingly
      
          2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.

        4
                for i in 1:skip-1 loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

        2
                  sub_ty :: rest_ty := rest_ty;
      
        2
                  index := index + Type.sizeOf(sub_ty);
      
                end for;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
                sub_ty :: rest_ty := rest_ty;
      
                // see if there is nested skips
      
        927
              then resolveSkips(index, sub_ty, rest, cref, fullmap);
      
              // skip to a record element
      
              case (Type.COMPLEX(complexTy = ComplexType.RECORD()), skip::rest) algorithm
      
                // get the children and skip to correct one
      
                field := match BVariable.getParent(BVariable.getVarPointer(cref, sourceInfo()))
      
                  case SOME(parent) algorithm
      
        314
                    subs := ComponentRef.subscriptsAll(cref);
      
                    // the skip counts all fields, but only the relevant ones (e.g. not removed aliases) have an index
      
          4/4✓ Branch 1 taken 850 times.
✓ Branch 2 taken 314 times.
✓ Branch 3 taken 850 times.
✓ Branch 4 taken 314 times.

        1164
                    crefs :=  list(BVariable.getVarName(child) for child in BVariable.getRecordChildren(parent));
      
          1/2✓ Branch 1 taken 314 times.
✗ Branch 2 not taken.

        314
                    if skip <= listLength(crefs) then
      
          2/2✓ Branch 0 taken 180 times.
✓ Branch 1 taken 134 times.

        576
                      for i in 1:skip-1 loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 262 times.

        262
                        field :: crefs := crefs;
      
          2/2✓ Branch 1 taken 250 times.
✓ Branch 2 taken 12 times.

        262
                        if UnorderedMap.contains(field, fullmap) then
      
        250
                          field := ComponentRef.setSubscriptsList(subs, field);
      
        250
                          index := index + Type.sizeOf(ComponentRef.getSubscriptedType(field));
      
                        end if;
      
                      end for;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 314 times.

        314
                      field :: crefs := crefs;
      
        314
                      field := ComponentRef.setSubscriptsList(subs, field);
      
                    else
      
        ✗
                      Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because skip of " + intString(skip)
      
                        + " is too large for record elements " + List.toString(crefs, ComponentRef.toString) + "."});
      
        ✗
                      fail();
      
                    end if;
      
                  then field;
      
                  else algorithm
      
        ✗
                    Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because skip of " + intString(skip)
      
                      + " for type " + Type.toString(ty) + " is requested, but the cref is not part of a record: " + ComponentRef.toString(cref) + "."});
      
        ✗
                  then fail();
      
                end match;
      
                // see if there is nested skips
      
        314
              then resolveSkips(index, ComponentRef.getSubscriptedType(field), rest, cref, fullmap);
      
              // size one arrays do not have a skip associated
      
              case (Type.ARRAY(), rest) guard(Dimension.sizesProduct(ty.dimensions, true) == 1) algorithm
      
        1
              then resolveSkips(index, ty.elementType, rest, cref, fullmap);
      
              // skip to an array element with more or equal skips to dimensions
      
              case (Type.ARRAY(), rest) guard List.compareLength(rest, ty.dimensions) >= 0 algorithm
      
        608
                (rest, tail) := List.split(rest, listLength(ty.dimensions));
      
                // locationToIndex expects the innermost dimension first
      
          4/4✓ Branch 0 taken 608 times.
✓ Branch 1 taken 608 times.
✓ Branch 2 taken 608 times.
✓ Branch 3 taken 608 times.

        1216
                index := locationToIndex(listReverse(list(Dimension.size(dim, true) for dim in ty.dimensions)), listReverse(rest), index);
      
        608
              then resolveSkips(index, ty.elementType, tail, cref, fullmap);
      
              // skip to an array with less skips then dimensions
      
              case (Type.ARRAY(), rest) algorithm
      
        83
                (rest_dim, tail_dim) := List.split(ty.dimensions, listLength(rest));
      
                // offset by the skipped position times the size of the remaining dimensions (may be zero)
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 83 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 83 times.

        83
                index := index + (locationToIndex(listReverse(list(Dimension.size(dim, true) for dim in rest_dim)), listReverse(rest), 1) - 1)
      
                  * Dimension.sizesProduct(tail_dim, true);
      
        83
                ty.dimensions := tail_dim;
      
              then (index, ty);
      
              // skip for tuple or array, but the skip is too large
      
              case (_, skip::_) guard(Type.isTuple(ty) or Type.isArray(ty)) algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because skip of " + intString(skip)
      
                  + " for type " + Type.toString(ty) + " is too large."});
      
        ✗
              then fail();
      
              // there is no skip but there is a tuple (no-skip array is fine)
      
              case (Type.TUPLE(), {}) algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because there is no skip for type "
      
                  + Type.toString(ty)});
      
        ✗
              then fail();
      
              // invalid skip
      
              // skipping to the first element of any type that is not array, tuple or complex is technically allowed but does not do anything
      
              case (_, skip::_) guard(skip <> 1) algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because skip of " + intString(skip)
      
                  + " for type " + Type.toString(ty) + " is invalid."});
      
        ✗
              then fail();
      
              else (index, ty);
      
            end match;
      
          end resolveSkips;
      
          // intermediate types and functions for resolveDependency()
      
          type Key = list<Integer>;
      
          type Val1 = list<ComponentRef>;
      
          type Val2 = list<Integer>;
      
          function keyString
      
            input Key key;
      
            output String str = List.toString(key, intString);
      
          end keyString;
      
          function keyHash
      
            input Key key;
      
            output Integer hash = Util.HASH_SEED;
      
          algorithm
      
          2/2✓ Branch 0 taken 272 times.
✓ Branch 1 taken 136 times.

        408
            for k in key loop
      
        272
              hash := stringHashDjb2Continue(intString(k), hash);
      
            end for;
      
          end keyHash;
      
          function keyEqual
      
            input Key key1;
      
            input Key key2;
      
            output Boolean b = List.isEqualOnTrue(key1, key2, intEq);
      
          end keyEqual;
      
          function val1String
      
            input list<ComponentRef> val;
      
            output String str = List.toString(val, ComponentRef.toString);
      
          end val1String;
      
          function resolveDependency
      
            "resolves the dependency of a component reference in an equation.
      
            I.  Resolve skip dimensions (Tuples, Records, Array Constructors)
      
            II. Resolve regular vs. reduced dimensions"
      
            input ComponentRef original_cref;
      
            input ComponentRef eqn_name;
      
            input Integer eqn_arr_idx;
      
            input Iterator iter;
      
            input Type ty;
      
            input UnorderedMap<ComponentRef, Dependency> dep        "dependency map";
      
            input UnorderedSet<ComponentRef> rep                    "repetition set";
      
            input UnorderedMap<ComponentRef, Integer> map           "unordered map to check for relevance";
      
            input UnorderedMap<ComponentRef, Integer> fullmap       "unordered map to check for general relevance";
      
            input IntMatrix.Builder m;
      
            input Mapping mapping                                   "array <-> scalar index mapping";
      
            input ModeTable modes;
      
          protected
      
            Dependency d;
      
            list<tuple<Integer, Type>> skip_lst;
      
            Type skip_ty;
      
            Integer skip_idx, start, size, body_size, iter_size;
      
            list<ComponentRef> names;
      
            list<Expression> ranges;
      
            list<Option<Iterator>> maps;
      
            list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            list<Boolean> regulars;
      
            ComponentRef cref;
      
          algorithm
      
            try
      
              // remove resizable parameters for index lookup
      
        24044
              cref := ComponentRef.mapExp(original_cref, Expression.replaceResizableParameter);
      
        24044
              cref := ComponentRef.simplifySubscripts(cref);
      
              // I. resolve the skips
      
        24044
              d           := UnorderedMap.getSafe(original_cref, dep, sourceInfo());
      
        24044
              (start, _)  := mapping.eqn_AtS[eqn_arr_idx];
      
          2/2✓ Branch 1 taken 22576 times.
✓ Branch 2 taken 1468 times.

        24044
              if not UnorderedSet.contains(cref, rep) then
      
        22576
                skip_lst  := resolveSkipsLst(start, ty, arrayList(d.skips), cref, fullmap);
      
              else
      
        1468
                skip_lst  := {(start, ty)};
      
              end if;
      
          2/2✓ Branch 0 taken 24359 times.
✓ Branch 1 taken 24044 times.

        48403
              for tpl in skip_lst loop
      
        24359
                (skip_idx, skip_ty) := tpl;
      
                // get equation and iterator sizes and frames
      
        24359
                body_size             := Type.sizeOf(skip_ty, true);
      
        24359
                iter_size             := Iterator.size(iter, true);
      
        24359
                size                  := body_size * iter_size;
      
        24359
                (names, ranges, maps) := Iterator.getFrames(iter);
      
        24359
                frames                := List.zip3(names, ranges, maps);
      
                // II. check for regular vs. reduced dimensions
      
        24359
                regulars := Dependency.toBoolean(d);
      
          2/2✓ Branch 1 taken 24038 times.
✓ Branch 2 taken 321 times.

        24359
                if List.all(regulars, Util.id) then
      
                  // II.1 all regular - single dependency per row.
      
                  // The rows of a for-equation are ordered by iteration, then by the elements of its body. If
      
                  // the dependency is only an element of the body (e.g. one output of a tuple) its rows are not
      
                  // contiguous but a whole body apart.
      
        24038
                  resolveAllRegular(cref, original_cref, eqn_name, skip_idx, size, iter_size, frames, rep, map, m, mapping, modes, Type.sizeOf(ty, true));
      
                elseif List.any(regulars, Util.id) then
      
                  // II.2 mixed regularity - find all necessary configurations and add them to a map with a proper key
      
        12
                  resolveMixed(cref, original_cref, eqn_name, skip_idx, ty, frames, iter_size, regulars, map, m, mapping, modes);
      
                else
      
                  // II.3 all reduced - full dependency per row. scalarize and add to all rows of the equation
      
        309
                  resolveAllReduced(cref, original_cref, eqn_name, skip_idx, size, iter_size, frames, rep, map, m, mapping, modes);
      
                end if;
      
              end for;
      
            else
      
        ✗
              Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed for: " + ComponentRef.toString(original_cref) + "."});
      
        ✗
              fail();
      
            end try;
      
          end resolveDependency;
      
          function resolveAllRegular
      
            "II.1 all regular - single dependency per row."
      
            input ComponentRef cref;
      
            input ComponentRef original_cref;
      
            input ComponentRef eqn_name;
      
            input Integer skip_idx, size, iter_size;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            input UnorderedSet<ComponentRef> rep                    "repetition set";
      
            input UnorderedMap<ComponentRef, Integer> map           "unordered map to check for relevance";
      
            input IntMatrix.Builder m;
      
            input Mapping mapping                                   "array <-> scalar index mapping";
      
            input ModeTable modes;
      
            input Integer stride = 0                                "rows of a whole equation body (0: same as the dependency)";
      
          protected
      
            Integer mode;
      
            list<ComponentRef> scalarized;
      
            list<Val2> scal_indices = {};
      
            Val2 idx_lst;
      
            Integer scal_size = 0, shift, body_size = if iter_size > 0 then intDiv(size, iter_size) else size;
      
          algorithm
      
        24038
            mode        := Modes.add(modes, Mode.create(eqn_name, {original_cref}, false));
      
        24038
            scalarized  := listReverse(ComponentRef.scalarizeAll(cref, true));
      
          2/2✓ Branch 0 taken 28653 times.
✓ Branch 1 taken 24038 times.

        52691
            for scal in scalarized loop
      
        28653
              idx_lst       := getCrefInFrameIndices(scal, frames, mapping, map, true);
      
              scal_indices  := idx_lst :: scal_indices;
      
        28653
              scal_size     := scal_size + listLength(idx_lst);
      
            end for;
      
        24038
            scal_indices := listReverse(scal_indices);
      
            // either the scalarized list has to be equal in length to the equation or it can be repeated enough times to fit
      
          7/8✓ Branch 0 taken 24037 times.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 26 times.
✓ Branch 3 taken 24011 times.
✓ Branch 5 taken 19 times.
✓ Branch 6 taken 7 times.
✓ Branch 7 taken 19 times.
✗ Branch 8 not taken.

        24057
            if scal_size > 0 and (size == scal_size or (UnorderedSet.contains(cref, rep) and intMod(size, scal_size) == 0)) then
      
              shift := 0;
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 24030 times.
✓ Branch 3 taken 24030 times.
✗ Branch 4 not taken.

        48118
              for i in 1:size/scal_size loop
      
          2/2✓ Branch 0 taken 28704 times.
✓ Branch 1 taken 24088 times.

        52792
                for indices in scal_indices loop
      
          2/2✓ Branch 0 taken 45958 times.
✓ Branch 1 taken 28704 times.

        74662
                  for scal_idx in indices loop
      
          2/2✓ Branch 0 taken 1338 times.
✓ Branch 1 taken 44620 times.

        45958
                    if stride > body_size and body_size > 0 then
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1338 times.

        1338
                      addMatrixEntry(m, skip_idx + intDiv(shift, body_size) * stride + intMod(shift, body_size), scal_idx, mode);
      
                    else
      
        44620
                      addMatrixEntry(m, skip_idx + shift, scal_idx, mode);
      
                    end if;
      
        45958
                    shift := shift + 1;
      
                  end for;
      
                end for;
      
              end for;
      
            elseif scal_size > 0 and scal_size < size then
      
              // partial out-of-bounds: some frame values produce invalid subscripts (e.g. $i1-1 at $i1=1).
      
              // evaluate each frame combination individually and assign deps to the correct equation row only.
      
        3
              resolveAllRegularPartial(cref, original_cref, eqn_name, skip_idx, size, iter_size, frames, map, m, mapping, modes);
      
            elseif scal_size > size then
      
              // undetected full dependency caused by non-evaluable subscripts, this can happen by inlining functions
      
              // II.3 all reduced - full dependency per row. scalarize and add to all rows of the equation
      
        4
              resolveAllReduced(cref, original_cref, eqn_name, skip_idx, size, iter_size, frames, rep, map, m, mapping, modes);
      
            end if;
      
            // scal_size == 0: all frame values are out-of-bounds, no real dependency — do nothing
      
          end resolveAllRegular;
      
          function resolveMixed
      
            "II.2 mixed regularity - find all necessary configurations and add them to a map with a proper key"
      
            input ComponentRef cref;
      
            input ComponentRef original_cref;
      
            input ComponentRef eqn_name;
      
            input Integer skip_idx;
      
            input Type ty;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            input Integer iter_size;
      
            input list<Boolean> regulars;
      
            input UnorderedMap<ComponentRef, Integer> map           "unordered map to check for relevance";
      
            input IntMatrix.Builder m;
      
            input Mapping mapping                                   "array <-> scalar index mapping";
      
            input ModeTable modes;
      
          protected
      
            ComponentRef stripped;
      
            list<Subscript> subs;
      
            list<Dimension> dims, eq_dims;
      
            array<Integer> key;
      
            UnorderedMap<Key, Val1> map1;
      
            array<UnorderedMap<Key, Val2>> frame_maps;
      
            list<array<Integer>> frame_indices;
      
            list<Integer> all_indices;
      
            Integer size_comp, frame_count = max(iter_size, 1), mode;
      
            Boolean per_frame;
      
            Pointer<Integer> eqn_idx_ptr;
      
            list<Boolean> eq_reg, scalars;
      
            list<tuple<Dimension, Boolean>> lst;
      
            list<tuple<Subscript, Dimension, Boolean>> var_lst;
      
            Boolean aligned;
      
          algorithm
      
            // 1. get the cref subscripts and dimensions as well as the equation dimensions (they have to match in length)
      
        12
            subs    := ComponentRef.subscriptsAllWithWholeFlat(cref);
      
        12
            dims    := Type.arrayDims(ComponentRef.getSubscriptedType(cref));
      
        12
            eq_dims := Type.arrayDims(ty);
      
        12
            (var_lst, scalars, aligned) := zipSubscripts(subs, dims, regulars);
      
          1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.

        12
            if aligned then
      
              // 2. create a map that maps a configuration key to the corresponding scalar crefs
      
        12
              stripped  := ComponentRef.stripSubscriptsAll(cref);
      
        12
              key       := arrayCreate(listLength(subs), 0);
      
        12
              map1      := UnorderedMap.new<Val1>(keyHash, keyEqual);
      
        12
              resolveReductions(var_lst, map1, key, stripped);
      
              // 3. create maps that map a configuration key to the final variable indices, one map per
      
              //    frame since each frame (iteration of a for-equation) has its own rows
      
          2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.

        24
              frame_maps := listArray(list(UnorderedMap.new<Val2>(keyHash, keyEqual) for i in 1:frame_count));
      
          2/2✓ Branch 1 taken 34 times.
✓ Branch 2 taken 12 times.

        46
              for k in UnorderedMap.keyList(map1) loop
      
          4/4✓ Branch 1 taken 98 times.
✓ Branch 2 taken 34 times.
✓ Branch 3 taken 98 times.
✓ Branch 4 taken 34 times.

        132
                frame_indices := list(listArray(getCrefInFrameIndices(scal, frames, mapping, map, true))
      
                  for scal in UnorderedMap.getSafe(k, map1, sourceInfo()));
      
          5/6✓ Branch 0 taken 98 times.
✓ Branch 1 taken 34 times.
✓ Branch 2 taken 98 times.
✓ Branch 3 taken 34 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 98 times.

        230
                per_frame := List.all(list(arrayLength(a) == frame_count for a in frame_indices), Util.id);
      
          1/2✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.

        34
                if per_frame then
      
        34
                  for i in 1:frame_count loop
      
          4/4✓ Branch 0 taken 98 times.
✓ Branch 1 taken 34 times.
✓ Branch 2 taken 98 times.
✓ Branch 3 taken 34 times.

        132
                    UnorderedMap.add(k, list(a[i] for a in frame_indices), frame_maps[i]);
      
                  end for;
      
                else
      
                  // indices that cannot be attributed to a frame (e.g. some frames are out of bounds) belong to all of them
      
        ✗
                  all_indices := List.flatten(list(arrayList(a) for a in frame_indices));
      
        ✗
                  for i in 1:frame_count loop
      
        ✗
                    UnorderedMap.add(k, all_indices, frame_maps[i]);
      
                  end for;
      
                end if;
      
              end for;
      
              // 4. check if equation and variable are of same length, if not: fixup the lists to be of equal length
      
        12
              size_comp := List.compareLength(eq_dims, regulars);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.

        12
              if size_comp > 0 then
      
                // bigger equation than variable
      
        ✗
                eq_reg := listAppend(regulars, List.fill(false, listLength(eq_dims) - listLength(regulars)));
      
        ✗
                lst := List.zip(eq_dims, eq_reg);
      
              elseif size_comp < 0 then
      
                // bigger variable than equation
      
        12
                lst := resolveMixedDimensions(eq_dims, regulars);
      
              else
      
        ✗
                lst := List.zip(eq_dims, regulars);
      
              end if;
      
        12
              lst := insertScalarDimensions(lst, scalars);
      
              // 5. iterate over all equation dimensions and use the map to get the correct dependencies,
      
              //    the rows of the frames follow each other
      
        12
              mode := Modes.add(modes, Mode.create(eqn_name, {original_cref}, false));
      
        12
              eqn_idx_ptr := Pointer.create(skip_idx);
      
        24
              for i in 1:frame_count loop
      
        12
                key := arrayCreate(listLength(subs), 0);
      
        12
                resolveEquationDimensions(lst, frame_maps[i], key, m, mode, eqn_idx_ptr);
      
              end for;
      
            else
      
        ✗
              Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because subscripts, dimensions and dependencies were not of equal length.\n"
      
                + "variable subscripts(" + intString(listLength(subs)) + "): " + List.toString(subs, Subscript.toString) + "\n"
      
                + "variable dimensions(" + intString(listLength(dims)) + "): " + List.toString(dims, Dimension.toString) + "\n"
      
                + "equation dimensions(" + intString(listLength(eq_dims)) + "): " + List.toString(eq_dims, Dimension.toString) + "\n"
      
                + "variable dependencies(" + intString(listLength(regulars)) + "): " + List.toString(regulars, boolString) + "\n"});
      
        ✗
              fail();
      
            end if;
      
          end resolveMixed;
      
          function zipSubscripts
      
            "Zips the subscripts of a cref with the dimensions and dependencies of its
      
             subscripted type. A scalar subscript (e.g. a[1].b[:]) has neither and gets
      
             a reduced dimension of size one, so that the key positions of the variable
      
             and the equation stay aligned (see insertScalarDimensions)."
      
            input list<Subscript> subs;
      
            input list<Dimension> dims;
      
            input list<Boolean> regulars;
      
            output list<tuple<Subscript, Dimension, Boolean>> lst = {};
      
            output list<Boolean> scalars = {};
      
            output Boolean aligned = true;
      
          protected
      
            list<Dimension> rest_dims = dims;
      
            list<Boolean> rest_regs = regulars;
      
            Dimension dim;
      
            Boolean reg;
      
          algorithm
      
          2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 12 times.

        36
            for sub in subs loop
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.

        24
              if Subscript.isScalar(sub) then
      
        ✗
                lst := (sub, Dimension.fromInteger(1), false) :: lst;
      
                scalars := true :: scalars;
      
              elseif listEmpty(rest_dims) or listEmpty(rest_regs) then
      
                aligned := false;
      
        ✗
                return;
      
              else
      
        24
                dim :: rest_dims := rest_dims;
      
        24
                reg :: rest_regs := rest_regs;
      
          2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.

        36
                lst := (sub, dim, reg) :: lst;
      
                scalars := false :: scalars;
      
              end if;
      
            end for;
      
          2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.

        12
            aligned := listEmpty(rest_dims) and listEmpty(rest_regs);
      
        12
            lst := listReverse(lst);
      
        12
            scalars := listReverse(scalars);
      
          end zipSubscripts;
      
          function insertScalarDimensions
      
            "Inserts a reduced dimension of size one into the equation dimensions for
      
             each scalar subscript of the variable."
      
            input list<tuple<Dimension, Boolean>> lst;
      
            input list<Boolean> scalars;
      
            output list<tuple<Dimension, Boolean>> outLst = {};
      
          protected
      
            list<tuple<Dimension, Boolean>> rest = lst;
      
            tuple<Dimension, Boolean> t;
      
          algorithm
      
          2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 12 times.

        36
            for scalar in scalars loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.

        24
              if scalar then
      
        ✗
                outLst := (Dimension.fromInteger(1), false) :: outLst;
      
              elseif not listEmpty(rest) then
      
        24
                t :: rest := rest;
      
                outLst := t :: outLst;
      
              end if;
      
            end for;
      
        12
            outLst := List.append_reverse(outLst, rest);
      
          end insertScalarDimensions;
      
          function resolveMixedDimensions
      
            "fills the list with dimensions of size one at the proper place even if they are skipped.
      
            allows a function that resolves all configurations of variable and equation sizes.
      
            prepares for resolveEquationDimensions() if the variable is bigger than the equation"
      
            input list<Dimension> eq_dims;
      
            input list<Boolean> regulars;
      
            input output list<tuple<Dimension, Boolean>> lst = {};
      
          algorithm
      
            lst := match (eq_dims, regulars)
      
              local
      
                Dimension dim;
      
                list<Dimension> rest_dim;
      
                list<Boolean> rest_reg;
      
              // dummy dimension that will be skipped
      
        12
              case (_, false :: rest_reg) then (Dimension.fromExp(Expression.INTEGER(1), Variability.CONSTANT), false) :: resolveMixedDimensions(eq_dims, rest_reg);
      
              // correct dimension that will be kept
      
        12
              case (dim :: rest_dim, true :: rest_reg) then (dim, true) :: resolveMixedDimensions(rest_dim, rest_reg);
      
              // excess unfitting is ignored
      
              else {};
      
            end match;
      
          end resolveMixedDimensions;
      
          function resolveAllReduced
      
            "II.3 all reduced - full dependency per row. scalarize and add to all rows of the equation"
      
            input ComponentRef cref;
      
            input ComponentRef original_cref;
      
            input ComponentRef eqn_name;
      
            input Integer skip_idx, size, iter_size;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            input UnorderedSet<ComponentRef> rep                    "repetition set";
      
            input UnorderedMap<ComponentRef, Integer> map           "unordered map to check for relevance";
      
            input IntMatrix.Builder m;
      
            input Mapping mapping                                   "array <-> scalar index mapping";
      
            input ModeTable modes;
      
          protected
      
            Boolean repeated;
      
            list<ComponentRef> scalarized;
      
            list<Val2> scal_indices = {};
      
            Integer shift;
      
            Integer mode;
      
          algorithm
      
        313
            repeated    := UnorderedSet.contains(cref, rep);
      
        313
            scalarized  := listReverse(ComponentRef.scalarizeAll(cref, true));
      
          2/2✓ Branch 0 taken 3571 times.
✓ Branch 1 taken 313 times.

        3884
            for scal in scalarized loop
      
        3571
              scal_indices := getCrefInFrameIndices(scal, frames, mapping, map, true) :: scal_indices;
      
            end for;
      
        313
            scal_indices := listReverse(scal_indices);
      
            // if its repeated, use the same cref always; otherwise use local cref
      
        313
            mode := Modes.add(modes, Mode.create(eqn_name, {original_cref}, not repeated));
      
          3/6✗ Branch 0 not taken.
✓ Branch 1 taken 313 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 313 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 313 times.

        980
            for i in skip_idx:iter_size:skip_idx+size-iter_size loop
      
              shift := 0;
      
          2/2✓ Branch 0 taken 5397 times.
✓ Branch 1 taken 667 times.

        6064
              for indices in scal_indices loop
      
          3/4✓ Branch 0 taken 5841 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5841 times.
✓ Branch 3 taken 5397 times.

        11238
                for scal_idx in indices loop
      
          2/2✓ Branch 0 taken 5401 times.
✓ Branch 1 taken 440 times.

        5841
                  if intMod(shift, iter_size) == 0 then shift := 0; end if;
      
        5841
                  addMatrixEntry(m, i + shift, scal_idx, mode);
      
        5841
                  shift := shift + 1;
      
                end for;
      
              end for;
      
            end for;
      
          end resolveAllReduced;
      
          function resolveAllRegularPartial
      
            "II.1 partial out-of-bounds variant: some frame values produce invalid (out-of-bounds) subscripts.
      
            Evaluates each frame combination individually and assigns each valid scalar index to the
      
            equation row that corresponds to that frame value only.  Rows whose frame value maps to an
      
            out-of-bounds subscript receive no dependency entry."
      
            input ComponentRef cref;
      
            input ComponentRef original_cref;
      
            input ComponentRef eqn_name;
      
            input Integer skip_idx, size, iter_size;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            input UnorderedMap<ComponentRef, Integer> map;
      
            input IntMatrix.Builder m;
      
            input Mapping mapping;
      
            input ModeTable modes;
      
          protected
      
            Integer mode;
      
            ComponentRef final_cref;
      
            Integer var_arr_idx, var_start;
      
            list<Integer> sizes;
      
            list<Expression> subs;
      
            Integer body_size;
      
            Pointer<Integer> row;
      
            UnorderedMap<ComponentRef, Expression> replacements;
      
          algorithm
      
        3
            mode          := Modes.add(modes, Mode.create(eqn_name, {original_cref}, false));
      
        3
            (final_cref, var_arr_idx) := getVarArrIdx(cref, mapping, map);
      
        3
            (var_start, _)            := mapping.var_AtS[var_arr_idx];
      
        3
            sizes         := ComponentRef.sizes(final_cref, false, true);
      
        3
            subs          := ComponentRef.subscriptsToExpression(cref, true);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.

        3
            body_size     := intDiv(size, iter_size);
      
        3
            row           := Pointer.create(skip_idx);
      
        3
            replacements  := UnorderedMap.new<Expression>(ComponentRef.hash, ComponentRef.isEqual);
      
        3
            resolveFrames(frames, sizes, subs, var_start, replacements, true, m, mode, body_size, row);
      
          end resolveAllRegularPartial;
      
          function resolveFrames
      
            "Recursively iterates over all frame combinations (one per equation row) and assigns
      
            each valid scalar index to the corresponding equation row.  Advances the row counter
      
            for every frame combination regardless of whether the subscript is valid."
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            input list<Integer> sizes;
      
            input list<Expression> subs;
      
            input Integer var_start;
      
            input UnorderedMap<ComponentRef, Expression> replacements;
      
            input Boolean resize;
      
            input IntMatrix.Builder m;
      
            input Integer mode                "index into the mode table";
      
            input Integer body_size;
      
            input Pointer<Integer> row;
      
          algorithm
      
            () := match frames
      
              local
      
                ComponentRef iterator;
      
                Expression range;
      
                Option<Iterator> fmap;
      
                list<tuple<ComponentRef, Expression, Option<Iterator>>> rest;
      
                Integer start, step, stop, sub_idx, r;
      
                list<list<Integer>> values;
      
                list<Expression> iterator_exps;
      
                list<Integer> iterator_lst;
      
              // leaf: all frame iterators bound — evaluate subscript and assign to current row
      
              case {} algorithm
      
        23
                r      := Pointer.access(row);
      
        23
                values := resolveDimensionsSubscripts(sizes, subs, replacements, resize);
      
          2/2✓ Branch 1 taken 20 times.
✓ Branch 2 taken 23 times.

        43
                for v in listReverse(values) loop
      
        20
                  addMatrixEntry(m, r, locationToIndex(sizes, v, var_start), mode);
      
                end for;
      
        23
                Pointer.update(row, r + body_size);
      
              then ();
      
              // recurse over iterator range
      
              case (iterator, range, fmap) :: rest algorithm
      
                iterator_lst := match range
      
                  case Expression.RANGE() algorithm
      
        3
                    (start, step, stop) := Expression.getIntegerRange(range, resize);
      
        3
                  then List.intRange3(start, step, stop);
      
                  case Expression.ARRAY() algorithm
      
        ✗
                    iterator_exps := list(Expression.map(e, function Replacements.applySimpleExp(replacements = replacements)) for e in range.elements);
      
        ✗
                    iterator_lst  := list(Expression.integerValue(SimplifyExp.simplifyDump(e, true, getInstanceName())) for e in iterator_exps);
      
                  then iterator_lst;
      
                  else algorithm
      
        ✗
                    Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed to parse iterator range: "
      
                      + ComponentRef.toString(iterator) + " in " + Expression.toString(range)});
      
        ✗
                  then fail();
      
                end match;
      
                sub_idx := 1;
      
          2/2✓ Branch 0 taken 23 times.
✓ Branch 1 taken 3 times.

        26
                for index in iterator_lst loop
      
        23
                  UnorderedMap.add(iterator, Expression.INTEGER(index), replacements);
      
        23
                  Iterator.createMappedLocationReplacement(fmap, sub_idx, replacements);
      
        23
                  resolveFrames(rest, sizes, subs, var_start, replacements, resize, m, mode, body_size, row);
      
        23
                  sub_idx := sub_idx + 1;
      
                end for;
      
              then ();
      
              else algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed for an unknown reason."});
      
        ✗
              then fail();
      
            end match;
      
          end resolveFrames;
      
          function resolveEquationDimensions
      
            "a component reference in a list of equation dimensions. The second argument to the tuple
      
            is TRUE if its a regular occurence of the cref and FALSE if its a reduced occurence.
      
            The key is created from the dimensions and the additional boolean to look up the cref occurence in the map."
      
            input list<tuple<Dimension, Boolean>> lst   "equation dimension and cref regularity tuple list";
      
            input UnorderedMap<Key, Val2> map           "map to look up occurence";
      
            input Array<Integer> key                    "mutable key";
      
            input IntMatrix.Builder m         "adjacency matrix builder";
      
            input Integer mode                "index into the mode table";
      
            input Pointer<Integer> eqn_idx_ptr          "mutable equation index";
      
            input Integer index = 1                     "dimension index for the key";
      
          algorithm
      
            () := match lst
      
              local
      
                Dimension dim;
      
                list<tuple<Dimension, Boolean>> rest;
      
                Integer eqn_idx;
      
                list<Integer> scal_lst;
      
              case {} algorithm
      
                // no further dimensions. resolve with current key config and bump equation index
      
        34
                eqn_idx := Pointer.access(eqn_idx_ptr);
      
        34
                scal_lst := UnorderedMap.getSafe(arrayList(key), map, sourceInfo());
      
          2/2✓ Branch 0 taken 98 times.
✓ Branch 1 taken 34 times.

        132
                for scal_idx in scal_lst loop
      
        98
                  addMatrixEntry(m, eqn_idx, scal_idx, mode);
      
                end for;
      
        34
                Pointer.update(eqn_idx_ptr, eqn_idx + 1);
      
              then ();
      
              case (dim, false)::rest algorithm
      
                // reduced dimension, keep key index at 0 and go deeper with next dimension
      
          1/2✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.

        68
                for i in 1:Dimension.size(dim, true) loop
      
        34
                  resolveEquationDimensions(rest, map, key, m, mode, eqn_idx_ptr, index+1);
      
                end for;
      
              then ();
      
              case (dim, true)::rest algorithm
      
                // regular dimension, update key index to corresponding dimension index
      
                // and go deeper with next dimension
      
          1/2✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.

        46
                for i in 1:Dimension.size(dim, true) loop
      
        34
                  arrayUpdate(key, index, i);
      
        34
                  resolveEquationDimensions(rest, map, key, m, mode, eqn_idx_ptr, index+1);
      
                end for;
      
              then ();
      
            end match;
      
          end resolveEquationDimensions;
      
          function addMatrixEntry
      
            input IntMatrix.Builder m         "adjacency matrix builder";
      
            input Integer eqn_idx;
      
            input Integer var_idx;
      
            input Integer mode                "index into the mode table";
      
          algorithm
      
            // only add the variable if its a viable index. due to unresolved if-expressions in for-loops some branches can access variables
      
            // that seem out of scope but are in fact valid because the if-condition ensures it.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 51917 times.

        51917
            if var_idx > 0 then
      
        51917
              IntMatrix.builderAddAux(m, eqn_idx, var_idx, mode);
      
            end if;
      
          end addMatrixEntry;
      
          function resolveReductions
      
            input list<tuple<Subscript, Dimension, Boolean>> lst;
      
            input UnorderedMap<Key, Val1> map;
      
            input Array<Integer> key;
      
            input ComponentRef stripped;
      
            input list<Subscript> acc = {};
      
            input Integer index = 1;
      
          algorithm
      
            () := match lst
      
              local
      
                list<tuple<Subscript, Dimension, Boolean>> rest;
      
                Subscript sub;
      
                Dimension dim;
      
                ComponentRef cref;
      
                Val1 val;
      
                Integer sub_idx;
      
              case {} algorithm
      
        34
                cref := ComponentRef.mergeSubscripts(listReverse(acc), stripped, true);
      
        34
                val := ComponentRef.scalarizeAll(cref, true);
      
        34
                UnorderedMap.add(arrayList(key), val, map);
      
              then ();
      
              case (sub, _, false)::rest algorithm
      
        34
                resolveReductions(rest, map, key, stripped, sub::acc, index+1);
      
              then ();
      
              case (sub, dim, true)::rest algorithm
      
                sub_idx := 1;
      
          2/2✓ Branch 2 taken 34 times.
✓ Branch 3 taken 12 times.

        46
                for s in Subscript.scalarize(sub, dim, true) loop
      
        34
                  arrayUpdate(key, index, sub_idx);
      
        34
                  resolveReductions(rest, map, key, stripped, s::acc, index+1);
      
        34
                  sub_idx := sub_idx + 1;
      
                end for;
      
              then ();
      
            end match;
      
          end resolveReductions;
      
          function combineFrames2Indices
      
            "Iterates over all elements in nested iterators represented by frames.
      
            Converts each of the now integer subscript lists (in combination with
      
            subscript sizes) to a single scalar index of the subscripted cref."
      
            input Integer first                                       "index of first variable. start counting from here";
      
            input list<Integer> sizes                                 "list of variables sizes";
      
            input list<Expression> subs                               "list of cref subscripts";
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames        "list of frame tuples containing iterator name and range";
      
            input UnorderedMap<ComponentRef, Expression> replacements "replacement rules iterator cref -> integer (may have to be simplified)";
      
            input Boolean resize;
      
            input output list<Integer> indices = {}                   "list of scalarized indices";
      
          algorithm
      
            indices := match frames
      
              local
      
                list<tuple<ComponentRef, Expression, Option<Iterator>>> rest;
      
                ComponentRef iterator;
      
                Expression range;
      
                Option<Iterator> map;
      
                Integer start, step, stop;
      
                list<list<Integer>> values;
      
                list<Expression> iterator_exps;
      
                list<Integer> iterator_lst;
      
                Integer sub_idx;
      
              // only occurs for non-for-loop equations (no frames to replace)
      
              case {} algorithm
      
        8
                values := resolveDimensionsSubscripts(sizes, subs, replacements, resize);
      
          4/4✓ Branch 0 taken 16 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 16 times.
✓ Branch 3 taken 8 times.

        24
              then list(locationToIndex(sizes, v, first) for v in values);
      
              // extract numeric information about the range
      
              case (iterator, range, map) :: rest algorithm
      
                iterator_lst := match range
      
                  case Expression.RANGE() algorithm
      
        810
                    (start, step, stop) := Expression.getIntegerRange(range, resize);
      
        810
                  then List.intRange3(start,step, stop);
      
                  case Expression.ARRAY() algorithm
      
          4/4✓ Branch 0 taken 36 times.
✓ Branch 1 taken 12 times.
✓ Branch 3 taken 36 times.
✓ Branch 4 taken 12 times.

        96
                    iterator_exps := list(Expression.map(e, function Replacements.applySimpleExp(replacements = replacements)) for e in range.elements);
      
          4/4✓ Branch 0 taken 36 times.
✓ Branch 1 taken 12 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 12 times.

        48
                    iterator_lst  := list(Expression.integerValue(SimplifyExp.simplifyDump(e, true, getInstanceName())) for e in iterator_exps);
      
                  then iterator_lst;
      
                  else algorithm
      
        ✗
                    Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because iterator binding could not be parsed: "
      
                      + ComponentRef.toString(iterator) + " in " + Expression.toString(range)});
      
        ✗
                  then fail();
      
                end match;
      
                // traverse every index in the range (and possible sub iterators)
      
                sub_idx := 1;
      
          2/2✓ Branch 0 taken 4122 times.
✓ Branch 1 taken 822 times.

        4944
                for index in iterator_lst loop
      
                  // create main iterator replacement
      
        4122
                  UnorderedMap.add(iterator, Expression.INTEGER(index), replacements);
      
                  // create local sub replacements if existent
      
        4122
                  Iterator.createMappedLocationReplacement(map, sub_idx, replacements);
      
          2/2✓ Branch 0 taken 3936 times.
✓ Branch 1 taken 186 times.

        4122
                  if listEmpty(rest) then
      
                    // bottom line, resolve current configuration and create index for it
      
        3936
                    values := resolveDimensionsSubscripts(sizes, subs, replacements, resize);
      
          2/2✓ Branch 1 taken 3933 times.
✓ Branch 2 taken 3936 times.

        7869
                    for v in listReverse(values) loop
      
        3933
                      indices := locationToIndex(sizes, v, first) :: indices;
      
                    end for;
      
                  else
      
                    // not last frame, go deeper
      
        186
                    indices := combineFrames2Indices(first, sizes, subs, rest, replacements, resize, indices);
      
                  end if;
      
        4122
                  sub_idx := sub_idx + 1;
      
                end for;
      
              then indices;
      
              case (iterator, range, _) :: _ algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because uniontype records are wrong: "
      
                  + ComponentRef.toString(iterator) + " in " + Expression.toString(range)});
      
        ✗
              then fail();
      
              else algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed for an unknown reason."});
      
        ✗
              then fail();
      
            end match;
      
          end combineFrames2Indices;
      
          function combineFramesIndices
      
            "Turns the subscripts of a cref into scalar indices over all frame values.
      
            Tries the arithmetic evaluation first and falls back to the general
      
            expression machinery."
      
            input Integer first;
      
            input list<Integer> sizes;
      
            input list<Expression> subs;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            input Boolean resize;
      
            output list<Integer> indices;
      
          protected
      
            Boolean ok;
      
          algorithm
      
        32583
            (ok, indices) := combineFramesArithmetic(first, sizes, subs, frames);
      
          2/2✓ Branch 0 taken 31939 times.
✓ Branch 1 taken 644 times.

        32583
            if not ok then
      
        644
              indices := listReverse(combineFrames2Indices(first, sizes, subs, frames,
      
                UnorderedMap.new<Expression>(ComponentRef.hash, ComponentRef.isEqual), resize));
      
            end if;
      
          end combineFramesIndices;
      
          function combineFramesArithmetic
      
            "Fast path for combineFrames2Indices: every frame has to be a literal
      
            integer range without a mapped location and every subscript has to be
      
            integer arithmetic over the frame iterators. ok is false if it is not,
      
            the general path has to be used then."
      
            input Integer first;
      
            input list<Integer> sizes;
      
            input list<Expression> subs;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames;
      
            output Boolean ok = true;
      
            output list<Integer> indices = {};
      
          protected
      
            Integer n = listLength(frames);
      
            Integer sz = if n > 0 then n else 1;
      
            array<ComponentRef> names = arrayCreate(sz, ComponentRef.EMPTY());
      
            array<Integer> values = arrayCreate(sz, 0);
      
            array<Integer> starts = arrayCreate(sz, 0);
      
            array<Integer> steps = arrayCreate(sz, 0);
      
            array<Integer> stops = arrayCreate(sz, 0);
      
            Integer i = 1;
      
            ComponentRef name;
      
            Expression range;
      
            Option<Iterator> map;
      
          algorithm
      
            // an unsubscripted cref yields no combination at all, same as List.combination({})
      
          1/2✓ Branch 0 taken 32583 times.
✗ Branch 1 not taken.

        32583
            if listEmpty(subs) then
      
        ✗
              return;
      
            end if;
      
          2/2✓ Branch 0 taken 3082 times.
✓ Branch 1 taken 32081 times.

        35163
            for frame in frames loop
      
        3082
              (name, range, map) := frame;
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 3082 times.
✓ Branch 2 taken 3082 times.
✗ Branch 3 not taken.

        3082
              if isSome(map) then
      
                ok := false;
      
        ✗
                return;
      
              end if;
      
        3082
              arrayUpdate(names, i, name);
      
              () := match range
      
                local
      
                  Integer rstart, rstep, rstop;
      
                case Expression.RANGE(start = Expression.INTEGER(value = rstart), stop = Expression.INTEGER(value = rstop))
      
                  algorithm
      
                    rstep := match range.step
      
          1/2✓ Branch 0 taken 2572 times.
✗ Branch 1 not taken.

        2572
                      case NONE() then if rstart > rstop then -1 else 1;
      
                      case SOME(Expression.INTEGER(value = rstep)) then rstep;
      
                      else 0;
      
                    end match;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.

        8
                    if rstep == 0 then
      
                      ok := false;
      
                    else
      
        2580
                      arrayUpdate(starts, i, rstart);
      
        2580
                      arrayUpdate(steps, i, rstep);
      
        2580
                      arrayUpdate(stops, i, rstop);
      
                    end if;
      
                then ();
      
                else algorithm
      
                  ok := false;
      
                then ();
      
              end match;
      
              if not ok then
      
        502
                return;
      
              end if;
      
        2580
              i := i + 1;
      
            end for;
      
        32081
            (ok, indices) := combineFramesArithmeticWork(first, sizes, subs, names, values, starts, steps, stops, 1, n, ok, indices);
      
          2/2✓ Branch 0 taken 142 times.
✓ Branch 1 taken 31939 times.

        32081
            if ok then
      
        31939
              indices := listReverse(indices);
      
            end if;
      
          end combineFramesArithmetic;
      
          function combineFramesArithmeticWork
      
            input Integer first;
      
            input list<Integer> sizes;
      
            input list<Expression> subs;
      
            input array<ComponentRef> names;
      
            input array<Integer> values;
      
            input array<Integer> starts;
      
            input array<Integer> steps;
      
            input array<Integer> stops;
      
            input Integer level;
      
            input Integer nframes;
      
            input output Boolean ok;
      
            input output list<Integer> indices;
      
          protected
      
            Integer v, step, stop, index;
      
            Boolean inBounds;
      
          algorithm
      
          2/2✓ Branch 0 taken 46372 times.
✓ Branch 1 taken 3367 times.

        49739
            if level > nframes then
      
        46372
              (ok, inBounds, index) := evalFrameIndex(subs, sizes, names, values, nframes, first);
      
          3/4✓ Branch 0 taken 46230 times.
✓ Branch 1 taken 142 times.
✓ Branch 2 taken 46230 times.
✗ Branch 3 not taken.

        46372
              if ok and inBounds then
      
        46230
                indices := index :: indices;
      
              end if;
      
            else
      
        3367
              step := steps[level];
      
        3367
              stop := stops[level];
      
        3367
              v := starts[level];
      
          4/4✓ Branch 0 taken 3240 times.
✓ Branch 1 taken 17646 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 3228 times.

        20886
              while (step > 0 and v <= stop) or (step < 0 and v >= stop) loop
      
        17658
                arrayUpdate(values, level, v);
      
        17658
                (ok, indices) := combineFramesArithmeticWork(first, sizes, subs, names, values, starts, steps, stops, level + 1, nframes, ok, indices);
      
          2/2✓ Branch 0 taken 139 times.
✓ Branch 1 taken 17519 times.

        17658
                if not ok then
      
        139
                  return;
      
                end if;
      
        17519
                v := v + step;
      
              end while;
      
            end if;
      
          end combineFramesArithmeticWork;
      
          function evalFrameIndex
      
            "Evaluates all subscripts at the current frame values and folds them into the
      
            scalar index, like locationToIndex() does for the general path. inBounds is
      
            false if one of them is outside its dimension, which is no dependency at all."
      
            input list<Expression> subs;
      
            input list<Integer> sizes;
      
            input array<ComponentRef> names;
      
            input array<Integer> values;
      
            input Integer nframes;
      
            input Integer first;
      
            output Boolean ok = true;
      
            output Boolean inBounds = true;
      
            output Integer index = first;
      
          protected
      
            list<Integer> rest_sizes = sizes;
      
            Integer size, value, factor = 1;
      
          algorithm
      
          2/2✓ Branch 0 taken 130896 times.
✓ Branch 1 taken 46230 times.

        177126
            for sub in subs loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 130896 times.

        130896
              if listEmpty(rest_sizes) then
      
                ok := false;
      
        ✗
                return;
      
              end if;
      
        130896
              size :: rest_sizes := rest_sizes;
      
        130896
              (ok, value) := evalFrameExp(sub, names, values, nframes);
      
          2/2✓ Branch 0 taken 142 times.
✓ Branch 1 taken 130754 times.

        130896
              if not ok then
      
        142
                return;
      
              end if;
      
          2/4✓ Branch 0 taken 130754 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 130754 times.

        130754
              if value < 1 or value > size then
      
                inBounds := false;
      
        ✗
                return;
      
              end if;
      
        130754
              index := index + (value - 1) * factor;
      
        130754
              factor := factor * size;
      
            end for;
      
          end evalFrameIndex;
      
          function evalFrameExp
      
            "Evaluates an integer expression at the current frame values. ok is false
      
            for anything but integer literals, frame iterators and integer +, - and *."
      
            input Expression exp;
      
            input array<ComponentRef> names;
      
            input array<Integer> values;
      
            input Integer nframes;
      
            output Boolean ok;
      
            output Integer value;
      
          algorithm
      
            (ok, value) := match exp
      
              local
      
                Integer v1, v2;
      
                Boolean ok1, ok2;
      
        111663
              case Expression.INTEGER() then (true, exp.value);
      
              case Expression.CREF() algorithm
      
                ok := false;
      
        19099
                value := 0;
      
          2/2✓ Branch 0 taken 19091 times.
✓ Branch 1 taken 8 times.

        26355
                for i in 1:nframes loop
      
          2/2✓ Branch 2 taken 19091 times.
✓ Branch 3 taken 7256 times.

        26347
                  if ComponentRef.isEqual(exp.cref, names[i]) then
      
        19091
                    value := values[i];
      
                    ok := true;
      
        19091
                    break;
      
                  end if;
      
                end for;
      
        19099
              then (ok, value);
      
              case Expression.BINARY() guard(Type.isInteger(Operator.typeOf(exp.operator))) algorithm
      
        ✗
                (ok1, v1) := evalFrameExp(exp.exp1, names, values, nframes);
      
        ✗
                (ok2, v2) := evalFrameExp(exp.exp2, names, values, nframes);
      
        ✗
                value := 0;
      
        ✗
                if ok1 and ok2 then
      
                  (ok, value) := match exp.operator.op
      
        ✗
                    case NFOperator.Op.ADD then (true, v1 + v2);
      
        ✗
                    case NFOperator.Op.SUB then (true, v1 - v2);
      
        ✗
                    case NFOperator.Op.MUL then (true, v1 * v2);
      
                    else (false, 0);
      
                  end match;
      
                else
      
                  ok := false;
      
                end if;
      
        ✗
              then (ok, value);
      
              case Expression.UNARY() guard(Type.isInteger(Operator.typeOf(exp.operator))
      
                  and exp.operator.op == NFOperator.Op.UMINUS) algorithm
      
        ✗
                (ok, value) := evalFrameExp(exp.exp, names, values, nframes);
      
        ✗
                value := -value;
      
              then (ok, value);
      
              else (false, 0);
      
            end match;
      
          end evalFrameExp;
      
          function getCrefInFrameIndices
      
            input ComponentRef cref                                               "cref to get indices from";
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames  "iterator frames at which to evaluate cref";
      
            input Mapping mapping                                                 "index mapping (only variable mapping needed)";
      
            input UnorderedMap<ComponentRef, Integer> map                         "unordered map to check for relevance";
      
            input Boolean resize;
      
            output list<Integer> scal_lst                                         "scalar indices of cref";
      
          protected
      
            ComponentRef final_cref;
      
            Integer var_arr_idx, var_start;
      
          algorithm
      
        32322
            (final_cref, var_arr_idx) := getVarArrIdx(cref, mapping, map);
      
        32322
            (var_start, _)  := mapping.var_AtS[var_arr_idx];
      
            // add local indices to start index
      
        32322
            scal_lst := getCrefInFrameIndicesLocal(cref, final_cref, frames, var_start, resize);
      
          end getCrefInFrameIndices;
      
          function getVarArrIdx
      
            input output ComponentRef cref                                        "cref to get indices from";
      
            input Mapping mapping                                                 "index mapping (only variable mapping needed)";
      
            input UnorderedMap<ComponentRef, Integer> map                         "unordered map to check for relevance";
      
            output Integer var_arr_idx;
      
          algorithm
      
            // try to get array index, if it fails, strip the subscripts
      
            (var_arr_idx, cref)  := match UnorderedMap.get(cref, map)
      
              case SOME(var_arr_idx) then (var_arr_idx, cref);
      
              else algorithm
      
        155
                cref := ComponentRef.stripSubscriptsAll(cref);
      
        155
              then (UnorderedMap.getSafe(cref, map, sourceInfo()), cref);
      
            end match;
      
          end getVarArrIdx;
      
        public
      
          function getCrefInFrameIndicesLocal
      
            input ComponentRef subscripted_cref;
      
            input ComponentRef stripped_cref;
      
            input list<tuple<ComponentRef, Expression, Option<Iterator>>> frames  "iterator frames at which to evaluate cref";
      
            input Integer var_start;
      
            input Boolean resize;
      
            output list<Integer> scal_lst;
      
          protected
      
            list<Integer> sizes;
      
            list<Expression> subs;
      
            Type ty;
      
            Integer complex_size;
      
          algorithm
      
            // prepare the sizes of the full cref, the subscripts and the type to check if its complex
      
        32354
            sizes := ComponentRef.sizes(stripped_cref, false, resize);
      
        32354
            subs  := ComponentRef.subscriptsToExpression(subscripted_cref, true);
      
        32354
            ty    := Type.arrayElementType(ComponentRef.getComponentType(subscripted_cref));
      
            // check if it needs special record handling
      
            scal_lst := match Type.complexSize(ty)
      
              case SOME(complex_size) algorithm
      
                scal_lst := {};
      
          1/2✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.

        329
                for i in complex_size:-1:1 loop
      
        558
                  scal_lst := listAppend(combineFramesIndices(var_start, complex_size :: sizes, Expression.INTEGER(i) :: subs, frames, resize), scal_lst);
      
                 end for;
      
              then scal_lst;
      
        32304
              else combineFramesIndices(var_start, sizes, subs, frames, resize);
      
            end match;
      
          end getCrefInFrameIndicesLocal;
      
        protected
      
          function resolveDimensionsSubscripts
      
            "uses the replacement module to replace all iterator crefs in the subscript with the current position.
      
            Returns the current positions for each subscript."
      
            input list<Integer> sizes                                     "dimension sizes";
      
            input list<Expression> subs                                   "subscript expressions";
      
            input UnorderedMap<ComponentRef, Expression> replacements     "replacement map for iterator crefs";
      
            input Boolean resize;
      
            output list<list<Integer>> values;
      
          protected
      
            list<Expression> replaced;
      
          algorithm
      
            // get all possible subscript combinations
      
          4/4✓ Branch 0 taken 9357 times.
✓ Branch 1 taken 3967 times.
✓ Branch 2 taken 9357 times.
✓ Branch 3 taken 3967 times.

        13324
            replaced := list(Expression.map(sub, function Replacements.applySimpleExp(replacements = replacements)) for sub in subs);
      
          7/8✓ Branch 0 taken 9357 times.
✓ Branch 1 taken 3967 times.
✓ Branch 2 taken 9357 times.
✓ Branch 3 taken 3967 times.
✓ Branch 4 taken 9357 times.
✓ Branch 5 taken 3967 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3967 times.

        13324
            values := list(resolveDimensionsSubscript(exp, size, resize) threaded for exp in replaced, size in sizes);
      
        3967
            values := List.combination(values);
      
          end resolveDimensionsSubscripts;
      
          function resolveDimensionsSubscript
      
            input Expression replaced;
      
            input Integer size;
      
            input Boolean resize;
      
            output list<Integer> res;
      
          protected
      
            Expression rep;
      
          algorithm
      
        9357
            rep := SimplifyExp.simplifyDump(replaced, true, getInstanceName());
      
            res := match rep
      
              local
      
                Integer start, step, stop;
      
              // just a single element; filter out-of-bounds values (Modelica arrays are 1-indexed)
      
          3/4✓ Branch 0 taken 9343 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 9343 times.
✗ Branch 3 not taken.

        9349
              case Expression.INTEGER() then if rep.value >= 1 and rep.value <= size then {rep.value} else {};
      
        ✗
              case Expression.ENUM_LITERAL() then {rep.index};
      
              // build list from range
      
              case Expression.RANGE() algorithm
      
        ✗
                (start, step, stop) := Expression.getIntegerRange(rep, resize);
      
        ✗
              then List.intRange3(start,step, stop);
      
              // resolve individual array elements
      
              case Expression.ARRAY()
      
        ✗
              then List.flatten(list(resolveDimensionsSubscript(e, size, resize) for e in rep.elements));
      
              // assume full dependency if it cannot be evaluated
      
        8
              else List.intRange(size);
      
            end match;
      
          end resolveDimensionsSubscript;
      
          function applyNewFrameRange
      
            "applies new start, step and stop to a frame"
      
            input output Frame frame;
      
            input tuple<Integer, Integer, Integer> range;
      
          algorithm
      
            frame := match frame
      
              local
      
                ComponentRef name;
      
                Expression exp;
      
                Option<Iterator> map;
      
        ✗
              case (name, exp as Expression.RANGE(), map) then (name, Expression.sliceRange(exp, range), map);
      
              case (_, exp, _) algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName()
      
                  + " failed because frame expression was not Expression.RANGE(): " + Expression.toString(exp)});
      
        ✗
              then fail();
      
            end match;
      
          end applyNewFrameRange;
      
          annotation(__OpenModelica_Interface="nbackend");
      
        end NBSlice;