[PDF] Débuter avec le langage Fortran 77 étape par étape | Cours informatique

REPUBLIQUE ALGERIEE DEMOCRATIQUE ET POPULAIRE

MINISRERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE

UNIVERSITE DE GUELMA

DEPARTEMENT DE GENIE CIVIL

ANNEE : 3

ANNEE LMD

SPECIALITE : GENIE CIVIL

ELABORE PAR: Mr LAFIFI BRAHIM

PROGRAMME

Chapitre I :

Introduction au langage FORTRAN

Chapitre II :

Les constantes et les variables

Chapitre III :

Les opérateurs et expressions

Chapitre IV :

Les instructions de branchement GO TO et IF

Chapitre V :

Les boucles de programme : l’instruction de contrôle DO

Chapitre VI :

Les instructions d’entrées sorties

Chapitre VII :

Chapitre I

Introduction au langage de Programmation FORTRAN

I.1. Historique

Le FORTRAN ou FORmula TRANslator est un langage de programmation particulièrement destiné au traitement des applications scientifiques telles que les statistiques, le calcul numérique, la simulation, etc….

En 1954, la Compagnie « International Business Machines » (IBM) publie la description préliminaire d’un système de FORmulation mathématique TRANsposée, c’est la première tentative pour définir un langage de programmation évolué. Ce FORTRAN est encore rudimentaire, ainsi par exemple, les noms de variables ont au plus 2 caractères. A cette époque, des travaux d’élaboration d’un compilateur (traducteur) pour IBM commencent, cependant que continue la réflexion autour de l’amélioration du langage lui même.

En 1956, parait le premier manuel de référence IBM qui définit la première version du langage : FORTAN I. Cette version reçoit à la version initiale :

- Noms de variables à 6 caractères ;

- Instructions : CONTINUE, GO TO, FORMAT ;

En 1957, parution de la deuxième version FORTRAN II. Ce FORTRAN reçoit les sous-programmes, les fonctions et les COMMON.

En 1958, mise au point de la troisième version FORTRAN III. En 1962, FORTRAN IV voit le jour avec en plus :

- Les déclarations explicites ; - L’instruction DATA ;

- L’instruction BLOCK DATA ;

En 1977, une version très développée de FORTRAN est parue sous le nom de FORTRAN 77 ou FORTRAN V. Ce dernier adopte un schéma d’alternative structuré (IF-THEN-ELSE-ENDIF) éliminant une bonne part des GO TO et il dispose des données de type CHARACTER.

I.2. Elaboration d'un programme

Un programme Fortran nécessite trois types de fichiers pour son élaboration : • Les fichiers source (extension .FOR, .F90 sous MS-D OS ou WINDOWS)

• Les fichiers objet (extension .OBJ sous MS-DOS)

• Le fichier exécutable (extension .EXE sous MS-DOS ou WINDOWS).

Le programmeur écrit le fichier source à l'aide d'un éditeur de texte de son choix. Il s'agit d'un texte clair, contenant toutes les instructions du programme. Le fichier source doit ensuite être

compilé, c'est à dire traduit en langage machine. C'est le rôle du compilateur. Chaque langage possède d'ailleurs un compilateur propre. Le fichier obtenu après compilation est un fichier objet, pas encore exécutable. L'éditeur de liens se chargeant de les lier et de les rendre exécutables. Toute modification, correction d'un programme passe tout d'abord par la modification du fichier source. Ce fichier doit être ensuite recompilé, ce qui permet d'obtenir un fichier objet mis à jour. Dans un cas simple, sur un compatible PC, on écrit le programme que nous appellerons par exemple PROG.FOR à l'aide d'un éditeur de texte au choix. On sauvegarde le fichier source sur le disque dur en lui donnant un nom respectant les conditions du système d'exploitation utilisé. L'extension utilisée est généralement .FOR sous MS-DOS. Le compilateur traduit les instructions qui ont été tapées par le programmeur et produit, si aucune erreur n'a été faite, en langage machine. La traduction est placée dans un fichier objet dont le nom est identique à celui du fichier source, mais dont l'extension est cette fois .OBJ sous DOS.

I.3. Structure d'un programme

Un programme comporte généralement plusieurs modules (sous-programmes). Ces modules peuvent figurer dans un même fichier ou dans des fichiers différents. Lorsque les modules figurent dans des fichiers individuels, il est possible, et c'est même fortement conseillé, de les réutiliser dans d'autres programmes. Un ensemble de modules doit, pour pouvoir être exécuté, comporter un programme principal. Le programme principal peut faire appel à des procédures et à des fonctions qui peuvent faire de même.

Un module comporte différentes parties :

• L'entête ou le nom du module. En FORTRAN on peut trouver:

• PROGRAM nom du programme pour le programme principal • SUBROUTINE (Liste de paramètres) pour un sous-programme • FUNCTION (Liste de paramètres) pour une fonction

• Les déclarations des paramètres, s'il y a lieu • Les déclarations des variables

• Les initialisations et déclarations particulières.

• Les instructions exécutables. C'est la traduction en langage (FORTRAN) de l'algorithme. • l'instruction FIN de module. En FORTRAN, il s'agit de END.

Attention, dans un fichier comportant plusieurs modules, il y aura autant d'instructions FIN que de modules.

I.4. Eléments de base du langage

Lorsque l'on écrit un programme, on utilise les lettres de l'alphabet, les chiffres et quelques signes. Les caractères reconnus par le compilateur sont :

• Les 36 caractères alphanumériques:

les 10 chiffres décimaux et les 26 lettres de l'alphabet • Les caractères spéciaux:

= signe égal , + plus , - moins , * étoile, / barre de fraction , ( parenthèses) , , virgule , . point , ' apostrophe, : double point

I.5. Les mots-clé du langage

Leur nombre est limité. Ils constituent le vocabulaire reconnu par le compilateur. Toute autre chaîne de caractères est considérée comme nom de procédure, de constante, de variable ou bien comme commentaire.

Exemple de mots-clé:

DATA, READ, WRITE, CONTINUE, GO TO, IF, THEN, COMMON.

I.6. Structure d'une ligne FORTRAN

Un texte FORTRAN s’écrit en revenant à la ligne après chaque instruction. Une ligne d’un programme FORTRAN est formée de 72 caractères (ou 72 colonnes).

- Les colonnes 1……5 sont réservées aux étiquettes ou à une ligne commentaire avec le caractère C à la première colonne.

