simplification des boucles imbriquées en CRésolu

Question

Bonjour, 
J'ai un programme ou je doit utiliser des boucles imbriquer. Je veux faire K boucles avec K et un paramètre , la taille de chaque boucle dans un tableau N[K] , un tableau des indices i[k] :
for ( i[0]=0 ; i[0]<N[0] ;  i[0]++){      for ( i[1]=0 ; i[1]<N[1] ; i[1]++){            for ( i[2]=0 ; i[2]<N[2] ;  i[2]++){                   for ( i[3]=0 ; i[3]<N[3] ; i[3]++){                                         .                                         .                                                           .                                         for ( i[K-1]=0 ; i[K-1]<N[K-1] ; i[K-1]++){                                                      ..........................                                         }                                         .                                         .                                                           .                  }            }      }}
à chaque fois le K augmente le programme devenir lourde et je n'arrive pas à l'exécuter.
comment je peux réduire les boucles d'une manière optimal pour accélérer mon programme.

Merci pour votre aide

NHenry · Answer

Pour simplifier ton code, tournes-toi vers les fonction récursives peut être.

nagaD.scar · Answer

La récusivité va en effet te permettre d avoir un k dynamique et un code plus lisible. Par exemple:

void recLoop(int k) 
{
   int i =0;
   for(i=0; i < k ; i++){
        recLoop(k-1);
   }
}

mais il faudrai savoir quel traitements tu veux faire pour mieux t aider. 
Par contre ca ne t aidera pas concernant la lourdeur de l exécution. 
Si tu expose ce que tu veux faire, on pourra t aider. 
naga

benhilal · Answer

supposons que j'ai une matrice M de dimension K et je veux calculer la dérivation partiel pour chaque dimension  de cette matrice.
Alors pour la dimension K je dois utiliser K boucles pour chaque dériver partiel
si K=3 :
for(i2=0 ; i2<N[2] ; i2++){    for(i1=0 ; i1<N[1] ; i1++){        for(i0=1 ; i0<N[0] ; i0++){            Dx0[i0-1][i1][i2] = M[i0][i1][i2] -M[i0-1][i1][i2]  ;        }    }}
for(i0=0 ; i0<N[0] ; i0++){    for(i2=0 ; i2<N[2] ; i2++){        for(i1=1 ; i1<N[1] ; i1++){            Dx0[i0][i1-1][i2] = M[i0][i1][i2] -M[i0][i1-1][i2]  ;        }    }}
for(i1=0 ; i1<N[1] ; i1++){    for(i0=0 ; i0<N[0] ; i0++){        for(i2=1 ; i2<N[2] ; i2++){            Dx0[i0][i1][i2-1] = M[i0][i1][i2] -M[i0][i1][i2-1]  ;        }    }}
je cherche une méthode générale pour diminuer la quantité de code 
Merci pour votre aide.

nagaD.scar · Answer

Re, 
Que vaut '  N  ' ? il limite tes itération mais je n ai aucunes idées de ce qu il représente. 
Et je suppose que Dx0 est la valeur de retour?
Et je ne comprends par ton exemple .. si on prend la première itération avec les 3, ca nous donnerai : 
 - Dx0[0][0][0] =  M[1][0][0] - M[0][0][0]
 - Dx0[0][0][0] = M[0][1][0] - M[0][0][0]
 - Dx0[0][0][0] = M[0][0][1] - M[0][0][0]
Du coup laquelle est vrai ?

nagaD.scar · Answer

Aussi, si tu peux donner le théorème que tu utilises, ca pourrai aider

benhilal · Answer

Je 'excuse c'est une erreur de notation .
J'ai une matrice M de dimension K avec k = 0,1,2....K pour chaque dimension k j'ai une taille N[k]. je veux calculer la dérivation partielle pour chaque dimension de cette matrice
for(i2=0 ; i2<N[2] ; i2++){
    for(i1=0 ; i1<N[1] ; i1++){
        for(i0=1 ; i0<N[0] ; i0++){
            Dx0[i0-1][i1][i2] = M[i0][i1][i2] -M[i0-1][i1][i2]  ;
        }
    }
}

