Chapitre I.
Rappels sur le Langage Fortran
1. Déclarations des objets
La mémoire de l’ordinateur est partagée en un certain nombre de cellules. Une fois le
programme affecte un nom a une cellule, cette dernière se prête à recevoir une donné. La
déclaration d’une donnée consiste à lui réserver une place dans la mémoire par son nom, la
taille réservée dépend du type de la donnée (Entier, réel, caractère, ……..).
La syntaxe d’une déclaration en fortran est : TYPE < Liste des objets>
• Type entier :
Un entier est représenté base binaire sur 4 octets (31 bits pour la valeur plus un bit pour le
signe). Les valeurs représentées par le type entier sont situées sur l'intervalle [-231,231-1]. La
syntaxe de déclaration est :
INTEGER <liste des entières>
Remarque : L’utilisation d’une donnée entière hors de l’intervalle ci-dessus provoque une
erreur au cours de l’exécution du programme ‘over flow’
• Type réel:
un réel est représenté en base 2 en virgule flottante sur 4 octets. Les valeurs représentées par
le type réel simple précision sont situées dans l'intervalle [1.401x10-45 ,3.403x1038]. La
syntaxe de déclaration est :
REAL < liste des objets>
• Type double précision :
Le double précision est un réel plus précis, codé en virgule flottante sur 8. Les valeurs (en
valeur absolue) sont comprises entre [4.941x10-324 ,1.798x10308] avec 15 chiffres
significatifs. La syntaxe de déclaration est :
DOUBLE PRECISION < Liste des données double précision>
• Type complexe :
Une donnée de type complexe occupe deux octets ; un octet pour la partie réelle et un octet
pour la partie imaginaire. La syntaxe de déclaration est :
COMPLEX <liste des données complexes>
• Type caractère :
Le Fortran a été développé principalement pour manipuler des données de type numérique a
travers des formules mathématique (Formula Translator). Cependant Fortran peut manipuler
même des chaînes de caractères par des opérations appropriées (Voir : Manipulation de
textes). La syntaxe de déclaration d’une chaîne de caractère consiste à spécifier le nombre
maximal de caractères de la chaîne :
CHARACTER*n < Liste des données caractères>
n c’est la longueur maximale des données caractères.
• Type Logique :
Une donnée de type logique occupe 4 octets de mémoire, sa valeur est .True. ou .False.
La syntaxe de déclaration est :
LOGICAL <Liste des données logiques>
Exemple: Séquence de programme qui déclare des quantités physiques
Program Physique
C dans ce programme on déclare les quantités physiques suivantes :
C Patm : Pression atmosphérique , Avog : nombre d’avogadro
C n : nombre de proton dans le noyau d’hydrogène
C Planck : constante de Planck,
C Poid : Formule du poid d’un corps (type caractère)
C -------------------------- Déclaration ---------------------------------
Real Patm, Avog
Integer n
Double precision Planck
Character*4 Poid
Remarques:
• une variable qui commence par les six lettres i,j,k,l,m,n.n et qui n'est pas déclarer au début
du programme, est considérée par défaut comme entière.
Exemple: imax, jmax, kmax, longueur, masse.
• Pour imposer la déclaration de tous les objets employés dans le programme on utilise la
commande IMPLICIT NONE
Exemple: implicit none
integer orbite
real force, energie_elect
double precision alpha1, alpha2
complex z
2. Opérateurs arithmétiques
L’évaluation d’une expression mathématique qui contient plusieurs opérateurs arithmétiques,
exige un certain ordre de priorité de calcul. Le tableau suivant liste ces opérateurs par ordre
de priorité croissante :
Addition et Soustraction +, -
Multiplication et division *, /
Puissance **
Les sous expressions regroupées entre parenthèses sont évaluées en première priorité. Lorsque
deux opérateurs sont de même priorité, les calculs sont effectués de la droite vers la gauche.
Exemples : a = 2, b = 4
c=a+b/2 donne c = 4 ( la division est prioritaire sur l’addition)
c = (a + b )/2 donne c = 3 ( Les expressions entre parenthèses sont évaluées en premier)
Conversion de type :
Comme les opérateurs arithmétiques, les types d’objets suivent un ordre de priorité, ce qui
affecte profondément le résultat des calculs. Les différents types par ordre de priorité
croissante sont: Logical, integer, real, double precision, complex
Remarques :
• i, j deux entiers tel que i = 1, j = 2, le résultat de i / j sera du type entier donc 0
• a, b deux réels tel que a = 1, b = 2, le résultat de a / b sera du type réel donc 0.5
• On considère a et c de type Real et b de type Double precision, et on calcul:
delta = b ** 2 - 4 * a* c
b ** 2 sera du type Double precision
4 * a* c sera du type le plus fort de a et de c, donc Real.
Delta sera du type le plus fort, donc Double precision, mais le produit 4*a*c sera
effectué en simple précision, d'où une perte de précision possible.
• 1 / 2 donne un résultat entier qui est 0
1. / 2 , 1 / 2. ou 1. / 2. donne un résultat réel qui est 0.5
• k = 3.1415 , si k n’est pas déclarer comme réel, il sera considéré par défaut comme
entier, ce qui affectera seulement la valeur 3 à k
3. Fonctions mathématiques
Le FORTRAN contient des fonctions mathématiques pré-programmées dont l’utilisation ne
demande que de spécifier leurs arguments entre parenthèses. Les arguments doivent être de
même type que les fonctions. Le tableau suivant donne quelques fonctions de la bibliothèque
FORTRAN avec leurs types :
real double precision complex Fonction
SIN DSIN CSIN sin(x)
COS DCOS CCOS cos(x)
TAN DTAN tg(x)
ASIN DASIN arcsin(x)
ACOS DACOS arccos(x)
ATAN DATAN arctg(x)
SINH DSINH sh(x)
LOG10 DLOG10 log 10 (x)
LOG DLOG CLOG ln(x)
EXP DEXP CEXP exp(x)
SQRT DSQRT x
double
integer real complex Fonction
precision
MAX0 AMAX1 DMAX1 max(x,y)
MIN0 AMIN1 DMIN1 min(x,y)
IABS ABS DABS CABS |x| ou |z|
INT AINT DINT Partie entière
MOD AMOD DMOD Reste de la division entière
Fonctions de conversion:
Ces fonctions permettent de convertir explicitement des données d'un type en un autre type.
DBLE REAL IMAG
Double precision Real Complex
REAL CMPLX
INT
Integer Real
FLOAT
4. Entrées / Sorties
Dans la syntaxe de lecture READ(n,m) et d’écriture WRITE(n,m) :
• n pose la question ‘ou ?’, c’est à dire ou sont les données qui alimentent le programme, ou
bien, ou seront stockés les résultats du programme .si n est remplacé par le caractère ‘*’, le
programmeur doit introduire directement les données sur clavier et les résultats seront
affichés sur l'écran. Si n est spécifié, le programmeur doit introduire les données sur le fichier
dont le numéro est n, déjà ouvert par l’instruction OPEN: open(n, file='nom du fichier') .
Les résultats seront stockés sur le fichier de résultat
• m pose la question ‘comment ?’, c’est à dire spécifier le format des données à lire où à écrire.
Si m est remplacé par le caractère ‘*’, le format est libre. Si m est spécifié, les données seront
introduites avec le format de l'’étiquette m et les résultats seront affichés avec le format exigé.
Ecriture formatée :
Il existe deux méthodes pour spécifier le format des résultats à afficher :
1ère méthode : Format spécifier directement dans l’instruction Write:
Syntaxe : Write (n , ' format' ) liste à afficher
2ème méthode : Format spécifier à l’extérieur de Write.
Syntaxe : Write (n , m) r1, r2
………………………
………………………
m Format( ………...)
Dans la ligne d’étiquette m on spécifie les différents champs qui correspondent aux types des
résultats à afficher.
Code Format des différents champs:
Champ Définition Code format Paramètres
I Entier Iw W : largeur du champ
Réel sous forme W : largeur du champ
F Fw.d
décimale d : nombre de chiffres après le point décimal
Réel sous forme W : largeur du champ
E Ew.d
exponentielle d : nombre de chiffres après le point décimal
L Logique Lw W: largeur du champ
A Caractère Aw W: Largeur de la chaîne caractère
X Champ des blancs wX W : nombre de blancs
T Position donnée Tw W : Position à partir de laquelle la donnée est représentée
‘ /’ Saut de ligne / Le nombre de barres correspond au nombre de lignes
Exemple :
Program Physique
C déclaration des objets
Implicit none
Integer n
Real R, E
Double precision Pi
Character* 44 c1
Character*2 c2,c3,c4
Character* 12 unit1
Character* 1 unit2
C Affectation des constants numériques et caractères
n=1
R=0.082
pi = 3.141592653589793
e= -1.6E-19
c1=’electrons d’’hydrogene:n=‘
c2=’R= ’
c3=’e= ’
c4=’P=’
unit1=’[Link]/mole.k’
unit2=’C’
C Ecriture formatée
Write(*,100)c1,n,c2,R,unit1,c3,e,unit2,c4,pi
100 Format(1x,A24 , I1 , /, 1x,A2 , F5.3,A12,/,1x,A2,E8.2,A1,1x,A2,D15.10)
End
Le résultat d’exécution du programme est:
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
e l e c t r o n s d ' h y d r o g e n e : n = 1
R = . 0 8 2 l . a t m / m o l e . k
e = - . 1 6 E - 1 8 C P = . 3 1 4 1 5 9 2 7 4 1 D + 0 1
Remarques:
Si une chaîne caractère comporte un apostrophe, celui-ci doit être doublé pour que toutes les
parties de la chaîne soient encadrées par des apostrophes.
On peut insérer des chaînes caractères encadrées par des apostrophes à l’intérieur du format,
et on peut utiliser un facteur de répétition si les objets à afficher ont le même format :
I=1422, J=2002, Pi=3.14, e=2.71
Pour afficher ces constantes on peut utiliser le format suivant:
Write(*,100)i,j,pi,e
100 Format(‘---entiers---‘,/,2(3X,I4),//,’---reels---’,/,2(3X,F4.2))
5. Instructions conditionnelles
En Fortran, la condition est imposée par l’instruction IF :
L’expression Logique ou Booléenne :
Une expression logique relie des objets avec des opérateurs de comparaison et des opérateurs
logiques, sa valeur ne peut être que .TRUE. ou .FALSE.
Opérateurs de Comparaison :
Opérateur Définition
== =
~= ≠
< <
≤ ≤
> >
≥ ≥
Opérateurs de liaison :
Opérateur Définition
.NOT. Non
.AND. Et
.OR. Ou
.EQV. Equivalent
.NEQV. Ou exclusif
Exemple : A=3 , B=5
Expression Logique Valeur
L1 = [Link].B .TRUE.
L2 = [Link].B .FALSE.
L3 = [Link].L2 .FALSE.
L4 = [Link].B .TRUE.
L5 = [Link].L2 .FALSE.
Remarque: Dans un programme L1, L2, L3, L4 et L5 doivent être déclarer comme des constantes
de type LOGICAL.
Les différents types de la condition IF :
a. IF Logique :
Teste la valeur d’une expression logique, si elle est vraie l’instruction qui suit sera exécutée.
Syntaxe : IF (Expression logique) instruction
…………………………………….
Exemple : Calcul de la racine d’un nombre réel Q
Program Racine
read(*,*)Q
IF([Link].0)Q = - Q
Write(*,*) 'la racine de Q=', Sqrt(Q)
End
On peut aussi résoudre ce problème en utilisant l’instruction GOTO :
Program Racine
20 read(*,*)Q
IF([Link].0)Goto 20
Write(*,*)'la racine de Q=', Sqrt(Q)
End
Dans ce cas la racine n’est calculer que si Q est positif
La condition peut-être formulée sous forme de Bloc IF:
• Pour exécuter une série d'instructions uniquement si une condition logique est vraie :
2T IF (condition logique) THEN
1T2 0T1 0T1 1T2 2T
1T ........................... 1T
1T ........................... 1T
2T ENDIF 2T
• Pour spécifier une autre série d'instructions à exécuter si la condition logique est fausse :
2T IF (condition logique) THEN
1T2 0T1 0T1 1T2 2T
1T ………………………..... 1T
1T ……………….... 1T
2T ELSE 2T
1T ……………….... 1T
1T ……………….... 1T
2T ENDIF
• Pour enchaîner plusieurs conditions logiques :
2T IF (condition logique 1) THEN
1T2 0T1 0T1 1T2 2T
1T ……………………… 1T
2T ELSE IF (condition logique 2) THEN
1T2 0T1 0T1 1T2 2T
1T …………………….. 1T
2T ELSE IF (condition logique 3) THEN
1T2 0T1 0T1 1T2 2T
1T …………………………………... 1T
2T ELSE 2T
1T …………………………………… 1T
2T ENDIF 2T
Remarque: Si au lieu des ELSE IF on utilise ELSE suivit par le bloc IF, on sera obligé de
fermer chaque bloc par ENDIF
b. IF Arithmétique :
Teste le signe d’une expression arithmétique.
IF(Expression arithmétique) l , m , n
……………………………………………………..…
l ensemble d’instructions et calculs à exécuter lorsque
la valeur de l’expression arithmétique est négative
m ensemble d’instructions et calculs à exécuter lorsque
la valeur de l’expression arithmétique est nulle
n ensemble d’instructions et calculs à exécuter lorsque
la valeur de l’expression arithmétique est positive
……………………………………………………….
Exemple :
Résolution d’une équation 2ème degré : ax2 + bx + c = 0
Les constantes caractères :
C1 = ‘ Racines réelles‘, C2 = ‘ Racine double‘, C3 = ‘Racines complexes ‘
PROGRAM EQUATION2
! ---------- résolution d'une équation 2ème degré ---------------------
! ------------------- déclarations ------------------------------------------
IMPLICIT NONE
REAL a,b,c,delta,x1,x2,x
COMPLEX z1,z2
CHARACTER*17 c1,c2,c3
! ----------------lecture des données -------------------------------------
READ(*,*)a,b,c
READ(*,*)c1,c2,c3
! ---------------- calcul et écriture des racines --------------------------
IF([Link].0)THEN
delta=b**2 - 4*a*c
IF(delta)10,20,30
30 WRITE(2,100)c1
x1=- b - SQRT(delta)/2*a
x2=- b + SQRT(delta)/2*a
WRITE(2,150)x1,x2
GOTO 40
20 WRITE(2,100)c2
x=-b/2*a
WRITE(2,200)x
GOTO 40
10 WRITE(2,100)c3
z1=- b - CSQRT(CMPLX(delta))/2*a
z2= CONJG(z1)
WRITE(2,300)z1,z2
GOTO 40
ELSE
IF([Link].0)then
x=-c/b
WRITE(2,400)x
ELSE
WRITE(2,*)'pas de solution'
END IF
END IF
40 CONTINUE
! --------------- format d'écriture --------------------
100 FORMAT('******',a25,'*******')
150 FORMAT('x1=',1x,f7.3,/,'x2=',1x,f7.3)
200 FORMAT('x1=x2=',1x,f7.3)
300 FORMAT('z1=(',f7.3,'+',f7.3,'i)',/,'z2=(',f7.3,'+',f7.3,'i)')
400 FORMAT('solution equation 1er degrée ....x=',1x,f7.3)
! ---------------- fin du programme -----------------
END
6. Les Boucles
Lorsqu’un ensemble d’instructions et de calculs se répètent, on utilise la boucle DO.
syntaxe de la boucle :
DO e i = Vint , Vfin , ps
………………………
e CONTINUE
Les instructions et les calculs situés entre l’instruction DO et l’instruction CONTINUE
d’étiquette e, se répètent i fois (indice de la boucle) à partir de Vint (valeur initiale de i),
jusqu'à Vfin (valeur finale de i). Les calculs s’effectuent avec un Pas ‘Ps‘.
Exemple : Calcul du nombre π à partir de la série :
Sn
∞
=4 ∑
(−1)n
n =0 2n +1
L’ordinateur ne peut pas traiter des nombres infinis, donc on doit préciser la valeur maximale
de n. Le plus grand entier codé sur 4 octets qu’on peut choisir est n = 2147483647. Au delà
de cette valeur le compilateur nous signale une erreur d’exécution ‘Integer over flow’, c’est à
dire qu’on est hors de l’intervalle des entiers. Dans notre cas on choisit n = 100000
PROGRAM PI_calcul
IMPLICIT NONE
DOUBLE PRECISION Pi
INTEGER n
Pi=0
do 150 n=0,100000
Pi =Pi + 4 * ((-1)**n / DFLOAT(2*n + 1))
150 CONTINUE
WRITE(*,200)Pi
200 FORMAT(3x,’Pi = ‘,d22.16)
END
Remarques:
• Le pas de la boucle n’est pas indiqué, il sera considéré par défaut égale à 1
• L’initialisation est très importante dans la boucle DO. Ici la somme initiale Pi = 0
• Le résultat qui sera afficher est : Pi = .3141602653489720D+01
Pour afficher les résultats intermédiaires de Pi qui correspondent à chaque valeur de n,
il suffit d’écrire la ligne write (*,100) Pi à l’intérieur de la boucle.
• On a utilisé la fonction DFLOAT pour convertir (2n+1) du type INTEGER vers le
type DOUBLE PRECISION.
Transfert du contrôle vers une boucle et sortie anormale de la boucle :
On peut transférer le contrôle dans une boucle DO vers n’importe quel point de la même
boucle et on peut sortir librement d’une boucle à tout moment en imposant une condition de
sortie: IF ….GOTO. Cependant la seule façon de transférer le contrôle à l’intérieur d’une
boucle DO est de passer par l’instruction DO.
Exemple : Dans l’exemple précédent ou on a calculé le nombre π, on impose une condition de
convergence qui permet d’arrêter les calculs lorsque le critère suivant est vérifié :
Sn −Sn −1 ≤ ε avec ε = 5x10-5
• Pour imposer la condition de convergence on doit stocker la valeur de S à l’itération
(Etape) n-1, pour l’utiliser à l’itération n .
• Lorsque la condition de convergence est vérifiée, on sort de la boucle et on écrit la
valeur de π avant même que le nombre maximal d’itérations (n=10000) ne soit atteint.
• Le nombre d’itérations nécessaire pour calculer π avec la précision ε donnée peut être
afficher en demandant la valeur de n et π lors de la sortie anormale de la boucle.
PROGRAM PI_calcul
IMPLICIT NONE
DOUBLE PRECISION Pi,P,eps,erreur
INTEGER n
eps=5.d -5
Pi=0.d0
DO 100 n=0,100000
P=Pi
Pi =Pi+4*((-1.0)**n/DFLOAT(2*n+1))
erreur=DABS(Pi-P)
IF(erreur. LE. eps)GOTO 150
100 CONTINUE
150 WRITE(*,200)n,Pi
200 FORMAT(3x,'n=',i7,3x,'Pi=',d22.16)
END
Le résultat d’exécution du programme est : n= 40000 Pi= .3141617652964806D+01
Indice de contrôle et indice de calcul :
Lorsque l’indice de la boucle intervient dans les calculs il est appelé indice de calcul. Dans
l’exemple précédent le nombre π est fonction de l’indice de la boucle n, donc n est un indice de
calcul. Lorsque l’indice de la boucle contrôle uniquement le nombre d’étapes de calcul, il est
considéré comme indice de contrôle.
Exemple : Programme pour calculer cos (α) et sin (α) sur [0° , 90°] avec un pas de 15°
PROGRAM trigonometrie
IMPLICIT NONE
REAL alpha,beta,pi,x,y
CHARACTER*10 c1,c2,c3,c4
c1='alpha(deg)'
c2='alpha(rad)'
c3='cos(alpha)'
c4='sin(alpha)'
Pi=4*atan(1.0)
WRITE(*,100)c1,c2,c3,c4
DO 20 alpha=0,90,15
beta=alpha*Pi/180
x=cos(beta)
y=sin(beta)
WRITE(*,200)alpha,beta,x,y
20 CONTINUE
100 FORMAT(4(5x,a10),/)
200 FORMAT(4(5x,f10.4))
END
Le résultat d’exécution du programme est le suivant:
alpha(deg) alpha(rad) cos(alpha) sin(alpha)
.0000 .0000 1.0000 .0000
15.0000 .2618 .9659 .2588
30.0000 .5236 .8660 .5000
45.0000 .7854 .7071 .7071
60.0000 1.0472 .5000 .8660
75.0000 1.3090 .2588 .9659
90.0000 1.5708 .0000 1.0000
Les boucles DO imbriquées:
On peut avoir plusieurs boucles imbriquées les unes dans les autres a condition que les règles
suivantes soient vérifiées :
• l’indice de la boucle intérieure doit être différent de celui de la boucle extérieure.
• On ne peut avoir de chevauchement dans les boucles (la boucle intérieure totalement
comprise dans la boucle extérieure).
• Les boucles qui ont la même terminaison, peuvent avoir la même étiquette.
Exemple : Calcul du produit des sommes :
5
Pr od = ∏ ln
m =1
π ( )
10 sin m π
∑e n
m n =1
PROGRAM Boucles_Do_Imbriq
IMPLICIT NONE
INTEGER m,n
REAL pi,som,prod
pi=4*atan(1.)
prod=1
DO 60 m=1,5
som=0
DO 50 n=1,10
som=som+exp((sin(m*pi/n)))
50 CONTINUE
prod=prod*alog(pi/m)*som
60 CONTINUE
WRITE(*,100)prod
100 FORMAT(3x,'PROD=',f15.8)
STOP
END
Les étapes du déroulement de l’exécution du programme sont:
m n SOM PROD
1 1 1.056333
2 3.718282
3 6.095725
4 8.123839
5 9.923837
6 11.572560
7 13.115800
8 14.582010
9 15.989800
10 17.351890 19.863220
2 1 1.000000
2 2.000000
5 1 9.999996E-01
2 3.718282
3 4.138902
4 4.631970
5 5.631970
6 7.280692
7 9.466163
8 11.985210
9 14.662500
10 17.380780 5731.503000
7. les tableaux
Les tableaux (vecteurs et matrices) sont utilisés dans de nombreux problèmes de la physique.
Dans un circuit électrique par exemple, le vecteur des différences de potentiel U est relié au
vecteur des intensités de courant I par l’intermédiaire de la matrice des impédances Z :
Is
Ie
Ie Quadripôle
+ Is
Ue Us Ue Us
-
La relation entre les tensions et les intensités de courant d’entrée et sortie est la suivante :
U e Z11 Z12 Ie
=
Us Z21 Z22 Is
Syntaxe de déclaration d’un tableau :
Les tableaux regroupent des objets de type Integer, Real, Double Precision, Complex, Logical
et Character, dans la syntaxe de déclaration on doit spécifier le type, le nom et les dimensions
maximales du tableau :
TYPE TAB ( n, m, l, ………)
Exemple : REAL U(2), I(2), Z(2,2)
Accès aux éléments d’un tableau :
Lors de la lecture ou de l’écriture des éléments d’un tableau, les instructions READ et
WRITE se répètent jusqu’au balayage complet du tableau, la boucle DO donc peut être
adoptée pour effectuer ces opérations.
Exemple : Lecture des éléments de la matrice impédance [Z], calcul du double de cette
matrice et écriture des éléments de la matrice résultante :
REAL Z(2,2) , Y(2,2)
DO 50 i =1,2
DO 50 j=1,2
READ(*,*) Z(i,j)
Y(i,j) = 2 * Z(i,j)
WRITE(*,*)Z(I,j)
50 CONTINUE
END
Cependant cette méthode s’adapte bien pour les calculs, mais ne prend pas en compte la forme
de la matrice lors de la lecture et de l’écriture ; tous les éléments doivent être écrits sur une
seule colonne (chaque élément sur une ligne). Une autre forme dite condensée est plus
convenable pour la lecture et l’écriture des éléments du tableau :
REAL Z(2,2) , Y(2,2)
READ(*,*) ((Z(i,j),j=1,2),i=1,2)
DO 50 i =1,2
DO 50 j=1,2
Y(i,j) = 2 * Z(i,j)
50 CONTINUE
WRITE(*,100) ((Y(i,j),j=1,2),I=1,2)
100 FORMAT(2(2X,F7.2))
END
8. Les Sous Programmes
Dans le cas général un programme complet est composé d’un programme principal et de un ou
plusieurs sous programme :
Le Programme Principal : Commence par l’instruction facultative PROGRAM et termine par
l’instruction obligatoire END et il ne peut avoir q’un seul programme principal dans le
programme complet.
Le sous programme : Un sous programme (procédure) est un programme indépendant appelé
par un programme principal ou par d’autres sous programmes. Un sous programme utilise des
paramètres (arguments fictifs ou muets), ce qui le rend plus général. L’appelle d’un sous
programme par un programme appelant consiste à lui fournir des arguments réels(valeurs bien
déterminées). Une fois les paramètres sont remplacés par les arguments réels, le sous
programme devient actif et fournit des résultats au programme appelant.
On distingue deux types de sous programmes :
a. Subroutine: C’est un sous programme qui fournit un ou plusieurs résultats au programme
appelant. La structure d’une subroutine est donnée par la syntaxe suivante :
SUBROUTINE < nom de la subroutine> ( Liste des paramètres ou arguments fictifs)
……………..
……………..
RETURN
END
L’instruction RETURN permet au sous programme de renvoyer les résultats au programme
appelant. La syntaxe d’appel de la subroutine par le programme appelant est donnée par la
syntaxe suivante:
CALL < nom de la subroutine> ( Arguments réels ou bien déterminés)
Remarque importante :
Les paramètres de la subroutine peuvent ne pas avoir les mêmes noms que les arguments
correspondants du programme appelant, mais doivent avoir les mêmes types.
Exemple : Ecrire un programme CINEMATIQUE qui appel une subroutine TRANSFORM pour
transformer les coordonnées cartésiennes (x , y) de dix points donnés en coordonnées
polaires (r , alpha). Les données sont placées dans deux tableaux X, Y et les résultats doivent
être stocker dans trois tableaux R, ALPHARAD, ALPHADEG (ALPHARAD, c’est l’angle en
radians et ALPHADEG est l’angle en degrés)
PROGRAM Cinematique
C Transformation des coordonnées cartésiennes en coordonnées polaires
REAL x(10), y(10), r(10),alpharad(10),alphadeg(10)
OPEN(1,FILE='coord_don.dat')
OPEN(2,FILE='coord_res.dat')
READ(1,*)(x(i),i=1,10)
READ(1,*)(y(i),i=1,10)
CALL transform(x,y,10,r,alpharad,alphadeg)
WRITE(2,*)'coordonnées cartésiennes X , Y'
WRITE(2,100)(x(i),i=1,10)
WRITE(2,100)(y(i),I=1,10)
WRITE(2,*)'coordonnées polaires r , alpha(rad) , alpha(deg)'
WRITE(2,100)(r(i),I=1,10)
WRITE(2,100)(alpharad(i),i=1,10)
WRITE(2,100)(alphadeg(i),i=1,10)
100 FORMAT(10(2x,f8.3))
END
SUBROUTINE Transform(x, y,n, r,alpharad,alphadeg)
REAL x(n), y(n), r(n), alpharad(n),alphadeg(n)
REAL pi
pi=4*atan(1.0)
DO 5 i =1,n
r(i)=SQRT(x(i)**2+y(i)**2)
IF (x(i)) 10, 20, 30
10 alpharad(i)=- atan(y(i)/x(i))
alphadeg(i)=alpharad(i)*180/pi
GOTO 5
20 IF (y(i).GE.0) THEN
alpharad(i)=pi/2
alphadeg(i)=90
ELSE
alpharad(i)=-pi/2
alphadeg(i)=-90
ENDIF
GOTO 5
30 alpharad(i)= ATAN(y(i)/x(i))
alphadeg(i)=alpharad(i)*180/pi
5 CONTINUE
3 RETURN
END
b. Function :
Le sous programmes function (fonction) renvoie un seul résultat au programme appelant. Le
sous programme FUNCTION est appelé simplement par son nom:
<Type de la fonction> FUNCTION < nom de la fonction> (paramètres)
< nom de la fonction > = < Expression de la fonction>
RETURN
END
m
Exemple : Calcul de la combinaison P= Cn
n!(n − m )!
P=
m!
Le programme principal COMBIN appel le sous programme FUNCTION FACT qui fournit la
valeur de la factorielle.
PROGRAM combin
c calcul de la combinaison de n ojets en m
INTEGER p,n,m,fact
OPEN(1,FILE='combin_don.dat')
OPEN(2,FILE='combin_res.dat')
READ(1,*)n,m
p=fact(n)/(fact(m)*fact(n-m))
WRITE(2,200)n,m,p
200 FORMAT('la combinaison de',i3,' objets en',i3,' est:',/,10x,i5)
END
INTEGER FUNCTION fact(k)
FACT=1
IF([Link].0)return
DO 10 i=1,k
fact=fact*i
10 CONTINUE
RETURN
END
