Structures de contrôle

Comme tout langage structuré, fortran propose différents types de structures de contrôle, qui sont toutes rédigées de la fa¸con suivante mot-cle instructions end mot-cle ou` mot-cle sera suivant les cas if, select, do. Pour plus de clart´e dans la programmation, il est possible de nommer les boucles de la fa¸con suivante :
nom-de-la-boucle : mot-cle instructions end mot-cle nom-de-la-boucle ceci est particulièrement intéressant en cas de boucles imbriquees.
Le bloc IF. if (expressionBooleenne1 ) then bloc1 elseif (expressionBooleenne2 ) then bloc2 … else dernierBloc end if Les blocs elseif et else sont optionnels; on peut mettre autant de blocs elseif que l’on veut. Chacun des blocs est une suite d’instruction fortran.
Le bloc SELECT CASE. select case (expression) case liste-de-valeurs-1 bloc1 case liste-de-valeurs-2 bloc2 … case liste-de-valeurs-n blocn end select ou` expression est une expression enti`ere ou logique, comme par exemple la sequence suivante, qui en fonction du num´ero du mois, indique le nombre de jours : select case (mois) case (4,6,9,11) nb_jours=30 case (1,3,5,7,8,10,12) nb_jours=31 case 2 nb_jours=28 endselect
Les boucle DO. Elles sont de la forme : do controle-de-boucle bloc end do ou` controle-de-boucle peut – ne pas exister : on a une boucle infinie; il faut donc qu’a` l’intérieur de la boucle, il y ait une instruction de sortie. – ˆetre de la forme : i=1,10 (parcourt les entiers de 1 a` 10), ou i=1,100,5 (parcourt les entiers de 1 `a 100, par pas de 5). Dans ces exemples i doit ˆetre une variable enti`ere, pr´ealablement declaree.
– ˆetre de la forme : while (condition-logique) : la boucle se poursuit tant que la condition est verifiee.
L’instruction WHERE. Cette instruction permet d’examiner un tableau coefficient par coefficient, et d’effectuer une op´eration sur les coefficients du tableau qui v´erifient une certaine condition. La syntaxe est : where condition bloc_d_operations elsewhere autre-condition autre_operation end where La clause elsewhere est facultative (comme pour elseif). Voici un exemple; ici a est un tableau de r´eels : where a /= 0. a=1./a elsewhere a=1. end where La commande where permet d’appliquer des op´erations compliqu´ees, soumises a` des conditions globalement `a un tableau, sans effectuer de boucle; elle est un substitut efficace a` l’utilisation combin´ee de do et if.
Pseudo-boucles. Il s’agit d’une construction jouant le mˆeme roˆle qu’une boucle do, qu’on peut utiliser dans un constructeur de tableau ou dans une instruction write. la syntaxe g´en´erale est (liste de termes, indice=min,max,pas) le pas est optionnel; s’il n’est pas indiqu´e, le pas est pris égal à 1. Exemples : – write (*,*) (i**2,i=0,100,3) imprime la liste des carr´es des multiples de 3 inférieurs a` 100. – a=reshape( (/ 1,((0,i=1,5),1,j=1,4) /),(/5,5/)) construit la matrice identit´e de taille 5×5 et l’affecte a` la variable a. 5.6. Sorties de boucle. La commande exit permet de sortir d’une boucle. Par exemple : i=1 do if (log(i)>5) then exit else i=i+1 end if end do Il peut ˆetre utile d’utiliser ici des boucles nommées. Ainsi, dans le programme boucle1: do … boucle2: do … if condition then exit boucle1 end if end do boucle2 end do boucle1 quand la condition du test est verifiee, on sort directement de la boucle principale boucle1, et non seulement de la boucle interne boucle2. La commande cycle1 permet a` l’inverse d’interrompre l’execution d’un bloc d’instruction dans une boucle, et de passer directement a l’iteration suivante. Ainsi, dans le programme do bloc-d-instructions1 if condition then cycle end if bloc-d-instructions2 end do lorsque la condition est verifiee, le programme saute l’ex´ecution du deuxieme bloc d’instructions, et passe directement a l’iteration suivante.

Structuration d’un programme en briques séparées

D`es qu’on ´ecrit des programmes de taille un peu importante, on a envie de d´ecouper les programmes en diff´erentes unit´es logiques. Ce choix rend les programmes plus lisibles et permet par ailleurs de r´epartir le d´eveloppement d’un projet entre plusieurs d´eveloppeurs, dont chacun est responsable du d´eveloppement d’une unit´e. Par aileurs, un morceau de programme pourra ˆetre utilis´e plusieurs fois `a l’int´erieur d’un programme donn´e, ou aussi ˆetre mutualis´e dans diff´erents programmes. Les sous-programmes seront de deux types : proc´edures (subroutine) ou fonctions (function). 6.1. La notion de sous-programme. On veut calculerZ x 0 e−x2/2 dx √2π par la m´ethode des rectangles; on va donc avoir `a utiliser un grand nombre de fois la fonction x 7→ e−x2/2. Les deux fichiers de programme suivants effectuent ce calcul, le premier en faisant appel a` une fonction, le second en utilisant une proc´edure. Regardez attentivement les programmes pour comprendre la diff´erence. 1- Programme utilisant une fonction : program int implicit none real :: s,x,f integer :: i write(*,*) ’rentrer un nombre positif’ read(*,*) x s=0 do i=0,1000 s=s+f(x*i/1000.) end do write(*,*) s*(x/1000.) end program int function f(x) implicit none real :: x,f,pi pi=4*atan(1.) f=exp(-x**2/2)/sqrt(2*pi) end function f On notera que f est une variable utilis´ee dans la fonction, et doit ˆetre d´efinie dans le corps de la fonction. 2- Programme utilisant une proc´edure : program int implicit none real :: s,x,f integer :: i write(*,*) ’rentrer un nombre positif’ read(*,*) x s=0 do i=0,1000 call mafonction(x*i/1000.,f) s=s+f enddo write(*,*) s*(x/1000.) end program int subroutine mafonction(x,f) implicit none real :: x,f,pi pi=4*atan(1.) f=exp(-x**2/2)/sqrt(2*pi) end subroutine mafonction.