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

benhilal - 23 nov. 2016 à 15:33 - Dernière réponse : nagaD.scar 4269 Messages postés samedi 8 septembre 2007Date d'inscription 29 août 2018 Dernière intervention
- 28 nov. 2016 à 12:23
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
Afficher la suite 

Votre réponse

7 réponses

Meilleure réponse
NHenry 14262 Messages postés vendredi 14 mars 2003Date d'inscriptionModérateurStatut 22 septembre 2018 Dernière intervention - 23 nov. 2016 à 18:01
1
Merci
Pour simplifier ton code, tournes-toi vers les fonction récursives peut être.

Merci NHenry 1

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 92 internautes ce mois-ci

Commenter la réponse de NHenry
nagaD.scar 4269 Messages postés samedi 8 septembre 2007Date d'inscription 29 août 2018 Dernière intervention - 25 nov. 2016 à 14:20
0
Merci
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
Commenter la réponse de nagaD.scar
0
Merci
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.
Commenter la réponse de benhilal
nagaD.scar 4269 Messages postés samedi 8 septembre 2007Date d'inscription 29 août 2018 Dernière intervention - Modifié par nagaD.scar le 28/11/2016 à 09:16
0
Merci
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 ?
Commenter la réponse de nagaD.scar
nagaD.scar 4269 Messages postés samedi 8 septembre 2007Date d'inscription 29 août 2018 Dernière intervention - 28 nov. 2016 à 09:25
0
Merci
Aussi, si tu peux donner le théorème que tu utilises, ca pourrai aider
Commenter la réponse de nagaD.scar
0
Merci
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.
Commenter la réponse de benhilal
nagaD.scar 4269 Messages postés samedi 8 septembre 2007Date d'inscription 29 août 2018 Dernière intervention - Modifié par nagaD.scar le 28/11/2016 à 12:23
0
Merci
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).
Commenter la réponse de nagaD.scar

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.