- La colonne 6 est réservée seulement aux lignes de continuation. Dans ce cas, on met un caractère quelconque dans cette colonne et le compilateur comprendra que cette ligne est la suite de la ligne précédente, le nombre de lignes de continuation ne peut en aucun cas excéder 19.

- Les colonnes 7…….72 sont réservées aux instructions FORTRAN. - Les colonnes 73……… 80 sont ignorées par le compilateur.

Exemple :

Colonnes 1 6 7 72 73 C

10

&

LECTURE DES DONNEES WRITE(*,10)

FORMAT(1X, ‘ENTRER LA VALEUR DU NOMBRE DE POINTS :’,\) READ(*,*) M ……… ……… STOP END

I.7. Les Commentaires

Lorsque le caractère C ou * figure dans la première colonne, la ligne entière est supposée être un commentaire, et le compilateur l'ignore. Une ligne vide est également considérée comme commentaire par le compilateur. Il est conseillé de faire usage autant que possible des ommentaires, afin de rendre le programme plus lisible. La notice d'utilisation du module figurera sous forme de commentaire en en-tête, et de ce fait ne quittera pas le programme.

I.8. Les identificateurs

Un identificateur est un nom que le programmeur attribue à une variable, un sous-programme ou une fonction. En principe, il ne peut comporter plus de 6 caractères, mais certains compilateurs en admettent d'avantage. Si l'on utilise un identificateur faisant plus de 6 caractères, les derniers sont au pire ignorés par le compilateur, et il peut confondre deux variables distinctes. Il ne faut pas choisir pour nom de variable un mot réservé. Les mots réservés sont les instructions de structuration et des noms de fonctions standard. Les majuscules et minuscules sont confondus par le langage. On peut donc styliser les noms de variables par un usage combiné de majuscules et de minuscules.

Exemples :

TOTAL RACINE I1

Les noms suivants ne sont pas valables :

SOUSTOTAL (Admissible, mais comporte plus de 6 car.) 3I9 (Commence par un chiffre)

A.B (Comporte un point) PAUSE (Mot réservé du langage)

Chapitre II

Les constantes et les variables

II.1 Les Constantes

II.1.1 Définition

Une constante est une valeur qui ne peut être modifiée lors de l’exécution d’un programme. Cette valeur peut être numérique, chaîne de caractères ou logique.

II.1.2 Constantes entières

C'est une suite de chiffres précédée ou non d'un signe, ne pouvant comporter aucun autre caractère.

Exemples :

123 -18 +4

II.1.3 Constantes réelles

On peut les trouver sous la forme simple précision ou double précision. On peut les présenter de deux manières :

• Constante réelle à virgule fixe : C’est une chaîne de chiffres comportant obligatoirement un seul point décimal, pouvant être précédée d'un signe.

Exemples :

3.14 -6.28 .7 0.

• Constante réelle à virgule flottante.

La présentation reste identique à la précédente, mais on rajoute en fin de chaîne un exposant comportant pour la simple précision la lettre E suivie d'une constante entière signée de deux chiffres. En ce qui concerne la double précision, l'exposant commencera par la lettre D et pourra comporter 3 chiffres.

Exemples :

128.34E+02 -.432E-06

II.1.4 Constantes complexes

Une constante complexe se présente sous la forme d'un doublet de deux réels placés entre parenthèses. Les deux réels sont séparés par une virgule, le premier représentant la partie réelle, le second la partie imaginaire.

Exemples :

(20.0, -3.14) (0.,0.)

(1.E01,1.23E-02)

Les réels formant le complexe doivent être de même nature, soit en simple ou en double précision.

II.1.5 Constantes logiques

Une constante logique n'a que deux valeurs possibles : .TRUE.

.FALSE.

II.1.6 Constantes chaînes de caractères

C'est une suite de caractères quelconques encadrée par l'apostrophe '. On utilise ces constantes pour composer des messages ou initialiser des chaînes.

Attention : Le français fait un usage courant de l'apostrophe, ceci peut poser un problème lors

de l'affichage de certains messages.

Exemples :

WRITE(*,*)'LUNDI 1 JANVIER 1990'

Contre-exemple :

WRITE(*,*)'L'affichage d'apostrophes va poser des problèmes!' Ce problème peut être réglé par le double apostrophe : WRITE(*,*)'L''affichage d''apostrophes ne pose plus de problème!' II.1.7 Déclaration des constantes

En FORTRAN, les constantes n'ont pas de nom. Les déclarations de constantes n'existent donc pas. Cependant, il peut-être utile de nommer des constantes, ce qui permet de les décrire en début de programme, et de les localiser tout de suite pour une modification. On utilise pour celà la déclaration PARAMETER.

Exemple :

II.2 Les variables

II.2.1 Variables simples

Une variable est une quantité susceptible de prendre diverses valeurs au cours d’un programme de calcul. Il est nécessaire de la représenter par un nom symbolique qui est son identificateur. Les identificateurs ou noms de variables sont constitués par une suite de 1 à 6 ou 1 à 8 caractères alphanumériques, le premier caractère gauche est toujours une lettre. Cependant, tout nom formé suivant cette règle n’est pas acceptable par le compilateur comme nom de variable, si c’est un mot réservé du FORTRAN, par exemple : COS est l’identificateur de la fonction cosinus et ne peut donc être pris comme nom de variable.

Une variable peut être de type entier, réel, double précision, complexe, logique ou chaîne de caractères.

a. Les variables entières :

Leur nom commence par l’une des lettres I, J, K, L, M, N ou sont déclarées dans une instruction de type INTEGER qui doit figurer au début du programme.

Exemple :

INTEGER X1, X2, Y, Z X1, X2, Y, Z sont des variables de type entier. INTEGER*4 X X est une variable entière stockée sur 4 octets.

b. Les variables réelles :

Leur nom commence par une lettre autre que I, J, K, L, M, N, ou sont déclarées dans une instruction de type REAL qui doit figurer au début du programme.

Exemple :

REAL IJ IJ est une variable de type réel. REAL SIGMAXX, SIGMAYY, SIGMAZZ

c. Les variables double précision :

Elles doivent obligatoirement figurer dans une déclaration de type DOUBLE PRECISION en tête du programme.

Exemple :

DOUBLE PRECISION V1, V2, V3 V1, V2, V3 : sont des variables de type double précision

d. Les variables complexes :

Elles doivent obligatoirement figurer dans une déclaration de type COMPLEX en tête du programme.

Exemple :

COMPLEX Z1, Z2, Z3 Z1, Z2, Z3 : sont des variables de type complexe. COMPLEX CX