for(i0=0 ; i0<N[0] ; i0++){
    for(i2=0 ; i2<N[2] ; i2++){
        for(i1=1 ; i1<N[1] ; i1++){
            Dx1[i0][i1-1][i2] = M[i0][i1][i2] -M[i0][i1-1][i2]  ;
        }
    }
}

for(i1=0 ; i1<N[1] ; i1++){
    for(i0=0 ; i0<N[0] ; i0++){
        for(i2=1 ; i2<N[2] ; i2++){
            Dx2[i0][i1][i2-1] = M[i0][i1][i2] -M[i0][i1][i2-1]  ;
        }
    }
}
Si j'ai la dimension K=7 je dois avoir 7 blocs pour calculer la dérivée partielle pour chaque dimension et dans chaque bloc il faut 7 boucles imbriquées. 
Je veux réduire mon programme dans une seul bloc.
Merci pour votre aide
      EDIT : Ajout des balises de code (la coloration syntaxique).
Explications disponibles ici : ICI 
Merci d'y penser dans tes prochains messages.

nagaD.scar · Answer

J'aurai une autre question: 
Pour exprimer une matrice on a seulement besoins de 2 dimensions: 
Pour une dimensions : 
a   b   cd   e   fg   h   i
on aurai:

M[0][0]= a;
M[0][1]= b;
M[0][2]= c;
M[1][0]= d;
.
.
.
M[2][2]=i;

(avec bien sûr a, b, etc étant des entiers. 
Hors, dans ton code, ton tableau à une troisième dimension, ce qui sous entant un 3ème axe .... je penses que tu es dans l erreur non? Car tu ne semble pas vouloir t intéresser aux matrices cubiques ( ou même supérieur)  je me trompe? 
Car si tu veux en effet dériver des matrices sous N dimensions (je serai d ailleurs curieux de savoir le contexte pour la7 ème dimension). 
Pour commencer je pense qu en exposant ton algo de cette manière:

for(j0=0 ; j0<N[0] ; j0++){ 
  for(j1=0 ;j1<N[2] ; j1++){ 
   for(j2=1 ; j2<N[1] ; j2++){ 
    Dx[j2-1][j1][j0] = M[j2][j1][j0] -M[j2-1][j1][j0] ; 
    Dx[j0][j2-1][j1] = M[j0][j2][j1] -M[j0][j2-1][j1] ; 
    Dx[j1][j0][j2-1] = M[j1][j0][j2] -M[j1][j0][j2-1] ; 
   } 
  } 
 }

ca sera déjà plus facile à lire. Et donc, me confirme tu que pour 4 dimensions on aurai :

for(j0=0 ; j0<N[0] ; j0++){ 
  for(j1=0 ;j1<N[3] ; j1++){ 
   for(j2=0 ; j2<N[2] ; j2++){ 
    for(j3=1 ; j3<N[1] ; j3++){ 3
     Dx[j3-1][j2][j1][j0] = M[j3][j2][j1][j0] -M[j3-1][j2][j1][j0] ; 
     Dx[j0][j3-1][j2][j1] = M[j0][j3][j2][j1] -M[j0][j3-1][j2][j1] ; 
     Dx[j1][j0][j3-1][j2] = M[j1][j0][j3][j2] -M[j1][j0][j3-1][j2] ; 
     Dx[j2][j1][j0][j3-1] = M[j1][j0][j2][j3] -M[j2][j1][j0][j3-1] ; 
    } 
   } 
  } 
 } 

? (c'est potentiellement faux, je l ai just determiné par rapport à la logique de base donc corriges moi si c est le cas).

Simplification des boucles imbriquées en C

7 réponses

Votre réponse

Discussions similaires