In C, how to write a N-dimensional nested for loop where N is variable

Question

I need to write the statement:

for ( int i1 = i1_min; i1 < width; ++i1 )
    for ( int i2 = i2_min; i2 < i2_max; ++i2 )
        for ( int i3 = i3_min; i3 < i3_max; ++i3 )
            ...
                for ( int iN = iN_min; iN < iN_max; ++iN )

How to do it?

Recursive function comes to mind. What are you trying to do? N-dimensional for loops like this are [_O(scary)_](https://stackoverflow.com/a/185576/1541563). — Patrick Roberts, Feb 06 '18 at 22:49
@rcgldr funny how the answer to how to not nest lots of loops is to use a loop (and array) — Nick is tired, Feb 06 '18 at 22:49
From top of my head, it looks like you could flatten these and have one loop that goes from 0 to `width * i2max * ... * inmax` and to calculate indices (if you need them) inside the loop body by dividing the index with the appropriate degree. — Nemanja Boric, Feb 06 '18 at 23:34

Patrick Roberts · Accepted Answer · 2018-02-06T23:20:20.157

You could write a recursive function loopn() to do this:

void loopn_recurse (int *min, int *max, int *counters, size_t N, size_t n, void (*func)(int*, size_t)) {
  for (int i = min[n]; i < max[n]; ++i) {
    counters[n] = i;

    if (N - n > 1) {
      loopn_recurse(min, max, counters, N, n + 1, func);
    } else {
      // innermost algorithm
      func(counters, N);
    }
  }
}

void loopn (int *min, int *max, int *counters, size_t N, void (*func)(int*, size_t)) {
  assert(N > 0);
  loopn_recurse(min, max, counters, N, 0, func);
}

// example usage

void test (int *counters, size_t N) {
  for (size_t j = 0; j < N; ++j) {
    printf("%d ", counters[j]);
  }

  putchar('\n');
}

loopn((int[]){ 1, 2, 3, 4, 5 }, (int[]){ 2, 4, 6, 8, 10 }, (int[5]){}, 5, test);

Try it online!

Jakub Piskorz · Answer 2 · 2018-02-06T23:53:05.393

It is possible to represent N-dimensional space as 1-dim, with one index, from which you can calculate N sub-indexes if you need them.

Below I'm attaching example implementation of this kind of space flattening

#include <stdio.h>

int bonds[][2] = {
  {1, 2},
  {5, 10},
  {0, 3},
  {6, 8}
};

int get_index(int index_position, int current, int sizes[], int sizes_size) {
  int mod = 1;
  for(int i = index_position; i < sizes_size; i++) {
    mod *= sizes[i];
  }

  int div = mod / sizes[index_position];

  return (current % mod) / div;
}

int main(int argc, char** argv) {

  int sizes[] = {
    bonds[0][1] - bonds[0][0],
    bonds[1][1] - bonds[1][0],
    bonds[2][1] - bonds[2][0],
    bonds[3][1] - bonds[3][0]
  };

  int big_size = sizes[0] * sizes[1] * sizes[2] * sizes[3];

  for(int i = 0; i < big_size; i++) {
    /* get indexes */

    /*
    int i0 = ((i % (sizes[0] * sizes[1] * sizes[2] * sizes[3])) / (sizes[1] * sizes[2] * sizes[3])) + bonds[0][0];
    int i1 = ((i % (           sizes[1] * sizes[2] * sizes[3])) / (           sizes[2] * sizes[3])) + bonds[1][0];
    int i2 = ((i % (                      sizes[2] * sizes[3])) / (                      sizes[3])) + bonds[2][0];
    int i3 = ((i % (                                 sizes[3]))                                   ) + bonds[3][0];
    */

    int i0 = get_index(0, i, sizes, 4) + bonds[0][0];
    int i1 = get_index(1, i, sizes, 4) + bonds[1][0];
    int i2 = get_index(2, i, sizes, 4) + bonds[2][0];
    int i3 = get_index(3, i, sizes, 4) + bonds[3][0];

    printf("%d %d %d %d\n", i0, i1, i2, i3);
  }

  return 0;
}

Dynamic handling of bonds/sizes array is out scope here. The example shows how to calculate sub-indexes from flattened space.

score 0 · Answer 3 · answered Feb 06 '18 at 23:35

0

If what you need to do is for really variable N, then recursive one by Patrick is a way to go.

If what you try to do is for fixed variable N and you are trying to avoid typing for loop repetitively, you can use macro to save some keystrokes:

#define LOOP(N) for (int i#N = i#N#_min; i#N < i#N#_max; ++i#N )

LOOP(1)
LOOP(2)
LOOP(3)
LOOP(4)
LOOP(5) {
   val = i1+i2+i3+i4+i5; // example calculation
}

answered Feb 06 '18 at 23:35

Chul-Woong Yang

1,223
10
17

I'm trying to implement the standard method for calculating capacity dimension (fractal dimension), but I want to do generalize it for an n-dimensional system. It requires to make a n-dimensional grid and run using nested-loops. I'm gonna try your advices and tell which was better. Thanks for everyone! – CAMILO HG Feb 07 '18 at 03:48

In C, how to write a N-dimensional nested for loop where N is variable

3 Answers3