CX = (5.0,1.0)

e. Les variables chaîne de caractères :

Elles sont constituées de chiffres, lettres, caractères spéciaux pris dans l’ensemble des caractères imprimables du code ASCII. Elles sont déclarées par l’instruction CHARACTER en spécifiant leur longueur.

Exemple :

CHARACTER*20 NOM, PRENOM

NOM et PRENOM sont des variables chaînes de 20 caractères de longueur chacune. CHARACTER CH*3, D1*4, ST*15

La variable CH contient 3 caractères, D1 en contient 4, ST a pour longueur 15 caractères. La déclaration implicite :

Lorsque l’on a une longue liste de variables d’un type donné à déclarer, il est commode d’utiliser la déclaration IMPLICIT.

Exemple :

IMPLICIT COMPLEX C

Toutes les variables dont le nom commence par la lettre C ou c sont de type complexe. IMPLICIT DOUBLE PRECISION (A-C,H , K,O-Z)

Toutes les variables dont le nom commence par H,K ou toutes les lettres comprises entre A et C et entre O et Z sont de type double précision.

II.2.2 Les tableaux (Variables indicées)

Un tableau FORTRAN est un ensemble de variables indicées, identifié par un seul nom de variable. Les noms de tableau obéissent aux mêmes lois de construction et de type que les noms de variables simples.

Un élément du tableau est représenté par le nom du tableau suivi de 1 à 7 indices placés entre parenthèses et séparés par des virgules.

Exemple :

Un indice peut être une constante, une variable ou une expression arithmétique entière, pouvant éventuellement contenir des variables indicées.

Toutes les variables d’un même tableau sont du même type ; celui du nom du tableau.

Il est nécessaire d’indiquer en début du programme la taille maximale du tableau, ce qui se fait par l’instruction DIMENSION.

Exemple :

DIMENSION A(10), I(5,7), B(-5 :20), K(2,3,0 :10) Le tableau A est un vecteur réel: l’indice varie de 1 à 10.

Le tableau I est une matrice de variables entières, le premier indice varie de 1 à 5, le deuxième varie de 1 à 7.

Le tableau B est un vecteur réel dont l’indice varie de -5 à 20.

Le tableau K est un tableau entier à 3 dimensions, les 2 premiers indices varient respectivement de 1 à 2 et de 1 à 3, le troisième varie de 0 à 10.

La valeur minimale de chaque indice n’est à préciser que lorsqu’elle diffère de 1, elle est alors séparée de la valeur maximale par le ( :), sinon elle est facultative.

Remarque :

Les deux déclarations : REAL I

DIMENSION I(10) peuvent se regrouper en : REAL I(10).

L’instruction DIMENSION a deux effets :

- elle réserve en mémoire le nombre de places indiquées pour les variables indicées correspondantes, selon leur type.

- Elle permet de retrouver l’adresse en mémoire de tout élément du tableau. Exemple :

DIMENSION A(2,5)

Elle réserve 2*5 = 10 places de réels en mémoire et indique que A est un tableau rectangulaire réel de 2 lignes et 5 colonnes.

En mémoire, le tableau est rangé en ligne de la façon suivante :

A(1,1)/ A(2,1)/ A(1,2)/ A(2,2)/ A(1,3)/ A(2,3)/ A(1,4)/ A(2,4)/ A(1,5)/ A(2,5)

C’est le premier indice qui varie le premier. L’élément A(I,J) sera donc placé dans le tableau à la 2*(J-1)+I ème place.

II.2.3 L’instruction DATA

Elle permet d’initialiser des variables indicées ou non. Sa forme générale est : DATA V1, V2, ….., Vn/ C1, C2, …..Cn ou DATA V1/C1/, V2/C2/, …., Vn/Cn/. Les Vi sont les variables à initialiser et les Ci leurs valeurs.

Si plusieurs variables successives ont des valeurs identiques C, on peut utiliser un facteur de répétition : k*C.

Exemple :

DIMENSION A(2,3) DATA A/1.,2*1.5,3*0./

Ce qui correspond à la matrice

          = . 0 5 . 1 . 0 5 . 1 . 0 . 1 A

Chapitre III

Les opérateurs et expressions

III.1. Opérateurs arithmétiques

Ils permettent l’exécution des opérations usuelles :

Opérateur Opération + addition - soustraction * multiplication / division ** puissance Exemple : 2. + 3. donne 5. 2. – 3. donne -1. 2. * 3. donne 6. 2. / 3. donne 0.666667 2. ** 3. donne 8.

III.1.1. Hiérarchie et formules

Pour pouvoir ordonner une suite d’opérations, il faut savoir dans quel ordre elles vont être effectuées : par exemple le résultat de :

3. + 2.* 5. sera – t –il 25. (3. + 2. = 5. ; 5. * 5. = 25. ) ou 13. ( 2.* 5. = 10. ; 10. + 3. = 13.)

La hiérarchie est la suivante : les calculs effectués en premier sont ceux placés entre parenthèses, en commençant par les parenthèses les plus internes. Viennent ensuite les élévations à une puissance, puis les divisions et multiplications, enfin additions et soustractions. Le résultat de la suite d’opérations ci-dessus sera donc 13.

A hiérarchie égale, les opérations sont effectuées de gauche à droite, en cas de doute mieux vaut introduire de parenthèses ou couper la formule en morceaux en utilisant quelques variables supplémentaires.

III.2. Opérateurs de relation

III.3. Opérateurs logiques

Opérateur Opération

.NOT. Négation logique .AND. Et logique

.OR. Ou logique

.EQV. Equivalence logique .NEQV. Non équivalence logique

Les opérandes doivent être des expressions de type LOGICAL III.3.1. Les tables de vérité

Autres opérateurs

III.4. Opérateur d’affectation

Syntaxe générale : Variable = expression

Exemple :

Y = A*X + B

Règles :

1- Une valeur de type CHARACTER ne peut pas être affectée à une variable numérique et vice-versa.

2- Une valeur de type INTEGER peut être affectée à une variable de type REAL.

3- Une valeur de type REAL peut également être affectée à une variable de type INTEGER, mais dans ce cas la valeur est alors tronquée en supprimant la partie fractionnaire.

Exemple :

III.5. Expressions arithmétiques

Une expression arithmétique est construite à partir d’opérateurs arithmétiques et d’opérandes qui peuvent être des constantes, des variables et de fonctions. Les éléments intervenant dans l’expression doivent être séparés par un opérateur arithmétique. Tous les calculs à effectuer doivent être représentés par un opérateur. Deux opérateurs ne peuvent apparaître consécutivement (A * - B) est incorrect, il faut écrire : A * (-B), des parenthèses doivent être utilisées.

