Structure de boucle infinie ( boucle $tant que$)

Fortran 90 posséde une structure de boucle infinie. Bien sûr son intérêt se justifie en tant qu'une boucle à répétition dite conditionnelle c-à-d dans laquelle la poursuite est régie par une condition.

Syntaxe de la boucle.

 
       [nom:]    DO 
                   bloc1
                   IF (exp_log) EXIT
                   bloc2
                 ENDDO [nom]

$bloc1$ est exécuté et si $exp\underline{~~}log$ est vraie on sort de la boucle (i.e on exécute les instructions juste après $ENDDO$) sinon on exécute le $bloc2$ et on recommence.

$\ominus$ Il faut que la valeur de $exp\underline{~~}log$ change à l'intérieur des blocs concernés sinon on aboutira à une boucle infinie (et le programme se demandera où est la sortie !!)

Exemple.

 
       DO
         IF (S >= 100) EXIT
         PRINT*,'Donner un nombre entier : '
         READ*,N
          S= S+N
       ENDDO

cela veut dire, tant que $S < 100$, alors on exécute le bloc.

Un exemple avec l'utilisation des noms des boucles :

 
       Fini = .FALSE.
   compte: DO
             READ*,S
             IF (S < 0.) EXIT compte
      somme: DO I=1,N
                S = S + A(I)
                IF (S < 0.) EXIT compte
                Y(I) = LOG(S)
             ENDDO somme
             Z = 2.*LOG(S)            
           ENDDO compte

$\ominus$ L'instruction EXIT peut apparaître dans n'importe quel type de boucle : avec compteur, boucle infinie. Dans cet exemple si on précise pas le nom de la boucle dans

 
       IF (S < 0.) EXIT compte

alos le programme sort de la boucle $somme$ et dans ce cas il calcule $z$ et il se plante via un 'overflow'

On peut utiliser également la boucle DO WHILE, par exemple

 
       DO WHILE (S< 100) 
         PRINT*,'Donner un nombre entier : '
         READ*,N
          S= S+N
       ENDDO

tant que la condition est vraie alors les instructions sont exécutées.