Simplification des boucles imbriquées en C [Résolu]

Signaler
-
nagaD.scar
Messages postés
4265
Date d'inscription
samedi 8 septembre 2007
Statut
Membre
Dernière intervention
29 août 2018
-
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

7 réponses

Messages postés
14671
Date d'inscription
vendredi 14 mars 2003
Statut
Modérateur
Dernière intervention
1 avril 2020
139
Pour simplifier ton code, tournes-toi vers les fonction récursives peut être.
Messages postés
4265
Date d'inscription
samedi 8 septembre 2007
Statut
Membre
Dernière intervention
29 août 2018
16
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
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.
Messages postés
4265
Date d'inscription
samedi 8 septembre 2007
Statut
Membre
Dernière intervention
29 août 2018
16
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 ?
Messages postés
4265
Date d'inscription
samedi 8 septembre 2007
Statut
Membre
Dernière intervention
29 août 2018
16
Aussi, si tu peux donner le théorème que tu utilises, ca pourrai aider
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.
Messages postés
4265
Date d'inscription
samedi 8 septembre 2007
Statut
Membre
Dernière intervention
29 août 2018
16
J'aurai une autre question:
Pour exprimer une matrice on a seulement besoins de 2 dimensions:

Pour une dimensions :

a b c
d e f
g 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).