Exemple :

B2 – 4.A.C s’écrit B**2 – 4*A*C

2

1 n

n U

U ₋ − s’écrit U(N – 1) – U(N) * U(N) ou U(N – 1) – U(N)**2

d x c b x a + + . . s’écrit (A*X + B)/(C*X + D)

Dans une suite d’opérations de même niveau, les calculs sont effectués de gauche à droite sauf dans les cas d’élévations successives à une puissance où les opérations sont effectuées de droite à gauche.

Exemple :

A**B**C calcul de a = B**C, puis de A**a.

A + B/C**D/E*F calcul de a = C**D, puis b = B/a, puis c = b/E, puis d = c*F et enfin e=A + d

III.5.1. Hiérarchie des types numériques

Un opérande de type complexe sera considéré comme plus élevé dans la hiérarchie qu’un opérande double précision, lui-même plus élevé qu’un opérande de type réel, le type le plus bas dans la hiérarchie étant le type entier.

L’opérande de type le plus bas dans la hiérarchie sera dans un premier temps converti au type de l’autre opérande : le résultat sera donc du type de l’opérande de valeur hiérarchique la plus élevée.

Exemple :

- Pour calculer 3*X

- 3 est d’abord converti en réel, - puis le produit est effectué, - le résultat obtenu est un réel. - Pour calculer 3.E-5 - 2.D-6

- La première constante est transformée en double précision et le résultat de la soustraction est obtenu en double précision.

- Le calcul de 2/3 se fait directement puisque les deux opérandes sont de même type, on obtient 0. - De même le calcul de (2/3)*6 donne 0, alors que le résultat de 2*6/3 vaut 4.

III.6. Fonctions usuelles de la bibliothèque FORTRAN

Le FORTRAN met à la disposition des utilisateurs une bibliothèque de fonctions d’usage courant telles que COSINUS, SINUS, racine carrée …..

Le ou les arguments de la fonction peuvent être n’importe quelle expression arithmétique. Une fonction est appelée simplement par son nom suivi de ses arguments entre parenthèses.

Exemple :

DELTA = SQRT (B**2 – 4.*A*C) pour ∆=b2−4.a.c

V = R*I*SIN (OMEGA*T + PHI) pour v= R.i.Sin(w.t+φ)

Les noms des fonctions de la bibliothèque sont des noms réservés et ne peuvent être utilisés comme nom de variables.

Remarque :

On doit respecter le type des arguments, par exemple pour calculer la racine carrée d’un entier, il faut écrire SQRT (4.) ou SQRT (FLOAT (I)) et non pas SQRT (4) ou SQRT (I).

Chapitre IV :

Les instructions de branchement GO TO et IF

IV.1. Généralités :

Le FORTRAN comporte une catégorie d’instructions appelées « instructions de contrôle », cette catégorie qui englobe les instructions de branchement, contient 8 types d’instructions :

- Instruction GO TO inconditionnel,

- Instruction GO TO conditionnel (calculé), - IF arithmétique,

- IF logique, - DO, - Continue,

- Instruction de contrôle de programme STOP et PAUSE, - Instruction d’appel de sous programme CALL,

- Instruction de retour de sous-programme RETURN, IV.2. L’instruction GO TO :

Cette instruction de branchement se présente sous deux formes : - GO TO inconditionnel,

- GO TO calculé (conditionnel), IV.2.1. GO TO inconditionnel :

C’est l’instruction de branchement à une étiquette E. Sa forme générale est : GO TO E

Où E est le numéro d’une instruction figurant dans le programme, l’instruction exécutée après le GO TO sera l’instruction d’étiquette E.

Exemple :

I = 0 10 I = i + 1

WRITE (*,*) I GOTO 10 IV.2.1. GOTO calculé :

C’est une instruction de branchement conditionnel. Sa forme générale est : GO TO (k1, k2,…..,kn), I

Avec :

I: variable entière positive K1, k2,...,kn : sont des étiquettes.

A l’étiquette k1 si I = 1 A l’étiquette k2 si I = 2 A l’étiquette kn si I = n

Cette instruction entraîne une erreur à l’exécution si I peut être n’est pas satisfaite : 1≤ I ≤ N

Il est déconseillé d’utiliser cette instruction si I peut être en dehors de l’intervalle

[

]

Exemple :

Soit à calculer Z, défini par : Z = R2 si L = 1 ou 3. Z = R + D si L = 2. Z = R2 + D + 5 si L = 4.

Le programme FORTRAN correspondant est : GO TO (10, 20, 10, 30), L 10 Z = R**2 GO TO 100 20 Z = R + D GO TO 100 30 Z = R*R + D + 5. 100 …….

IV.3. Les instructions de test IF :

L’instruction de test IF peut prendre deux formes : - Le IF arithmétique ;

- Le IF logique ;

IV.3.1. L’instruction IF arithmétique :

Cette instruction est destinée à tester le signe d’une expression arithmétique et à effectuer un branchement selon que cette expression est :

- négative, - nulle, - positive,

La forme générale de cette instruction est : IF (expression arithmétique) E1, E2, E3

E1, E2, E3 étant des entiers sans signe qui représentent des numéros d’étiquettes. L’exécution de cette instruction provoque :

- Le calcul de l’expression arithmétique ; - Le branchement

En E1 si l’expression est < 0, En E2 si l’expression est = 0, En E3 si l’expression est > 0,

On peut avoir l’une des égalités suivantes : E1 = E2

E2 = E3 E3 = E1.

Exemple :

Dans la résolution de l’équation a.x2 + b.x + c = 0, on désir dissocier les trois cas correspondant au signe du déterminant : < 0 > 0 Aller en 10 Aller en 20 = 0 Aller en 30 On écrira : IF (B*B – 4.*A*C) 10,30,20 Remarque :

Après avoir déterminé le signe de l’expression arithmétique le “IF” effectue le branchement et la valeur numérique de l’expression n’est pas mémorisée. Si on doit utiliser cette expression par la suite, il peut être préférable de la calculer avant le test.

Reprenons l’exemple précédent, nous pouvons écrire l’organigramme suivant :

< 0 delta > 0 Aller en 10 Aller en 20 = 0 Aller en 30 On écrira alors : Delta = B*B – 4.*A*C IF (Delta) 10, 30, 20

