next up previous
Next: Les tableaux Up: Initiation au Langage Fortran Previous: Entrées / Sorties

Sous-sections

Contrôle de l'exécution

Un programme enchaîne les instructions qu'on lui donne une à une dans l'ordre. Pour réaliser un vrai programme, il faut tout de même disposer de moyens pour faire des tests et des boucles : on appelle cela le contrôle d'exécution.

Instructions conditionnelles

Objectif

Exécuter une séquence d'instructions si une condition logique est vérifiée, sinon en exécuter une autre.

Syntaxes

Pour exécuter une série d'instructions uniquement si une condition logique est vraie :

if (condition logique) then
    ...
    ...
endif

On peut aussi spécifier une autre série d'instructions à exécuter si la condition logique est fausse :

if (condition logique) then
    ...
    ...
else
    ...
    ...
endif

On peut même enchaîner plusieurs conditions logiques :

if (condition logique 1) then
    ...
    ...
else if (condition logique 2) then
    ...
    ...
else if (condition logique 3) then
    ...
    ...
else
    ...
    ...
endif

Le programme exécute le bloc d'instructions suivant la première condition logique vraie puis reprend après endif. Si aucune condition logique n'est vraie, le bloc else est exécuté.

Expressions logiques

Ce sont des objets de type logical.

Ils ne peuvent prendre que deux valeurs

.true.
.false.

Une expression logique est en général le résultat d'une comparaison entre deux objets :

En maths En FORTRAN En Anglais
x = y x.eq.y « equal »
$x \neq y$ x.ne.y « not equal »
x > y x.gt.y « greater than »
x < y x.lt.y « less than »
$x \geq y$ x.ge.y « greater or equal »
$x \leq y$ x.le.y « less or equal »

On peut combiner ces expressions entre elles avec les opérateurs logiques usuels :

Ou .or.
Et .and.
Ou exclusif .xor.
Négation .not.

Exemples

Pour lire un caractère au clavier et agir en conséquence en tenant compte du fait que l'utilisateur peut répondre « Oui » en tapant O majuscule ou o minuscule, et idem pour non (avec N ou n) :

      character rep
      ...
      write(*,'(a,$)')
     &  'Répondez par (o)ui ou (n)on :'
      read(*,a) rep
      
      if (rep.eq.'0'.or.rep.eq.'o') then
        write(*,*) 'Vous répondîtes oui'
        ...
      else if (rep.eq.'N'.or.rep.eq.'n') then
        write(*,*) 'Vous répondîtes non'
        ...
      
      else
        write(*,*)
     &    'Vous répondîtes n''importe quoi'
        ...
      endif

Pour tester le signe du discriminant d'une équation du second degré :

      double precision a,b,c,delta,x1,x2
      ...
      delta=b**2-4*a*c
      x1=(-b-dsqrt(delta))/2/a
      x2=(-b+dsqrt(delta))/2/a
      
      if (delta.gt.0d0) then
        write(*,*) x1,x2
      
      else if (delta.eq.0d0) then
        write(*,*) x1
      
      else
        write(*,*) 'Pas de racines'
      endif

Variables logical

On peut déclarer des variables de ce type et leur affecter comme valeur :

Cela sert parfois à améliorer la lisibilité des programmes.

Par exemple, pour l'équation du second degré :

      double precision a,b,c,delta,x1,x2
      logical une_racine
      logical deux_racines
      ...
      delta=b**2-4*a*c
      une_racine=(delta.eq.0d0)
      deux_racines=(delta.gt.0d0)
      
      if (deux_racines) then
        x1=(-b-dsqrt(delta))/2/a
        x2=(-b+dsqrt(delta))/2/a
        write(*,*) x1,x2
      else if (une_racine) then
        x1=-b/2/a
        write(*,*) x1
      else
        write(*,*) 'Pas de racines'
      endif

Boucles

Objectif

Une boucle permet d'exécuter une séquence d'instructions plusieurs fois d'affilée.

Le nombre de boucles peut être déterminé :

Boucles do ... enddo

On effectue la boucle un nombre de fois prédéterminé.

Syntaxes

do var = deb, fin
    ...
    ...
enddo

do var = deb, fin, pas
    ...
    ...
enddo

Fonctionnement

var est une variable de type integer et deb, fin et pas sont des objets de type integer (constantes ou variables).

La variable var prend d'abord la valeur de deb et est augmenté de pas à chaque boucle. Dès que var > fin, la boucle s'arrête et l'exécution continue après le enddo.

L'entier pas peut être omis et vaut 1 par défaut.

Si fin<deb et pas>0, la boucle n'est jamais exécutée.

Si fin>deb et pas<0, la boucle n'est jamais exécutée.

Exemples

Somme des premiers nombres entiers jusqu'à n :

      ... ! affectation de n
      somme=0
      
      do i=1,n
        somme=somme+i
      enddo

ou bien encore :

      ... ! affectation de n
      somme=0
      
      do i=n,1,-1
        somme=somme+i
      enddo

Somme des nombres impairs inférieurs à n :

      ... ! affectation de n
      somme=0
      
      do i=1,n,2
        somme=somme+i
      enddo

Boucles do ... while

On effectue la boucle tant qu'une condition logique est vérifiée.

Syntaxe

do while (condition logique)
    ...
    ...
    ...
enddo

Fonctionnement

On rentre dans la boucle seulement si la condition logique vaut .true. et on exécute la boucle tant qu'elle reste à .true..

Dès qu'à la fin d'une boucle, la condition est .false., l'exécution reprend après enddo.

Remarque importante

Pour pouvoir sortir de la boucle, il faut que la condition logique puisse devenir .true. à l'intérieur. Si ce n'est pas le cas, le programme ne s'arrêtera jamais (Pensez-y !).

Exemples

Sommation de la série $\sum_{n \geq 1} 1/n^2$ jusqu'à ce que le terme général soit inférieur à $\epsilon$ fois la somme partielle courante :

      integer n
      double precision somme, epsilon
      ... ! affectation de epsilon
      n=1
      somme=0
      do while (1d0/n**2 .ge. epsilon*somme)
        somme=somme + 1d0/n**2
        n=n+1
      enddo

Plus élégant, en utilisant une variable logical :

      integer n
      double precision somme, epsilon
      logical fini
      
      ... ! affectation de epsilon
      n=1
      somme=0
      fini=.false
      do while (.not. fini)
        somme=somme + 1d0/n**2
        n=n+1
        fini=(1d0/n**2 .lt. epsilon*somme)
      enddo

Instructions goto et continue

Il s'agit d'un archaïsme. À proscrire absolument, sauf si on ne peut pas faire autrement. Tout abus sera puni !

Les instructions de branchement conduisent à des programmes illisibles et difficiles à corriger. Certaines instructions du FORTRAN (voir « fichiers » 11) utilisent des branchements de manière implicite pour gérer des erreurs. Dans ce cas, et seulement dans celui-ci, le branchement est obligatoire.

Syntaxe

goto No de label

En arrivant sur une telle ligne, le programme est branché directement sur la ligne comportant le label mentionné. En général, pour faire beau (il faut le dire vite...), cette ligne contient seulement l'instruction qui ne fait rien continue.

Exemple

Pour vous donner des mauvaises idées :

      character rep
      ...
 10   continue
      write(*,*) 'Repondez oui ou non'
      read(*,*) rep
      
      if (rep.ne.'o'.and.rep.ne.'n') then
        goto 10
      endif
      ...

next up previous
Next: Les tableaux Up: Initiation au Langage Fortran Previous: Entrées / Sorties
Copyright © EMAC - 1996-1999 - Paul GABORIT