Vous êtes sur la page 1sur 7

El éments de fortran 77

par V. Marry

1. Structure d’un programme

a Structure verticale.

On souhaite écrire un programme effectuant le produit de deux nombres de notre choix. Appelons ce programme produit. On appelle produit.f le fichier contenant les lignes de code du programme. Chaque ligne du fichier constitue une instruction du programme. La premi ère ligne sera program produit, la derni ère sera end. Entre les deux, diff érentes parties :

En début de programme: une partie obligatoire de dé claration des variables

utilis ées par la suite, avec leur type (entier, r éel, caractè re, …). Dans le programme

produit, on doit définir au moins les deux variables réelles x et y, dont on veut faire le produit.

Une partie lecture des donn ées (sur l’écran ou dans un fichier). Ici, on souhaite lire

les valeurs de x et y choisies par l’utilisateur.

Le corps du programme : calcul du produit x*y

Une partie impression des r ésultats (sur l’ écran ou dans un fichier) : le programme

transmet le r ésultat à l’utilisateur.

Remarque : l’une ou l’autre de ces parties peut faire appel à des sous­programmes (fonctions ou sous­routines) exté rieurs au programme principal.

a Structure horizontale.

Une ligne ne peut contenir qu’une seule instruction.

Une instruction commence à la colonne 7 et ne peut dé passer la colonne 72.

Pour des raisons de clart é ou si l’instruction est trop longue, on peut continuer

l’instruction en passant à la ligne et en ajoutant un caract è re (& par exemple) en colonne 6 de la nouvelle ligne.

Les lignes commenç ant par C ou * dans la colonne 1 ne sont pas ex écut ées: ce sont

des commentaires.

Les colonnes 1 à 5 contiennent éventuellement une étiquette (un entier) permettant

de numé roter la ligne pour y faire r éf érence ailleurs dans le programme.

Conseils : aé rer (sauter des lignes) et commenter le programme. Choisir des noms de variables parlants. Faire appara ître les diff érentes structures (boucles, conditions) en marquant des retraits en dé but de ligne.

2

D éclaration des variables : type et pré cision.

L’instruction implicit none en début de programme oblige le programmateur à déclarer

toutes les variables qu’il utilise par la suite : cela permet d’éviter certaines erreurs lors de la compilation. Dans le tableau suivant sont donnés les diff érents types de variables et la faç on de les déclarer dans le programme. La derni ère colonne du tableau comporte une s érie d'exemples de la mani ère dont on peut affecter ces variables dans le corps du programme (voir 4.a).

type

dé claration

Exemples d'affectation

entier

integer i

i=10

r éel de 4 octets

real x

x=1.5E­2 ou x=0.015

r éel de 8 octets

real*8 x ou double precision x

x=1.5D­2

chaî ne de 6 caract è res

character*6 mot

mot=’patate’

constante logique

logical a

a=.true. ou a=.false.

nombre complexe

complex b

b=(2.0,1.0)

Exemple :

program produit implicit none real x,y

end

Cas des tableaux ou variables indic ées:

il convient de définir les dimensions d’un tableau en m ême temps que son type. Si l’on veut déclarer un tableau b à une seule dimension compos é de 100 nombres r éels, on écrira :

real b(100) Le premier élé ment du tableau est b(1) et le dernier b(100). real b(10,20) correspond à une matrice (10x20).

3. Lecture et impression

Instruction de lecture: read(

,

)

dé signe l’endroit où on va lire : * si c’est à l’é cran, un numé ro si c’est un fichier. désigne la faç on de lire : * par défaut ou un format.

à l’ é cran, un num é ro si c’est un fichier. d é signe la

Lecture dans un fichier :

Il faut avoir ouvert le fichier au pré alable et lui avoir attribué un numéro pour que le compilateur sache où aller chercher l’information. Quand on n’a plus besoin du fichier, on le ferme. Si on veut lire dans le fichier nomm é liste, par exemple :

open(60,file=’liste’)

read(60,*) gamma

close(60)

Ces remarques sont aussi valables pour l’impression, mais l’instruction devient :

Exemple :

write(

,

)

program produit implicit none real x,y write(*,*) ‘combien valent x et y ?’

c l’ordinateur attend ici qu’on écrive les valeurs de x et y à l’ écran read(*,*) x,y

4. Ecriture du bloc central

a. R ègles d’affectations

Commentons la suite d’instructions suivante :

c

c

c

a=2.0

on stocke la constante 2.0 dans la variable appel ée a.

b=3.0

on stocke la constante 3.0 dans la variable appel ée b. a=b

on stocke la valeur de b dans la variable a. b valant 3.0, a vaut maintenant

c

3.0 aussi.

Autre exemple :

 

a=2.0

b=3.0

a=b+a

c

ne signifie pas que b=0 mais que a vaut maintenant la valeur de b + son ancienne

c

valeur 2.0, soit 5.0

a. Les fonctions intrins èques

L’ordinateur conna î t un certain nombre de fonctions telles que l’addition (+), la soustraction (­), la multiplication (*), la division (/) et la puissance (2**3=8 par exemple). Il en existe bien d’autres encore, ainsi que des fonctions de conversion pouvant changer un type de variable en un autre. Quelques unes de ces fonctions sont détaillé es dans le tableau ci­apr ès.

Exemple :

integer n real x

n=2

x=exp(float(n))

c

l'exponentielle « exp » est une fonction d'une variable r éelle. Il faut donc convertir

c

n entier en r éel (ici 2.0) avant d'appliquer la fonction exp