Ainsi pour le calcul des racines réelles et imaginaires, la valeur de delta est déjà connue et il est inutile de refaire le calcul.

Exercice :

Ecrire deux programmes permettant de calculer la racine carrée d’un nombre A en utilisant la b2 -4.a.c

Delta = b2 – 4.a.c

( ) 2 1 1 i i i x A x x₊ = +

La valeur de x0 est supposée donnée.

Premier cas : on arrête les itérations lorsque xi₊1−xi ≤ε

Deuxième cas : on arrête les itérations lorsque xi+1 = xi

IV.3.2. L’instruction IF logique :

Comme son nom l’indique, cette instruction porte sur une expression logique dont la forme générale est :

IF (expression logique) Instruction exécutable I1 L’exécution du IF logique provoque :

- L’évaluation de l’expression logique ;

- L’exécution de l’instruction exécutable I1, si l’expression est VRAIE ; - Le branchement à la ligne suivant si elle est FAUSSE.

Ceci peut se schématiser dans l’organigramme suivant :

oui non

IV.3.3. Utilisation du IF logique et du IF arithmétique : On peut écrire :

IF (expression logique) IF (expression arithmétique) E1, E2, E3. On obtient ainsi un test permettant de se brancher vers 4 directions différentes :

- Expression logique fausse, on continue en séquence.

- Expression logique vraie, branchement en E1, E2, E3 selon le signe de l’expression arithmétique.

IV.3.4. La forme IF THEN ELSE :

Cette forme permet de mieux structurer les programmes, elle permet une réduction du nombre d’étiquettes et des instructions de branchement.

Calcul de l’expression logique VRAIE Exécuter l’instruction I1 Passage à l’instruction suivante

Sa forme générale est :

- IF (expression logique 1) THEN Séquence 1

- ELSE IF (expression logique 2) THEN Séquence 2 ………….. - ELSE Séquence n - ENDIF

IV.4. Les instructions de contrôle STOP, PAUSE et END IV.4.1. L’instruction STOP

Considérons l’organigramme suivant :

oui non

FIN

oui non

FIN FIN

L’exécution de ce programme peut se terminer ici de trois façons différentes selon le résultat des tests.

Pour arrêter l’exécution du programme, on utilise l’instruction STOP. Le programme correspondant à l’organigramme ci-dessus contiendra donc trois instructions STOP.

B A f

Y X p

Programme : IF (A.GT.B) GO TO 20 ……… . ……… . ……… IF (X.LT.Y) GO TO 10 ……… ……… ……… STOP 20 ……… ……… ……… STOP 10 ……… ……… ……… STOP END

Cette instruction exécutable provoque l’arrêt du déroulement du programme à titre définitif. IV.4.2. L’instruction Pause

Pause permet d’arrêter momentanément l’exécution du programme afin de permettre une intervention manuelle de l’opérateur. A la fin de cette intervention l’exécution du programme est reprise à l’endroit où elle avait été suspendue.

IV.4.3. L’instruction END

Un programme comporte de nombreuses instructions et il faut indiquer au compilateur quand cette séquence se termine. Pour cela on utilise l’instruction END.

Applications :

- Soit un tableau réel A(100).

1- Ecrire un programme permettant de déterminer l’élément maximum et l’élément minimum. Les valeurs numériques correspondantes seront rangées en XMAX et XMIN.

2- Refaire le même programme en déterminant en outre les valeurs des indices correspondant aux extrêmes. Ces valeurs seront rangées dans KMAX et KMIN. (Les nombres sont supposés tous distincts).

3- Soit un tableau A de 100 nombres rangés dans un ordre quelconque en mémoire.

- faire l’organigramme destiné à trier ces nombres et à les ranger par ordre croissant. Ecrire ensuite le programme correspondant.

Chapitre V :

Les boucles de programme, l’instruction de contrôle DO

V.1. Introduction

Une boucle de calcul est l’exécution d’une séquence d’instructions qui doit être répétée plusieurs fois en faisant progresser un indice ou une variable entière de façon régulière.

Exemple :

Soit un tableau A (100). Calculer la valeur numérique des variables S et S2 définies par :

∑

∑

Avec l’utilisation de l’instruction IF, on aura le programme suivant : REAL A(100) ……. S = 0. S2 = 0. I = 1 10 S = S + A(I) S2 = S2 + A(I)**2 I = I + 1 IF (I.LT.100) GO TO 10

V.2. L’instruction DO : forme générale

En utilisant l’instruction DO, le calcul de S et de S2 Pourra être réalisé par la séquence suivante : REAL A(100) ……. S = 0. S2 = 0. DO 10 I = 1, 100, 1 S = S + A(I) 10 S2 = S2 + A(I)**2 …………

L’instruction DO indique ici l’étiquette de la dernière instruction de la boucle, les valeurs extrêmes de l’indice et le pas d’incrémentation. Nous constatons q’une boucle de calcul est caractérisée par les paramètres suivants :

- Première instruction de la boucle (celle qui suit directement le DO) ; - Dernière instruction de la boucle (celle qui porte un numéro d’étiquette) ; -

- Valeur maximale de cette variable ; - Pas d’incrémentation.

Forme générale : DO N I = M1, M2, M3

Lorsque l’incrément M3 a la valeur 1, il peut être omis dans l’instruction DO. La forme simplifiée de DO est donc :

DO N I = M1, M2 V.3. Les boucles emboîtées

Il est possible d’utiliser à l’intérieur de la portée d’une boucle DO une autre boucle DO à condition que les boucles soient « emboîtées » et qu’elles soient contrôlées par des variables distinctes. Exemple : INTEGER A, B, C, P, Q, R ……… DO 100 I = A, B, C ……… DO 50 J = P, Q, R ……… 50 ……… ……… 100 ………

V.4. Règles relatives à l’instruction DO

La forme de l’instruction DO impose les règles suivantes : Règle1 :

Il est interdit de se brancher directement à l’intérieur de la portée d’une boucle DO, en sautant l’instruction DO. Exemple : GO TO 50 ……….. DO 100 I = k, 100, 2 ……….. 50 X = … 100 ………. Règle 2:

L’instruction terminale d’une boucle DO doit satisfaire aux conditions suivantes : * Etre une instruction exécutable à l’exclusion

- Des instructions de contrôle PAUSE, STOP, RETURN ; - De l’instruction END.

* Elle doit figurer dans la même unité de programme que l’instruction DO. Règle 3 :

