Discussion :

[lebelge]

Bonjour,

Je fais face au problème suivant : je dois faire un certain nombre de boucles imbriquées, ce nombre étant un paramètre à entrer par l'utilisateur.

La structure imbriquée normale serait donc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
do i1 = 1, n1
 do i2 = 1, n2
  do i3 = 1, n3
  ...
  ...
  enddo
 enddo
enddo

Sauf que, bien sûr, le nombre de ces boucles dépendra de ce que va choisir l'utilisateur. Je ne peux donc pas l'écrire comme ca.
Quelqu'un connait-il une solution pour générer un nombre de boucles imbriquées variable ?

Merci d'avance

[Sylvain Bergeron]

Voici ce que j'ai en réserve :

NestedLoop.zip

Je n'ai pas regardé le contenu récemment. À toi de faire le tri de ce qui est pertinent...

[lebelge]

merci beaucoup. J'adorerai etre fort et avoir tout compris mais malheureusement ce n'est pas le cas, je bricole seulement en fortran, qui plus est en fortran 77 (votre code est du 95).
Je commente ci-dessous un des programmes que vous m'avez envoye, pourriez-vous confirmer lorsque mes commentaires sont justes et completer la ou il en manque ? Vraiment desole, mais il faut me considerer comme un debutant.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

!!! Declaration des variables !!
integer :: nLoop ! Nombre de boucles
integer :: iLoop ! Boucle courante
integer :: iMin(nLoop) ! Borne minimale de chaque boucle
integer :: iMax(nLoop) ! Borne maximale de chaque boucle
integer :: iStep(nLoop) ! Incrément de chaque boucle
integer :: i(nLoop) ! Index courant de chaque boucle
!!!!!!!!!!!!!!!!!!!!!!!!

!!! Valeurs a rentrer par le programmeur ou l'utilisateur
iMin(: ) = ...
iMax(: ) = ...
iStep(: ) = ...
!!!!!!!!!!!!!!!!!!!!!!

i = iMin
!!! On fixe la valeur de i a iMin. Mais a quoi va servir ce i ? i est un vecteur ou un entier ?

if (all((iMax => iMin .and. iStep > 0) .or. (iMax <= iMin .and. iStep < 0))) then ! zero trip...
!!! si la borne sup est plus grande que la borne inf et que l'increment est positif ou si l'inverse est vrai alors...


   outer:do
!!! ... on fait la chose suivante

      Expression sur i(: ) ...

!!! Ca c'est quoi ? Expression sur i(: ), je n'ai pas compris ce que represente i... Quel est son role ? 

      iLoop = nLoop
!!! On fixe la boucle courante a la valeur de la dernier boucle desiree

      i(iLoop) = i(iLoop) + iStep(iLoop)
!!! La derniere valeur de i (qui donc est en fait un vecteur) est incrementee. Mais que vaut i(iLoop) puisque celui-ci n'est pas initialise ?

!!! Du coup, sans comprendre ce qui precede, je peux pas comprendre ce qui suit.
      do while((i(iLoop) > iMax(iLoop) .and. iStep(iLoop) > 0) .or. (i(iLoop) < iMax(iLoop) .and. iStep(iLoop) < 0))
         i(iLoop) = iMin(iLoop)
         iLoop = iLoop - 1
         if (iLoop < 1) exit Outer
         i(iLoop) = i(iLoop) + iStep(iLoop) 
      enddo
   enddo
endif

[lebelge]

En fait, pour faire plus simple, je vais vous exposer ce que j'essaye de faire (c'est tres simple), ce sera plus efficace.
Je dois generer toutes les partitions possibles de n objets dans m lieux differents, avec au-moins un objet dans chaque lieu.
Si on a 5 objets et 3 lieux, on peut avoir:
{1}{1}{3}, {1}{2}{2}, {1}{3}{1}, {2}{1}{2}, {2}{2}{1}, {3}{1}{1}, soit 6 possibilites.

Quand m vaut 4, par exemple, le programme sera le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
	do i1 = 1, n-m+1
	 do i2 = 1, n-i1-1
	  do i3 = 1, n-i1-i2-1
	   i4 = n-i1-i2-i3
	   write(*,*) i1, i2, i3, i4
	  enddo
	 enddo
	enddo

Mais je dois généraliser cela avec m quelconque, m étant entré par l'utilisateur lors de l'exécution du programme.

Voila, merci beaucoup

[Sylvain Bergeron]

Tu devras malheureusement faire un peu d'effort... Ton problème est très spécifique. Ou bien tu fais le travail, ou bien tu espère que quelqu'un le fasse pour toi...

La piste que je te suggère:

• Part du code que je t'ai fourni et essai de la comprendre.
• Ensuite, modifie pour l'adapter à F77
• Comme le nombre de boucle n'est pas connu, tu devras allouer les vecteurs dynamiquement (F95) ou les déclarer très grand (F77)
• Pour tes bornes supérieures variables, le plus simple est probablement de ne pas en tenir compte et de simplement rejeter les cas tel que la somme <> n

[lebelge]

merci,

A vrai dire, oui, ca m'aurait bien aide qu'on le fasse pour moi...
Je ne suis pas un etudiant qui doit passer un examen et qui essaye de le faire faire par un autre, je travaille. Et de temps a autre j'utilise mes (maigres) connaissances en fortran pour aller plus vite dans ce que je fais.

Je n'ai pas de temps a investir pour comprendre et adapter des programmes. J'en suis le premier desole.
Mais merci tout de meme.