fonction

écriture fortran

type de la variable d'entr ée

type de la variable de sortie

sin

sin

R

R

(sinus)

dsin

DP

DP

cos

cos

R

R

(cosinus)

dcos

DP

DP

tan

tan

R

R

(tangente)

dtan

DP

DP

asin

asin

R

R

(arc sinus)

dasin

DP

DP

ln (logarithme népé rien)

alog

R

R

dlog

DP

DP

log

alog10

R

R

(logarithme décimal)

dlog10

DP

DP

exp

exp

R

R

(exponentielle)

dexp

DP

DP

racine carr ée

sqrt

R

R

dsqrt

DP

DP

valeur absolue

iabs

I

I

abs

R

R

dabs

DP

DP

conversion en entier

int

R

I

idint

DP

I

conversion en r éel

float

I

R

conversion en DB

dble

I ou R

DP

Tableau: Fonctions des bibliothèques (I: integer; R: ré el; DP: double pr écision)

a. Les instructions ité ratives (ou boucles)

Il arrive souvent d'avoir à faire des opérations r épétitives. On utilise alors l'instruction

do

enddo

contenant un indice de boucle.

Exemple 1: on veut calculer n!=1x2x3x

program factoriel implicit none integer i,n,fact

x(n­1)xn. On peut écrire :

write(*,*) 'n?' read(*,*) n

fact=1

do i=2,n fact=fact*i enddo write(*,*) 'n! =', fact end

Exemple 2: on veut lire les valeurs d'une matrice A (10x20) dans le fichier 60.

do i=1,10

boucle sur les lignes i read(60,*) (a(i,j), j=1,20)

c

boucle sur les colonnes j comprise dans une seule instruction enddo

c

a. Les instructions conditionnelles

Imaginons qu'on souhaite calculer (1/n 2 ) pour n=1,+. Il suffit d' écrire une boucle sur n qui, à chaque it ération, ajoutera à la variable S le terme 1/n 2 . Mais on ne peut évidemment pas demander à l'ordinateur d'ex écuter une somme infinie. En revanche, selon la précision avec laquelle on désire obtenir S, on peut décider d'arr êter la boucle à la condition que la diff érence entre deux valeurs cons écutives de S soit plus petite que , dont la valeur sera d'autant plus faible que la pr écision souhait ée est grande.

Instructions faisant intervenir une condition:

if (condition) then

instruction1

else

instruction2

endif

do while (condition) instruction enddo

Si l'instruction est simple, on peut parfois écrire seulement:

if(condition) instruction

Op érateurs logiques et de comparaison

syntaxe

.LT.

.GT.

.LE.

.GE.

.NE.

.EQ.

.AND.

.OR.

signification

<

>

 

π

=

« et » logique

« ou » logique

Exemples pour le calcul de S (le calcul théorique donne 2 /6):

S=1.0d0

S1=0.0d0

n=1

do while (abs(S­S1).gt.1.0d­8)

c

continue la boucle tant que |S­S1| est sup érieur à 10 ­8

S1=S

c

met l'ancienne valeur de S dans S1

n=n+1

S=S+1/dfloat(n)**2

c

calcule la nouvelle valeur de S enddo

Ou encore:

c

S=1.0d0

do n=2,100000

S1=S

S=S+1/dfloat(n)**2

if (abs(S­S1).lt.1.0d­8) goto 10

si |S­S1| est supérieur à 10 ­8 , sort de la boucle en allant à la ligne num éro 10 enddo continue

10

e. Les sous­programmes

Ils sont de deux types: des fonctions ou des sous­routines. Ils sont tr ès utiles quand on veut ex écuter plusieurs fois la même s é quence d'instructions. Par exemple, si on souhaite calculer la combinaison C n p =n!/(p!(n­p)!), on a besoin d'ex écuter trois fois le calcul d'un nombre factoriel. On peut envisager par exemple de transformer le programme factoriel ci­dessus en sous­programme, qu'on appellera plusieurs fois au sein du programme dit « principal ». On appellera arguments les variables transmises du programme appelant le sous­programme vers le sous­programme et réciproquement.

Les sous­programmes ont la m ême structure qu'un programme principal: ils comportent une partie d éclaration de variables et se terminent par end.

Les fonctions (ou function): elles transmettent au programme appelant un et un seul

r ésultat, stock é dans une variable portant le nom de la fonction.

Exemple:

program combinaison implicit none integer n,p,fact,factn,factp,factnp real comb write(*,*) 'n et p (p<n)?' read(*,*) n,p factn=fact(n)

factp=fact(p) factnp=fact(n­p) comb=float(factn)/(float(factp)*float(factnp)) write(*,*) 'combinaison=',comb end

function fact(m) implicit none integer fact,m,i

fact=1

do i=2,m

fact=fact*i

enddo

end

Les sous­routines (ou subroutine): elles peuvent transmettre plusieurs r ésultats, mais

aussi un seul ou m ême aucun (cas d'une sous­routine d'impression par exemple). On appelle une sous­routine à l'aide de l'instruction call subroutine.

Exemple:

program combinaison implicit none integer n,p,factn,factp,factnp real comb write(*,*) 'n et p (p<n)?' read(*,*) n,p call fact(n,factn) call fact(p,factp) call fact(n­p,factnp) comb=float(factn)/(float(factp)*float(factnp)) write(*,*) 'combinaison=',comb end

subroutine fact(m,f) implicit none integer f,m,i

f=1

do i=2,m

f=f*i

enddo

end