A l’intérieur de la portée d’une boucle DO, il est interdit de modifier la valeur de la variable de contrôle et celle des paramètres lorsque ceux-ci sont des variables.

Exemple :

DO 10 I = 1, J, 2

K = K + 1 (autorisé) …………

I = I + 1 (incrémentation interdite à l’intérieur de la portée) …………

J = 3 (incrémentation interdite à l’intérieur de la portée) 10 S = S + A(I)

Règle 4 :

Lorsque deux boucles sont emboîtées, on peut sauter de la boucle intérieure vers la boucle extérieure, mais le contraire est interdit (sinon la règle 1 ne serait pas respectée pour la boucle intérieure).

Règle 5 :

Si deux boucles emboîtées ont la même instruction terminale, de la boucle intérieure, on peut se brancher vers l’instruction terminale par contre ceci est interdit à partir de la boucle extérieure.

Exemple : DO 105 I = 1, N ……. GO TO 105 (interdit) ……. DO 105 J = 2, K ……. GO TO 105 (autorisé) ……. 105 ……. Règle 6 :

Le mécanisme de la boucle DO interdit que les boucles DO puissent se « chevaucher ». Ces principales règles peuvent se récapituler dans le schéma suivant :

DO 20 …. DO 10 ….. DO 10 …. DO 10 …. 10 20 AUTORISE 10

- Ecrire un programme permettant de calculer la somme de tous les éléments d’un tableau réel A (10,20).

Chapitre VI

Les instructions d’entrée / sortie

VI.1. Introduction

Le besoin de pouvoir échanger des informations entre mémoire centrale et mémoire auxiliaire et plus particulièrement entre l’ordinateur et l’utilisateur, nécessite l’utilisation d’instructions particulières appelées instructions d’entrées/sorties.

Une opération d’entrée/sortie est caractérisée par : - Le type de l’opération : séquentielle ou directe ; - Le sens de l’opération : entrée ou sortie ;

- L’identification du périphérique (on dit aussi unité) ; - Le nom des variables à imprimer ;

- Le « FORMAT » sous lequel ces variables doivent être transmises (nombre de caractères après le point décimal – espacement des variables – texte facultatif – saut de ligne, etc…). On peut avoir des opérateurs d’entrée/sortie :

- Avec format ; - Avec format libre. Nous utilisons trois instructions :

READ : entrée à partir de périphérique vers la mémoire centrale. WRITE : sortie de mémoire centrale vers un périphérique. FORMAT : indique le format des variables.

VI.2. Les instructions d’entrée/sortie READ et WRITE Ces instructions peuvent prendre les formes générales suivantes :

Avec format :

READ (u, f) k WRITE (u, f) k

Avec format libre:

READ (u, *) k WRITE (u, *) k

u : est une constante ou variable entière positive représentant un numéro d’unité logique ;

f : est une constante entière positive représentant une étiquette (étiquette de l’instruction FORMAT auquel an fait référence) ;

k : est une liste de variable (qui peut être vide).

Exemple :

READ (1, 100) A, B, X(3) WRITE (3, 200) A, X(5), Y

100 FORMAT (3F15.7) 200

VI.2.1. Entrée/sortie en format libre

Lorsque l’on travail à partir d’un terminal, le respect d’un format en entrée est pénible. Pour se dispenser du « formatage », on pourra utiliser le format libre qui s’écrit :

READ (u, *) liste

Les données doivent être introduites dans l’ordre de la liste. Elles sont séparées les unes des autres par une virgule, un slash ou par des blancs.

Exemple :

READ (1, *) A, B, C

Permettra de lire A, B, C introduite sous la forme : 3.4, 2.5 7.28

VI.2.2. Liste d’entrée/sortie

Pour éditer le contenu des variables A, B, X(1), X(5), nous écrivons par exemple : WRITE (1, 100) A, B, X(1), X(5)

Pour éditer des éléments d’un tableau :

- Nous pouvons utiliser une liste d’entrée/sortie contenant tous les éléments du tableau ; - Ou bien utiliser une liste DO implicite ;

- Ou bien faire figurer sans indice le nom du tableau

Exemple1 :

WRITE (3, 100) (X(I), I = 3, 15, 2) WRITE (3, 200) A, B, (X(I), I = 1, 20) WRITE (3, 200) A, B, X

Exemple2 :

DIMENSION A(10), B(10), C(10), D(10, 10), E(10) READ (5,100) (A(I), I = 1, 10) 100 FORMAT (10F8.4) DO 200 I = 1, 10 200 READ (5, 100) B(I) DO 300 I = 1, 10 300 READ (5, 100) (C(I, J), J = 1, 10) READ (5, 100) ((D(I, J), J = 1, 10), I = 1, 10) READ (5, 100) E

- Les nombres A(1)……A(10) seront lus sur la même ligne si le format ne dépasse pas la capacité de l’écran (80 colonnes) ;

- Les nombres B(1)……B(10) seront lus chacun sur une ligne ; - Les matrices carrées C et D seront lues ligne par ligne ; - Les nombres E(1)……E(10) seront lus sur la même ligne.

VI.2.3. Règles relatives aux instructions READ et WRITE

Règle 1 : en principe, si une liste d’entrée/sortie nécessite l’édition de n valeurs numériques,

l’instruction FORMAT associe doit contenir n descripteurs de traitement des variables.

Règle 2 : si la liste d’entrée/sortie est satisfaite avant que l’exploration complète du FORMAT ne

soit terminée, l’exploration des descripteurs de traitement des variables est abandonnée.

Règle 3 : l’exécution d’une instruction READ peut faire lire un enregistrement contenant plus de

données que la liste d’entrée/sortie. Dans ce cas les données excédentaires ne sont pas traitées et tout se passe comme si elles ne figurent pas dans l’enregistrement.

VI.3. L’instruction FORMAT

L’instruction FORMAT doit permettre : - D’éditer du texte ;

- De décrire les types de conversion à effectuer entre représentation interne et représentation externe.

Pour cela, l’instruction FORMAT fait appel à deux catégories de descripteurs : - Des descripteurs de mise en page et d’édition de texte ;

- Des descripteurs de traitement des variables. VI.3.1. Tableau des différents descripteurs

Dans une même unité de programme, plusieurs READ et WRITE peuvent faire référence à une même instruction FORMAT. Il est donc nécessaire que chaque descripteur de traitement de variable fasse apparaître le type de la variable et la représentation externe.

Exemple :

Descripteur I5

I : signifie variable de type entière ;

