Reversing the order of some loops.

Discussion in 'C Programming' started by Dr. David Kirkby, Oct 22, 2003.

  1. I have a program that loops through and changes all the elements on an
    array n times, so my code looks like this:

    for (n=1; n < n_max; ++n)
    for(i=imax; i >= 0; --i) {
    for(j=0 ; j < jmax; ++j) {
    /* main bulk of code goes here */
    }
    }

    The problem is I want to reverse the order of the **two inner loops**,
    so I have all 4 possible combinations of the loops incrementing and
    decrement i and j. So on the first iteration of n (n=1), i and j will
    both incremnt from 0 to their maximum values, but on another they will
    decmement from their maximum values to 0. The second permetation would
    be:

    for(i=imax; i >= 0; --i) {
    for(j=0 ; j < jmax; ++j) {
    /* loads of code goes here */
    }
    }

    where I have reversed the i loop, and this one where the j loop is
    reversed. The other two combinations would be:

    for(i=0; i< imax; ++i) {
    for(j=jmax ; j >= 0; --j) {

    And finally:

    for(i=imax; i >= 0; --i) {
    for(j=jmax ; j >= 0; --j) {

    Can anyone find a ***neat*** way of doing this in a C function?


    The only way I have found to do this is at the minute is rather ugly.
    I have a C function (which could be main), with four #includes, and
    four #defines, which includes a C source file. The exact ordering of
    the loops in the included file depends on what is #defined in the main
    file. In other words I have:


    int main()
    {
    for(n=1; n < n_max; ++n) {

    #define TO_BOTTOM_RIGHT
    #include "update_voltage_array.c"
    #undef TO_BOTTOM_RIGHT

    #define TO_BOTTOM_LEFT
    #include "update_voltage_array.c"
    #undef TO_BOTTOM_LEFT

    #define TO_TOP_RIGHT
    #include "update_voltage_array.c"
    #undef TO_TOP_RIGHT

    #define TO_TOP_LEFT
    #include "update_voltage_array.c"
    #undef TO_TOP_LEFT
    }


    then in the file "update_voltage_array.c", I don't have a function,
    but bits like this:

    #ifdef TO_BOTTOM_RIGHT
    for(i= 0; i <= imax; ++i){
    for(j=0; j<=jmax; ++j) {
    #endif

    #ifdef TO_BOTTOM_LEFT
    for(i= imax; i >=0 ; --i){
    for(j=0; j<=jmax; ++j) {
    #endif

    #ifdef TO_TOP_RIGHT
    for(i= 0; i <= imax; ++i){
    for(j=height-1; j>=0; --j) {
    #endif

    #ifdef TO_TOP_LEFT
    for(i= imax; i >=0; --i){
    for(j=jmax; j>=0; --j) {
    #endif


    Can anyone think of a better way of achieving what I want to achieve?
    Ideally a function which took a couple of arguments to determine how
    the loops behave would be good, but I can't find a way of doing it.
    Whilst its easy to pass the start and end points of the loops, I can
    find no way of changing the "i < imax" to be an "i >= 0", so passing
    those does not help.

    Suggestions welcome.

    Dr. David Kirkby.

    My real email address can be found at:
    http://homepage.ntlworld.com/drkirkby/home-email.jpg
    Dr. David Kirkby, Oct 22, 2003
    #1
    1. Advertising

  2. In article <>,
    Dr. David Kirkby <> wrote:
    >
    >Can anyone find a ***neat*** way of doing this in a C function?


    for (n=1; n < n_max; n++)
    for (k=0; k<4; k++)
    for (i1=0; i1 < imax; i1++)
    for (j1 = 0; j1 < jmax; j1++) {
    i = n & 1 ? i1 : imax - i1;
    j = n & 2 ? j1 : jmax - j1;
    ...
    };

    Or perhaps:

    for (n=1; n < n_max; n++)
    for (k=0; k<4; k++)
    for (i = n&1 ? 0 : imax; n&1 ? i < imax : i >= 0 ; n&1 ? i++ : i--)
    for (j = n&2 ? 0 : jmax; n&2 ? j < imax : j >= 0 ; n&2 ? j++ : j--) {
    ...
    };

    -- Brett
    Brett Frankenberger, Oct 22, 2003
    #2
    1. Advertising

  3. "Brett Frankenberger" <> wrote in message
    news:bn4u2o$ice$...
    > In article <>,
    > Dr. David Kirkby <> wrote:
    > >
    > >Can anyone find a ***neat*** way of doing this in a C function?

    >
    > for (n=1; n < n_max; n++)
    > for (k=0; k<4; k++)
    > for (i1=0; i1 < imax; i1++)
    > for (j1 = 0; j1 < jmax; j1++) {
    > i = n & 1 ? i1 : imax - i1;
    > j = n & 2 ? j1 : jmax - j1;
    > ...
    > };
    >
    > Or perhaps:
    >
    > for (n=1; n < n_max; n++)
    > for (k=0; k<4; k++)
    > for (i = n&1 ? 0 : imax; n&1 ? i < imax : i >= 0 ; n&1 ? i++ : i--)
    > for (j = n&2 ? 0 : jmax; n&2 ? j < imax : j >= 0 ; n&2 ? j++ :

    j--) {

    I think you have some n's where you should have k's, but otherwise...

    I would probably use a switch with four sets of loops inside. That would
    give the compiler a chance to properly optimize each loop. Otherwise, the
    fisst one might optimize better than the second, though the second probably
    satisfies the "neat" requirement better.

    Just to complain again about the lack of power of the C preprocessor
    relative to PL/I, the PL/I preprocessor could expand four loops at compile
    time a little easier than C.

    -- glen
    Glen Herrmannsfeldt, Oct 24, 2003
    #3
  4. Dr. David Kirkby

    David Frank Guest

    "Glen Herrmannsfeldt" <> wrote in message
    news:6a1mb.6076$ao4.13422@attbi_s51...
    >
    > "Brett Frankenberger" <> wrote in message
    > news:bn4u2o$ice$...
    > > In article <>,
    > > Dr. David Kirkby

    <> wrote:
    > > >
    > > >Can anyone find a ***neat*** way of doing this in a C function?

    > >
    > > for (n=1; n < n_max; n++)
    > > for (k=0; k<4; k++)
    > > for (i1=0; i1 < imax; i1++)
    > > for (j1 = 0; j1 < jmax; j1++) {
    > > i = n & 1 ? i1 : imax - i1;
    > > j = n & 2 ? j1 : jmax - j1;
    > > ...
    > > };
    > >
    > > Or perhaps:
    > >
    > > for (n=1; n < n_max; n++)
    > > for (k=0; k<4; k++)
    > > for (i = n&1 ? 0 : imax; n&1 ? i < imax : i >= 0 ; n&1 ? i++

    : i--)
    > > for (j = n&2 ? 0 : jmax; n&2 ? j < imax : j >= 0 ; n&2 ?

    j++ :
    > j--) {
    >
    > I think you have some n's where you should have k's, but

    otherwise...
    >
    > I would probably use a switch with four sets of loops inside. That

    would
    > give the compiler a chance to properly optimize each loop.

    Otherwise, the
    > fisst one might optimize better than the second, though the second

    probably
    > satisfies the "neat" requirement better.
    >
    > Just to complain again about the lack of power of the C preprocessor
    > relative to PL/I, the PL/I preprocessor could expand four loops at

    compile
    > time a little easier than C.
    >
    > -- glen
    >
    >
    >


    And Fortran will unroll and inline the subroutine code even better
    with no preprocessor help..

    This problem seems to invite "parallelization" and the
    Fortran syntax,

    forall (i=1:imax,j=1:jmax) array_stuff

    is a invitation for the compiler to generate multi-processor code.

    Lacking multi-processing capability, I would put below in my exec,
    and call the array stuff with appropriate indices..

    ! ----------------------
    do n = 1,n_max

    icase = mod(n-1,4)+1 ! 4 sequential "n cases"

    select case (icase)
    case (1)
    do i = 1,imax
    do j = 1,jmax
    call array_stuff(i,j)
    end do
    end do
    case (2)
    do i = 1,imax
    do j = jmax,1,-1
    call array_stuff(i,j)
    end do
    end do
    case (3)
    do i = imax,1,-1
    do j = 1,jmax
    call array_stuff(i,j)
    end do
    end do
    case (4)
    do i = imax,1,-1
    do j = jmax,1,-1
    call array_stuff(i,j)
    end do
    end do
    end select
    end do
    David Frank, Oct 25, 2003
    #4
  5. "David Frank" <> wrote in message
    news:hktmb.34803$...
    >
    > "Glen Herrmannsfeldt" <> wrote in message
    > news:6a1mb.6076$ao4.13422@attbi_s51...
    > >
    > > "Brett Frankenberger" <> wrote in message
    > > news:bn4u2o$ice$...
    > > > In article <>,
    > > > Dr. David Kirkby

    > <> wrote:
    > > > >
    > > > >Can anyone find a ***neat*** way of doing this in a C function?
    > > >
    > > > for (n=1; n < n_max; n++)
    > > > for (k=0; k<4; k++)
    > > > for (i1=0; i1 < imax; i1++)
    > > > for (j1 = 0; j1 < jmax; j1++) {
    > > > i = n & 1 ? i1 : imax - i1;
    > > > j = n & 2 ? j1 : jmax - j1;
    > > > ...
    > > > };
    > > >
    > > > Or perhaps:
    > > >
    > > > for (n=1; n < n_max; n++)
    > > > for (k=0; k<4; k++)
    > > > for (i = n&1 ? 0 : imax; n&1 ? i < imax : i >= 0 ; n&1 ? i++

    > : i--)
    > > > for (j = n&2 ? 0 : jmax; n&2 ? j < imax : j >= 0 ; n&2 ?

    > j++ :
    > > j--) {
    > >
    > > I think you have some n's where you should have k's, but

    > otherwise...
    > >
    > > I would probably use a switch with four sets of loops inside. That

    > would
    > > give the compiler a chance to properly optimize each loop.

    > Otherwise, the
    > > fisst one might optimize better than the second, though the second

    > probably
    > > satisfies the "neat" requirement better.
    > >
    > > Just to complain again about the lack of power of the C preprocessor
    > > relative to PL/I, the PL/I preprocessor could expand four loops at

    > compile
    > > time a little easier than C.
    > >
    > > -- glen
    > >
    > >
    > >

    >
    > And Fortran will unroll and inline the subroutine code even better
    > with no preprocessor help..
    >
    > This problem seems to invite "parallelization" and the
    > Fortran syntax,
    >
    > forall (i=1:imax,j=1:jmax) array_stuff
    >
    > is a invitation for the compiler to generate multi-processor code.
    >
    > Lacking multi-processing capability, I would put below in my exec,
    > and call the array stuff with appropriate indices..
    >
    > ! ----------------------
    > do n = 1,n_max
    >
    > icase = mod(n-1,4)+1 ! 4 sequential "n cases"
    >
    > select case (icase)
    > case (1)
    > do i = 1,imax
    > do j = 1,jmax
    > call array_stuff(i,j)
    > end do
    > end do
    > case (2)
    > do i = 1,imax
    > do j = jmax,1,-1
    > call array_stuff(i,j)
    > end do
    > end do
    > case (3)
    > do i = imax,1,-1
    > do j = 1,jmax
    > call array_stuff(i,j)
    > end do
    > end do
    > case (4)
    > do i = imax,1,-1
    > do j = jmax,1,-1
    > call array_stuff(i,j)
    > end do
    > end do
    > end select
    > end do


    I don't think you are answering the right question.

    What the PL/I preprocessor can do is generate the four different
    combinations of increment/decrement loops. Well, that would be more
    important if the stuff inside the loop were more complicated.

    That doesn't have anything to do with parallelization. The original
    question didn't say why those four choices were needed.

    -- glen
    Glen Herrmannsfeldt, Oct 26, 2003
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. flipflop

    Reversing order of quicksort

    flipflop, May 28, 2004, in forum: C Programming
    Replies:
    3
    Views:
    353
    Martin Ambuhl
    May 28, 2004
  2. flipflop

    Reversing order of quicksort

    flipflop, May 28, 2004, in forum: C Programming
    Replies:
    2
    Views:
    378
    Robert Wessel
    May 30, 2004
  3. Marcin Ciura
    Replies:
    27
    Views:
    575
    Terry Reedy
    Mar 22, 2007
  4. Kelly B

    Reversing order of words in a given string

    Kelly B, Apr 26, 2007, in forum: C Programming
    Replies:
    2
    Views:
    350
    Kelly B
    Apr 26, 2007
  5. Replies:
    9
    Views:
    942
    Juha Nieminen
    Aug 22, 2007
Loading...

Share This Page