443,706 Members | 2,030 Online
Need help? Post your question and get tips & solutions from a community of 443,706 IT Pros & Developers. It's quick & easy.

# Reversing the order of some loops.

 P: n/a 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 Nov 13 '05 #1
4 Replies

 P: n/a 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 Nov 13 '05 #2

 P: n/a "Brett Frankenberger" wrote in message news:bn**********@reader1.panix.com... 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 Nov 13 '05 #3

 P: n/a "Glen Herrmannsfeldt" wrote in message news:6a1mb.6076\$ao4.13422@attbi_s51... "Brett Frankenberger" wrote in message news:bn**********@reader1.panix.com... 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 Nov 13 '05 #4

 P: n/a "David Frank" wrote in message news:hk*******************@twister.tampabay.rr.com ... "Glen Herrmannsfeldt" wrote in message news:6a1mb.6076\$ao4.13422@attbi_s51... "Brett Frankenberger" wrote in message news:bn**********@reader1.panix.com... 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 Nov 13 '05 #5

### This discussion thread is closed

Replies have been disabled for this discussion.