5 : dans la forme externe la valeur numérique doit s’exprimer au moyen de 5 caractères. Le tableau suivant montre l’utilisation et la forme générale des différents descripteurs :

Forme Descripteur Forme générale Descripteurs

de traitement de variables

Double précision D tDw.d

Réel avec exposant Réel sans exposant

E F tEw.d tF.d Entier I tIw Logique L tLw Descripteurs d’édition et de mise en forme Edition de texte H nHh1…….hn Insertion de blanc X nX Tabulation T nT

w et n = constante entière sans signe non nulle représentant la longueur de la zone de la chaîne de caractères sur l’enregistrement.

d = constante entière représentant le nombre de chiffres dans la partie fractionnaire de la chaîne de caractères.

t = constante entière représentant le facteur de répétition. VI.3.2. Les spécifications

- Pour demander la répétition d’un descripteur de zone, il suffit d’écrire avant le descripteur le nombre de fois qu’il doit être répété :

Exemple :

100 FORMAT (3E18.7, I5)

Il faut utiliser 3 fois la séquence E 18.7. Cette instruction est équivalente à

100 FORMAT (E18.7, E18.7, E18.7, I5) * Descripteur I: Exemple : J = 435 WRITE (3, 100) J 100 FORMAT (I5) En sortie on aura: 4 3 5 * Descripteur E et F Exemple1 : 1250.903

Le descripteur E15.5 donne 0 . 1 2 5 0 9 E + 0 4 5 15 Exemple2 : A = 35.122 B = 1397.123 WRITE (3, 10) A, B 10 FORMAT (F 10.3, F 15.6) On aura : A = ^^^^35.122 B = ^^^^1397.12300 10 15 * Descripteur D : même chose que pour E. * Descripteur de mise en page :

Exemple1 : (X)

WRITE (3, 10) Y, Z

10 FORMAT (F 10.7, 5X, E 14.7) On aura :

Valeur de Y « blancs » valeur de Z 10 caractères 5 caractères 14 caractères

Exemple1 : (H)

WRITE (3, 100)

100 FORMAT (23H LE FORTRAN EST COMMODE) On aura :

VI.4. Les fichiers

VI.4.1. Définition de fichier

Il sera intéressant d'envoyer certains résultats dans des fichiers, pour une utilisation ultérieure par un programme différent. Ces fichiers seront soit des fichiers d'entrée, soit des fichiers de sortie. Lorsque les résultats d'un programme sont nombreux, il est agréable de pouvoir les consulter dans un fichier, à l'aide d'un éditeur de texte. Le fichier dans ce cas là, sera un fichier texte, à accès séquentiel.

VI.4.2. Ouverture d'un fichier

Une instruction standard d'ouverture de fichier a généralement la forme suivante : OPEN(unité, FILE = 'nom du fichier', STATUS =

'OLD' 'NEW'

'UNKNOWN' )

Description de chaque paramètre

unité : nombre entier qui sera choisi entre 5 et 20, de préférence supérieur à 10. status : Peut être 'OLD', 'NEW', 'UNKNOWN'.

OLD : Le fichier doit déjà exister NEW : Le fichier est à créer .

UNKNOWN : NEW ou OLD si le fichier existe ou non.

Exemples :

C Ouverture d'un fichier existant déjà

OPEN (11, FILE='DONNEES.DAT') ...

C Ouverture d'un nouveau fichier pour y placer des Cresultats

OPEN (12, FILE='RESULT.DAT', STATUS='NEW') VI.4.3. Fermeture d'un fichier

La fermeture d'un fichier se fait automatiquement lorsque le programme se termine normalement.

Syntaxe :

CLOSE (unité)

Exemple :

C fermeture et effacement du fichier 8 CLOSE (8)

Chapitre VII

Les sous-programmes

VII.1. Généralités

Lorsqu’il est nécessaire d’exécuter, en des points différents d’un programme, une meme séquence de calculs avec des données différentes, il est recommandé d’utiliser un sous programme. Un simple exemple de sous-programme : les fonctions de la bibliothèque FORTRAN : SIN, SQRT,…..

Il existe trois autres types de sous-programmes ;

- L’instruction fonction ou fonction arithmétique, - Le sous-programme FUNCTION,

- Le sous-programme SUBROUTINE. VII.2. L’instruction FONCTION

Elle n’a d’existence qu’a l’intérieur du programme (ou sous-programme de type FUNCTION ou SUBROUTINE) où elle est définie. Une instruction FONCTION est définie par une seule expression arithmétique en tête du programme où elle apparaît, avant la première instruction exécutable et après les déclarations DIMENSION ou DATA.

Sa forme générale est : NOM (X, Y, Z) = expression arithmétique

Exemple :

F(X) = SQRT(3.*X+2.*SIN(X**2)) ou G(X,Y) = X*X+Y*Y+X*Y NOM : est le nom de la fonction,

X, Y, Z : sont les arguments de la fonction. Ce sont des variables non indicées.

Le nom de la fonction doit satisfaire aux règles des noms de variables, son type est le type du nom.

L’expression arithmétique précise les calculs à effectuer sur des éléments qui peuvent être : - Des constantes,

- Des variables non indicées,

- Des fonctions de la bibliothèque FORTRAN, - Des noms d’instruction fonction,

- Des noms de sous-programmes FUNCTION

Exemple :

F(X) = SQRT(3.*X+2.*SIN(X**2)) est réelle et son argument est réel. I(A, B, C) = A+B+C est entière et ses trois arguments sont réels. DOUBLE PRECISION F, X, Y, SOMME, A, B

F(A, B, X, Y) = A+B+SOMME(X, Y)/DSQRT(SOMME(A, B)) Les deux fonctions et leurs arguments sont en double précision.

L’appel d’une instruction fonction se fait dès que son nom figure dans une expression arithmétique suivi d’une liste de variables d’appel de même nombre et de même type que les paramètres formels de définition. Ces paramètres d’appel sont les valeurs pour lesquelles on veut calculer la fonction.

VII.3. Le sous-programme FUNCTION

C’est un programme indépendant, compilé indépendamment du programme d’appel, il est donc possible d’utiliser les mêmes étiquettes que dans le programme d’appel et de prendre les mêmes noms de variables. Il comporte un nombre quelconque d’instructions.

La forme générale est :

FUNCTION NOM (A, B, C) ………….

NOM = ………… RETURN

END

NOM : est le nom du sous-programme, il satisfait aux lois des noms de variables. Il apparaît au moins une fois à gauche du signe « = » d’une instruction arithmétique du sous-programme. A, B, C : sont des noms de variables non indicées ou des noms de tableaux.

Le type de résultat est le type du nom de la FUNCTION qui peut figurer dans une déclaration de type.

Exemple :

REAL FUNCTION I (A, B, C)

est réelle de 3 arguments réels et dans ce cas le programme d’appel doit comporter la déclaration de type: REAL I

Les arguments sont dits ”muets” ou formels qui seront remplacés lors de l’exécution par les variables de la liste d’appel qui peuvent etre:

- des constantes,

- des variables, indicées ou non, - des tableaux,

- des expressions arithmétiques.

Le retour au programme d’appel est commandé par l’instruction RETURN du sous-programme. VII.4. Le sous-programme SUBROUTINE

O distingue deux sortes de SUBROUTINES : - SUBROUTINE avec liste d’arguments, - SUBROUTINE avec l’instruction COMMON.

VII.4.1. SUBROUTINE avec arguments

Il ressemble beaucoup au sous-programme FUNCTION mais il peut renvoyer plusieurs résultats au programme d’appel. Sa forme générale est :

SUBROUTINE NOM (A, B, C) …………

C = (A*A+B*B)/(A+B) ………….

RETURN END

NOM : est le nom du sous-programme, son type n’a aucune importance car il ne sert que de « titre ».

A, B, C : sont des noms de variables non indicées ou de tableaux.

Le programme SUBROUTINE est appelé, dans un programme principal ou dans un sous-programme par une instruction CALL de la forme :

CALL NOM (X, Y, Z)

Où : X, Y, Z sont les noms des arguments sur lesquels le calcul doit etre fait, ils peuvent etre des constantes, des variables indicées ou non, des tableaux ou des expressions arithmétiques.

Exemple :

SUBROUTINE MULT (A, B) A = 2.*A

B = 3.*B RETURN END L’instruction d’appel est :

CALL MULT (X, Y)

X aura à la sortie le double de sa valeur d’entrée. Y aura à la sortie le triple de sa valeur d’entrée. VII.4.2. SUBROUTINE avec COMMON

Il est identique comme forme et comme appel au précédant mais à part le fait qu’il peut ne pas comporter une liste d’arguments, certains arguments étant transférés par l’intermédiaire de l’instruction COMMON.

L’instruction COMMON permet l’usage d’une même zone mémoire par un programme et ses sous-programmes, d’où un gain de place et de temps.

a) COMMON blanc :

Les variables listées dans le COMMON peuvent être indicées ou non, elles sont implantées en mémoire dans l’ordre de la liste.

Exemple : COMMON A, B, C, X

b) COMMON étiqueté :

Exemple :

Programme principal : COMMON/C1/A, B, C/C2/X, Y, Z Sous-programme SP1 : COMMON/C1/U, V, W

Le programme principal et chaque sous-programme sont analysés séparément par le compilateur. Ils peuvent donc figurer soit dans un même fichier, soit dans des fichiers séparés. Il est préférable de faire un fichier par sous-programme. Au moment de la mise au point de petits programmes, il est plus facile de faire figurer le programme principal et les sous programmes ensemble, puis de les séparer lorsque la compilation et les essais d'exécution ont réussi.

L'éditeur de liens réalise la construction globale du programme et des sous-programmes. Il fait également des tests de compatibilité au niveau des passages de paramètres.

Dans le cas où l'on fait figurer dans un même fichier programme et sous-programmes, le programme principal doit figurer en tête, suivi des sous-programmes, chacun se terminant par END, pour bien délimiter les blocs.

On distingue 4 types de modules :

PROGRAM : Programme principal, tout module dont la première instruction n'est pas SUBROUTINE, FUNCTION ou BLOCK DATA. Ce module peut comporter comme première instruction PROGRAM, mais ce n'est pas obligatoire.

SUBROUTINE : Ce module est un sous-programme toujours appelé par un CALL à partir d'un autre module de type programme ou sous-programme.

FUNCTION : Ce module est simplement appelé par son nom à partir d'un autre module. BLOCK DATA : Ce module initialise des variables placées dans un COMMON nommé. 7.2 Programme principal

Un programme comporte 2 parties :

• Les déclarations concernant les variables, • Les instructions exécutables.

On peut placer au début du programme l'instruction PROGRAM Nom du programme. Cette instruction est facultative, le compilateur n'en a nullement besoin, mais en fin de programme, on fera toujours figurer l'instruction END.

Structure globale :

PROGRAM nom du programme Déclarations des variables utilisées Instructions exécutables

END

Attention : On ne peut pas placer de déclaration après une instruction exécutable . 7.3 Sous-Programmes

• Les fonctions qui sont appelées par leur référence dans une expression mathématique et fournissent un résultat numérique.

• Les fonctions implicites qui font partie du langage. Elles se trouvent dans les librairies du FORTRAN. Ce sont par exemple les fonctions mathématiques du genre SIN(x), SQRT(x), etc. • Les sous-programmes qui sont appelés par un CALL et peuvent fournir plusieurs résultats. Ces résultats figurent obligatoirement parmi les paramètres.

7.3.1 Structure d'un sous-programme type SUBROUTINE SUBROUTINE nom(liste de paramètres)

Déclarations des paramètres Déclarations des variables Instructions exécutables

RETURN END

L'instruction RETURN redonne la main au programme appelant. On peut placer plusieurs instructions RETURN dans un même module, mais pour des raisons de structuration et de lisibilité, on évitera cette pratique. Faire figurer cette instruction de préférence à la fin du module, ou alors l'oublier, car elle n'est plus nécessaire pour les versions actuelles du FORTRAN.

La forme générale de l'appel d'un sous-programme du type SUBROUTINE sera : CALL nom du sous-programme(liste de paramètres)

Les paramètres peuvent être : • des constantes de tous types

• des expressions arithmétiques ou logiques • des noms de fonctions ou de sous-programmes

• des variables simples ou indicées (éléments de tableaux) • des noms de tableaux

En sortie, le sous-programme peut modifier : • les variables simples

• les variables indicées

Exemple d'appel de sous-programme : CALL SPROG(A,MAT,10)

4.3.2 Structure d'un sous-programme du type FUNCTION FUNCTION nom(liste d'arguments)

Instructions

nom = ...

RETURN ! Facultatif END

Remarquer deux choses :

• L'entête avec sa déclaration de type, car une fonction retourne une valeur dont il faut déclarer le type

• L'instruction END délimite les blocs, et l'instruction RETURN n'est plus obligatoire pour les versions actuelles du FORTRAN.