Batata

Chapitre III Eléments de base du langage FORTRAN
Chapitre III
Eléments de base du langage FORTRAN
1. Introduction :
Le langage FORTRAN ( FORmula TRANslator ) à été le premier langage évolué permettant

de programmer des problèmes scientifiques. Un programme en FORTRAN est une suite
d’ordres écrits dans un langage compréhensible par l’ordinateur, permettent la résolution d’un
problème.
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. Ce fichier peut être envoyé sur une
imprimante ou affiché sur l'écran. C'est ce que fait l'éditeur de texte. 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).
Dans un cas simple, sur un compatible PC, on écrit le programme que nous appellerons par
exemple PROG.FOR texte. On sauvegarde le fichier source sur le disque dur en lui donnant un
nom respectant les conditions du système d'exploitation utilisé.
2. 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 26 lettres de l'alphabet, majuscules et minuscules ainsi que les 10 chiffres.
¾ Les caractères spéciaux
espace blanc
= signe égal
+ plus
- moins
* étoile
/ barre de fraction
( parenthèses
)
, virgule
. point
' apostrophe
: double point
Chaque instruction, sauf l'instruction d'affectation (ex. : VALEUR = 10), commence par un
mot-clé du FORTRAN.
2.1. 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é:
WRITE, READ, PRINT.
15
2.2. Mise en place des instructions
2.2.1. Structure d'une ligne FORTRAN

De nos jours, les programmes sont tous écrits à l'aide d'un éditeur de texte. Une ligne en
FORTRAN se décompose en quatre groupes de colonnes (total de colonnes: 80).
¾ Zone A (colonnes 1 à 5) : elle contient un nombre entier qui sert à repérer une instruction
c’est la zone ETIQUETTES. Les étiquettes servent à référencer les lignes pour par exemple
un saut (GOTO) ou un format d'entrée/sortie (FORMAT).
¾ Zone B (colonnes 7 à 72) : elle contient l’instruction FORTRAN proprement dite.
¾ Zone C (colonnes 73 à 80) : généralement elle est utilisée pour numéroter les lignes du
programme elle est ignorée par le compilateur.
¾ Zone D (colonne 6) : si elle contient un caractère quelconque autre que le zéro. Elle spécifie
une ligne suite. En effet. si une instruction ne peut être écrite sur une ligne, nous pouvons la
faire suivre de 9 lignes au maximum.
Attention : Le non respect de l'usage de ces quatre groupes de colonnes est une cause fréquente
d'erreurs que commet un débutant.
Quand on parle de la programmation structurée on doit passer par 6 étapes:

Première Etape
La tête du programme doit réservée toujours ou nom du programme.
Le nom est utilisé lorsque le programme est rangé dans une bibliothèque de programme. On
peut aussi ajouter quelques commentaires qui expliquent le but de ce programme.
Deuxième Etape (Partie déclaratif)

Dans la programmation structurée, il faut toujours déclarer la nature des données utilisées.
Troisième Etape (Partie introduction des données)

C’est une partie consacrée aux données introduites par le clavier et qui sont nécessaires pour
l’exécution du programme.
Quatrième Etape (Partie de traitement)

C’est la patrie des instructions qui doivent traiter (calcul, comparaison, etc.) par l’unité centrale
de l’ordinateur).
Cinquième Etape (Partie d’affichage des résultats).

Est caractérisée par les instruction PRINT, WRITE et FORMAT
Sixième Etape (Partie fin du programme).

Tous les programmes en FORTRAN 77 comportent les deux instruction de Fin de programme
STOP et END.
Remarques
¾ Les compilateurs FORTRAN 90 admettent le format libre de ligne. Aucune colonne n’est
réservée, un commentaire commence par un point d’exclamation, la colonne 72 n’est plus
une limite, le fait de préciser .f90 pour l’extension d’un fichier source au lieu de .for,
implique l’utilisation du format libre.
¾ 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 commentaires, afin de rendre le
programme plus lisible.
16
¾ Le FORTRAN 90 admet également des commentaires en fin de ligne d'instruction. Dans ce

cas, ils commencent par un point d'exclamation.
¾ Il est possible, en FORTRAN 90, de placer plusieurs instructions par ligne, à condition de
les séparer par des points-virgule, mais réservez cette possibilité uniquement aux
affectations d'initialisation.
2.2.2. 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.
Ils utilisent toutes les lettres de l'alphabet, ainsi que les 10 chiffres, mais ils ne commenceront
jamais par un chiffre.
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)
3. Constantes et Variables
3.1. Constantes :
C’est une quantité dont la valeur numérique est fixée et ne peut plus être modifiée pendant
l’exécution du programme. Les constantes que nous étudierons sont :
3.1.1. Constantes entières : elles s’écrivent avec 1 à N chiffres décimaux (N dépend de

l’ordinateur utilisé). Elles sont précédées ou non d’un signe + ou - . Aucun espace ou point n’est
autorisé entre les chiffres composant cette constante.
Exemples : +6 -231 126
3.1.2. Constantes réelles simple précision : deux formes sont possibles, avec exposant et sans
exposant.
a) Constantes réelles sans exposant :
C'est une chaîne de chiffres comportant obligatoirement un seul point décimal, pouvant être
précédée d'un signe.
Exemples: +11.6 - 23.12 12. .125
b) Constantes réelles avec exposant :
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
Exemples: -17.E+2 115.5E-55 .13E8
3.1.3. Constantes double précision : elles s’écrivent en utilisant la forme avec exposant, la
lettre E devient D.
Exemples: 55.159874D-5 -.5D+6
3.1.4. Constantes complexes : elles sont constituées d’un couple de constantes simple précision
(avec ou sans exposant) entre parenthèses et séparées par une virgule.
Exemples : (20.0,-3.14) (0.,0.) (1.E01,1.23E-02)
3.1.5. Constantes logiques :
Un constante logique n'a que deux valeurs possibles :
. TRUE. . FALSE.
17
3.1.6. Constantes caractères : c’est une suite de caractères alphanumériques ou spéciaux
encadrés par deux apostrophes. L’apostrophe à l’intérieur d’une chaîne de caractères est doublée.
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(*,*)'SAMEDI 22 JANVIER 2005'
3.2. Les variables

Une variable est définie par un identificateur, le nom d’une variable est formé de 1 à 6
caractères alphanumériques dont le premier est obligatoirement alphabétique. FORTRAN est un
langage permettant l'utilisation de 5 types de variables intrinsèques:
REAL réels
INTEGER entiers
LOGICAL logiques
COMPLEX complexes
CHARACTER chaînes de caractères
Exemples : ALPHA FMIN RMAX BETFA MATRIC
3.2.1. Déclaration des variables

Les variables réelles et entières peuvent être déclarées implicitement : si une variable commence
par l’une des lettres suivantes I, J, K, L, M, N, elle est du type entier, sinon elle est du type réel.
Pour les autres types de variables, la déclaration explicite est obligatoire.
DOUBLE PRECISION
COMPLEX
LOGICAL
a) Déclaration explicite
Les variables de type double précision, logique et complexe sont déclarées selon la syntaxe
suivante:
DOUBLE PRECISION
COMPLEX Var1 [,Var2,….,VarN]
LOGICAL
Avec: DOUBLE PRECISION, LOGICAL ET COMPLEX : mots-clés.
b) L’instruction de déclaration implicit
On peut toutefois modifier la déclaration par :
IMPLICIT attribut (lettre), attribut (lettre),...
attribut peut être INTEGER, REAL, CHARACTER, COMPLEX, ...
La lettre qui suit l'attribut désignera alors le type de variable dont elle est initiale.
Exemples:
1)
IMPLICIT LOGICAL(K)
Dans ce cas, les variables KIND, K2, KM sont de type logique, c'est à dire qu'elles ne
peuvent avoir que deux valeurs:
.FALSE. ou .TRUE.
2)
IMPLICIT COMPLEX (W-Z)
Toutes les variables débutant par W, X, Y, Z sont de type complexe
Les déclarations de type se placent en tête de programme, avant toute instruction exécutable:
INTEGER A,B,C,D
REAL MAT,MU
DOUBLE PRECISION DMAT,DMU
Il est normalement inutile de déclarer par exemple la variable INDEX entière, étant donné
qu'elle commence par la lettre I. Par contre toutes les variables double précision, logiques ou
complexes doivent être déclarées.
18
Remarques :
On pourra déclarer alphanumériques toutes les variables dont le nom commencera par la lettre C
en mentionnant en début de programme la déclaration suivante:
IMPLICIT CHARACTER (C)
Dans cette déclaration les chaînes sont déclarées de longueur 1. Or dans la plupart des cas,
notamment dans les programmes orientés gestion, il est intéressant de pouvoir manipuler des
mots. On peut déclarer des variables alphanumériques de longueur différente de 1 en écrivant:
CHARACTER *20 NOM,PRENOM
NOM et PRENOM sont deux chaînes de caractères pouvant comporter au plus 20 caractères.
On peut également déclarer plusieurs variables comme étant de longueurs différentes:
CHARACTER*8 NOM1, NOM2, ORIGIN*15, NOM3
Attention dans l'exemple ci-dessus, NOM1, NOM2 et NOM3 ont une longueur maximale de 8
caractères, et ORIGIN est défini comme étant de longueur 15.
Généralement, on place la déclaration CHARACTER après la déclaration IMPLICIT.
3.2.2. Les variables indicées

On représente une variable indicée ou un tableau par un identificateur, suivi d'indices placés
entre parenthèses et séparés par des virgules :
Identificateur (I1, I2, ...)
Exemples:
TABLE(I,J)
PNT(2,K,L)
A(I)
Une variable indicée est un ensemble de variables simples, de même type. Un vecteur, une
matrice, un polynôme constituent des variables indicées. Le nombre d’indices tolérés est au
maximum de 3. Toutefois certains compilateurs proposent 7.
Une variable indicée est déclarée avant toute utilisation. Si le nom de ces variables commence
par l’une des lettres I, J, K, L, M, N, elles sont dites entières, sinon elles sont réelles (déclaration
IMPLICITE). Les autres variables indicées de types doubles précision, complexe, logique et
caractère sont déclarées explicitement. La syntaxe de déclaration pour les 3 premiers types est:
DOUBLE PRECISION
COMPLEX Tab1 (i1 [,i2,i3])
LOGICAL
Il faut prévenir le compilateur de la place mémoire à réserver à une variable indicée à l'aide de
l'instruction DIMENSION.
Exemple:
DIMENSION ELEM(20,20), X(20)
4. Opérateurs et fonctions mathématiques

4.1. Opérateurs arithmétiques
Une expression arithmétique est un ensemble formé de constantes, variables et fonctions
séparées par des opérateurs et des parenthèses ; elle est destinée à fournir une valeur numérique.
Au moment de l’évaluation, toute les variables et les fonctions doivent être définies.
Les symboles des opérations arithmétiques utilisées par FORTRAN sont les suivants :
+ Addition
- Soustraction
* Multiplication
/ Division
** Exponentiation
19
Pour le calcul des expressions arithmétiques, une priorité est établie entre les opérateurs
arithmétiques. L’évaluation d’une expression arithmétique se fait selon l’ordre de priorité
suivant :
− évaluation à une puissance (**).
− multiplication et division (*, /).
− addition et soustraction (+, -).
Le langage FORTRAN permet aussi l’utilisation des parenthèses de façon conventionnelle. Plus
précisément, les parenthèses sont prioritaires sur toutes les opérations arithmétiques et c’est le
couple de parenthèse le plus interne qui est traité le premier.
Les opérations arithmétiques simples sont évaluées de la gauche vers la droite. Par contre, deux
exponentiations successives sont évaluées de la droite vers la gauche.
4.2. Opérateurs de comparaison
FORTRAN 77 FORTRAN 90
.GT. Plus grand que (Greater than) >
.GE. Plus grand ou égal que (Greater than or equal to) >=
.EQ. Egal à (Equal to) ==
.NE. Différent de (Not equal to ) /=
.LE. Inférieur ou égal à (Less than or equal to) <=
.LT. Inférieur à (Less than) <
4.3. Opérateurs logiques

En logique, il n'existe que deux états :
.TRUE. VRAI
.FALSE. FAUX
Les opérateurs logiques sont:

.NOT. NON
.AND. ET
.OR. OU
.EQV. EQUIVALENCE
.NEQV. NON-EQUIVALENCE
4.3. Fonctions mathématique

On peut citer les plus usuelles :
SIN sinus
COS cosinus
ALOG logarithme népérien
EXP exponentielle
SQRT racine carrée
ATAN arc tangente
TANH tangente hyperbolique
ABS valeur absolue d'un réel
IABS valeur absolue d'un entier
FLOAT convertit d'entier à réel
IFIX convertit de réel à entier
20
Exemples :
ABS (a − b ) + c / sin( d )
c
¾ a−b + ⇒
sin d
e x+ y
¾ ⇒ EXP( x − y ) / (x + y )
x+ y
Remarques
- Pour éviter les erreurs d’interprétation, il est conseillé d’utiliser les parenthèses.
- Dans une expression arithmétique sans parenthèse qui comprend des fonctions de la
bibliothèque, l’évaluation de ces fonctions est prioritaire sur les règles énoncées
précédemment.
4.4. Conversion de type dans une opération
Le compilateur ne sait faire des opérations arithmétiques (+ - * / **) que sur des valeurs codées
de la même manière. Si vous lui demandez un calcul entre deux variables de type différent, le
compilateur doit avant tout en convertir une pour qu'elles soient de même type. Il sait convertir
automatiquement un entier en réel et un réel en double précision. Donc, suivant le type des deux
opérandes, le résultat de l'opération sera : Donc, suivant le type des deux opérandes, le résultat
de l'opération sera :
integer real double précision
integer integer real double précision
real real real double précision
double précision double précision double précision double précision

Exemples
b**2 sera du type de b.
4*a*c sera du type le plus fort de a et de c.
Si a et c sont real, et b double précision, le résultat de b**2-4*a*c sera double précision, mais
attention, le produit a*c sera effectuée en simple précision, d'où une perte de précision possible.
Remarques
− 2/3 sera du type integer. Autrement dit la division effectuée sera une division entière, et le
résultat sera 0. Pour calculer effectivement deux tiers en réel, écrire : 2./3, 2/3. ou 2./3.
− Vous pouvez indiquer au compilateur quelles conversions il doit effectuer. Pour cela, on
utilise les fonctions : FLOAT, IFIX …etc.
Exercice 1
Ecrire les expressions logiques suivantes en FORTRAN77
A≥B X<Y et Z>W X#Y
X2 ≥ 0 ou Y<0 (X-Y)2 ≤ l.2

Exercice 2
Ecrire les expressions arithmétiques suivantes en FORTRAN.
V = 4πR 3 / 3
R = T / C ln α 0
p2 + 3
y = 20 log
p3 − 3 p2 + 1
Exercice 3
Les mots suivants sont-ils des identificateurs FORTRAN ? Expliquer la réponse dans tous les cas ?
PROGRAMME
3TAUX
Z 36
X.5
21
5. Les instructions de FORTRAN

L’exécution des instructions se fait en séquence l’une après l’autre suivant l’ordre d’apparition
de ces instructions dans le programme. Mais cet ordre peut être altéré par les instructions
suivantes
GOTO, IF, RETUEN, CALL, DO, STOP.
La première instruction d’un programme est l’instruction

PROGRAM Nom programme.
Cette instruction est facultative, elle permet de donner un nom au programme.
5.1. Instruction d’affectation

La syntaxe est:
Var = expr
Avec:
Var: variable numérique simple ou indicée.
expr: expression arithmétique qui est évaluée puis convertie au type de Var.
5.2. L’instruction PARAMETER

C’est une instruction qui initialise des variables qui seraient utilisées dans des affectations ou
dans des déclarations.
Sa syntaxe est:
PARAMETER (Varl=Cstl [,VarN=CsteN)]
Avec:
Var1, Var2, VarN : variables, elles ne devraient pas être déclarées explicitement par les
instructions de déclarations.
Cstel, Cste2 ,CsteN : constantes de types numérique caractère ou logique,
Exemple
PARAMETER (u=l0)
READ(u,*)((a(i,j),i=1,l0),=l,5)
5.3. Instruction d’initialisation des variables (DATA)

Son rôle est d’alléger le programme en évitant de faire plusieurs affectations.
Sa syntaxe est:
DATA VI1, VI2,...,VIN/Cl,C2,...,CN/
Avec:
VIi: Variables à initialiser.
Ci: constante
La Variable VI1est initialisée par Cl, VI2 par C2 etc…
Remarque :
Dans le cas où nous avons plusieurs constantes identiques successives il est préférable d’utiliser
un facteur de répétition.
Exemple : Dans une partie d’un programme FORTRAN, nous rencontrons ceci :
I=2
J=2
K=2
L=5
Nous utilisons DATA comme suit:

DATA I,J,K,L/2,2,2,5/
Ou en utilisant le facteur de répétition:
DATA I,J,K,L, /3*2,5/
22
5.4. Les instructions D’entrée / Sortie

Nous distinguons deux types d’opérations E / S en FORTRAN:
a- les E/S en format libre.
b- les E/S contrôlées par un format.
Le Fortran attribue à chaque périphérique un numéro d'unité logique. Fortran attribue le

Caractère * à la console.
Dans la réalisation d’une E/S, 4 instructions sont utilisées:
PRINT : impression des résultats sur le terminal
READ : lecture des données tapées à partir du clavier vers la mémoire centrale.
WRITE : sortie des données de la mémoire centrale vers un périphérique.
FORMAT : format avec lequel les variables doivent être transmises. Il est utilisé par les
instructions précédentes.
5.4.1. L’instruction PRINT
a- Sa syntaxe avec format libre :

PRINT*[,liste]
Liste : liste des données. Les données peuvent être des variables de n’importe quel type ou des
constantes chaînes de caractères.
Exemples:
PRINT*,‘le résultat est=’
PRINT*,I,J,F
b- Sa syntaxe avec format imposé :

PRINT étiq,liste
Avec:
étiq : l’étiquette d’une instruction FORMAT
liste : liste de résultats
5.4.2. L’instruction READ
a- Syntaxe de l’instruction READ avec format libre

Nous avons la possibilité de l’écrire sous deux formes:
¾ première syntaxe en format libre
C’est une lecture à partir du terminal. L’entrée des données se fait par le clavier.
READ*,liste
Cette instruction lit sur le terminal les valeurs des éléments de la liste. Ces valeurs doivent être
séparés par dés virgules.
Exemples
READ*,x,y
READ*,I,J,K,FIN
A l’exécution on introduit les valeurs de I,J,K,FIN séparées par une virgule ou un espace
Soit , par exemple
5, 20,10, 300.5E- 05
¾ deuxième syntaxe avec format libre
La lecture se fait à partir de l’unité logique.
READ(u,* [,liste de spécifications])liste
Avec:
u : numéro d’unité logique.
23
Exemples
Lecture d’une matrice
READ(5,*)(A(I,J),I=1,10), J=1,15)
Lecture d’un vecteur
READ(7,*)(X(I),I=1,100)
Lecture des variables
READ(1,*)A,B,C
b- Syntaxes de l’instruction READ avec format imposé

Deux formes d’écriture sont possibles:
¾ Premiere syntaxe
READ ef,liste
¾ Deuxième syntaxe
READ(u,ef[,liste de spécifications]) liste
Avec:
ef: étiquette de l’instruction FORMAT.
La liste des spécifications sera explicitée par la suite
Exemple
READ 10,A,B,C,D
10 FORMAT (descripteurs)
READ(5,25)(X(I),I=1,10)
25 FORMAT(descripteurs)
Les descripteurs seront explicités par la suite.
5.4.3. L’instruction WRITE
a- Sa syntaxe en format libre est :

WRITE(u,*[,liste de spécifications])liste
Avec:
Liste : liste de variables simples ou indicées, de chaînes de caractères ou d’expressions.
u : numéro d’unité logique.
Exemple
WRITE(10,*)‘les solutions sont égales à :’,I,J,K
b- Sa syntaxe en format imposé est :
WRITE(u,ef[,liste de spécifications])liste
Avec:
u : numéro d’unité logique
ef: étiquette de l’instruction FORMAT
liste : liste de variables
Exemple
WRITE(10,15)((A(I,J),J=1,10),I=1,10)
15 FORMAT(descripteurs)
N.B. La liste des spécifications sera explicitée par la suite.
5.5. Les instructions de test

Ce sont des instructions d’exécution conditionnelles.
5.5.1. L’instruction IF arithmétique

Cette instruction effectue un test sur une expression arithmétique dont le signe renvoie à 3
représentations possibles : positive, négative ou nulle Elle est dite aussi test à 3 sorties
Sa syntaxe est :
IF (ExpArit) étiqi,étiq2,étiq3
24
Avec:
ExpArit : expression arithmétique

étiq1, étiq2. étiq3 : étiquettes numériques correspondant respectivement à ExpArit négative,
ExpArit nulle et ExpArit positive.
Exemple
DELTA = B*B-4*A*C
IF (DELTA) 10,20,30
Nous pouvons la représenter comme ci-contre:
5.5.2. L’instruction IF logique

C’est une instruction qui réalise un test logique sur une expression à valeur logique
Sa syntaxe est
IF (Explog) instExéc
Avec :
Explog: expression logique
InstExéc : instruction exécutable. Elle n’est exécutée que dans le cas ou l’évaluation de
l’expression logique st vraie. Elle est décrite par l’organigramme suivant:
L’instruction peut être n’importe quelle instruction FORTRAN sauf les instructions IF , DO ,
END.
5.5.3. L’instruction IF… THEN… ELSE / ENDIF

Contrairement aux IF précédents qui conditionnaient une instruction simple. Celle-ci
conditionne une séquence, c’est à dire une suite d’instructions
Sa syntaxe est :
IF (condition) THEN
traitement-l
ELSE
traitement-2
ENDIF
Si la condition est vraie, alors seulement le traitement-1 est exécuté, sinon c’est à dire si la
condition est fausse, alors seulement le traitement-2 est exécuté.
25
Example
IF (DELTA.LT.0.) THEN
PRINT *, ‘RACINES COMPLEXES’
ELSE IF (DELTA.EQ.0.) THEN
PRINT*, ‘RACINE DOUBLE’
ELSE
PRINT *, ‘ RACINES REELLES’
ENDIF
5.6. Les instructions de branchement

Ces instructions sont utilisées généralement avec les instructions de test précédentes. Elles ont
pour rôle d’indiquer le traitement à prendre lors du choix. Pour cela, un numéro qui est une
étiquette désigne l’instruction correspondante au traitement.
Il existe deux types d’instructions de branchement
5.6.1. L’instruction de branchement inconditionnel (GOTO)

Sa syntaxe est :
GOTO étiq
Avec:
étiq : étiquette de l’instruction où le branchement doit se faire pour éviter l’exécution en
séquence.
Exemple
GOTO 30
....
30 READ*,I
....
5.6.2. GOTO calculé
Sa syntaxe est: GOTO (nl,n2 ...... ni),I
nl,n2...... ni: étiquettes d’instructions exécutables.

I: Expression arithmétique éventuellement tronquée pour obtenir un résultat entier.
Suivant la valeur de I, cette instruction renvoie à l’une des étiquettes.
5.7. Les instructions de répétitions (les boucles DO)

5.7.1. La boucle DO
Une boucle est une suite d'instructions que le programme va parcourir un certain nombre de fois.
Le mot-clé d'une boucle est: DO
Sa syntaxe est:
Do étiq VE=I,F,P
.......
étiq CONTINUE
Avec:
étiq : l’étiquette d’une instruction exécutable de fin de boucle qui est l’instruction CONTINUE.
VE : variable entière qui fait le contrôle de la boucle, c'est le compteur.
I et F : Bornes du compteur de boucle.
P : Un compteur de boucle peut évoluer non seulement par incrément de 1, mais aussi se
décrémenter, ou évoluer par pas entiers constants, mais quelconques. Cet élément est facultatif.
Son absence sous entend un incrément de 1.
Il est possible d’imbriquer les boucles, c’est à dire d’utiliser des boucles à l’intérieur des autres à
condition qu’elles soient contrôlées par des variables différentes.
26
Exemple
Calcul de l a somme des éléments de la diagonale d’une matrice carrée :
dimension a(6,6)
read(5,*) n
do 10 i=1,n
10 read(5,*) (a(i,j),j=1,n)
s=0
do 20 i=1,n
s=s+a(i,i)
20 continue
write (6,*) s
stop
end
¾ Remarques
Si l’incrément est 1, il peut être entièrement omis. par exemple :
DO 100 I=1,N,1 peut être écrit sous la forme abrégée DO 100 I=1,N
il est possible qu’une boucle DO (la boucle DO intérieure) soit comprise totalement dans une
autre boucle DO (la boucle extérieure). Les boucles DO construite de cette façon sont
appelées boucles DO imbriquées, le nombre de boucles DO imbriquées est limité par le
compilateur. Dans l’écriture des boucles imbriquées, les variables de contrôles des boucles
doivent être différentes.
L’instruction CONTINUE ne donne naissance à aucun ordre, elle sert simplement pour des
transferts entraînant une, nouvelle itération DO.
Pour certaines commandes (telles que READ, PRINT, WRITE), il est parfois pratique
d'utiliser des boucles itératives implicites. Pour la lecture des coefficients d'un tableau A de
dimension 10*20, cela donnerait : READ *,((A(I,J),I=1, 10),J=1,20)
5.7.2. La boucle DO...WHILE

La syntaxe de cette instruction est :
DO [étiq [ , ] ] WHILE explog
Avec:
étiq : étiquette de la dernière instruction exécutable de la boucle.
explog : expression logique.
Tant que explog est vraie, un bloc d’instructions compris entre DO WHILE et l’étiquette étiq
sera exécuté. ENDDO délimite le traitement répété.
Nous programmons cette instruction de la sorte:
DO [étiq [ , ] ] WHILE condition
Bloc d’instructions
ENDDO
5.8. L’instruction d’arrêt d’exécution (STOP)
Elle signifie fin de l'exécution, la syntaxe de cette instruction est :
STOP [message]
Remarque
Dans l’absence de [message], le message de défaut suivant est montré :
STOP - Program terminated.
5.9. L’instruction d’arrêt de compilation (END)

Sa syntaxe est :
END
Son rôle est d’arrêter la compilation du programme, elle est donc obligatoire. Elle ne doit être
suivie d’aucune instruction
27
5.10. Gestion des entrées/sorties
a- Les Fichiers
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.
b- Ouverture d'un fichier
L’instruction standard d'ouverture de fichier a généralement la forme suivante :
OPEN(unite, FILE = 'nom du fichier', STATUS =
'OLD'
'NEW'
'UNKNOWN')
• Unite : est un entier représentant l'identificateur de fichier.
• Nom du fichier est une chaîne de caractères représentant le nom du fichier.
• Status est une chaîne de caractères pouvant prendre les valeurs suivantes :
o OLD pour ouvrir un fichier qui existe déjà. Par exemple pour lire des données
dans un fichier.
o NEW pour ouvrir un nouveau fichier ou écraser un fichier dont les données ne
sont plus utiles.
o UNKNOWN. C'est la valeur par défaut. Si le fichier existe, il est ouvert, sinon, un
nouveau fichier est créé.
5.11. L’instruction FORMAT

Cette instruction indique la mise en page pour les états imprimés. La syntaxe de l’instruction
FORMAT est :
étiq FORMAT(descripteurs)
5.11.1. Les descripteurs de traitement des variables

¾ le descripteur I
[m]I n
Cette spécification s'applique aux variables entières. n indique le nombre de caractères à
imprimer, ou le nombre de caractères à lire sur le fichier. m représente le nombre de répétitions
de cette spécification.
Exemples
I=21
WRITE(*,10)I
10 FORMAT(I5)
L’édition donnera : 21 précédé de trois blancs
INTEGER X1,X2,X3
READ(*,60)X1,X2,X3
60 FORMAT(I2,I4,I3)
Nous faisons entrer par le biais du clavier le nombre : un blanc suivi de 58234651, l’attribution
sera ainsi faite:
Xl = un blanc suivi de 5
X2 = 8234
X3 = 651
¾ Le descripteur F
II est utilisé pour la représentation des nombres de type réel en point fixe simple précision.
Sa forme générale est:
[m]Fn.d
Avec:
28
m : répétiteur
n : représente la longueur totale occupée par le nombre à entrer ou à imprimer.
d : représente le nombre de chiffres à imprimer après la virgule.
Pour ne pas avoir de dépassement de capacité, la relation suivante doit être satisfaite:
n = d+p+2
Avec:
n et d comme précédemment.
p : nombre de caractères de la partie entière.
Exemple
Au nombre : +53.127 on associe le Format : F7.3
¾ Le descripteur E
Il est utilisé pour la représentation des nombres de type réel en point flottant simple précision
avec exposant en entrée-sortie.
Sa forme générale est:
[m]En.d
m :répétiteur
n: représente la longueur totale occupée par le nombre à lire ou à imprimer.
d : indique le nombre de positions après le point décimal
Avec : n>d+6
Exemple
U=-2.25267
WRITE(3,5)U
5 FORMAT(E11,3)
L’édition donnera: un blanc suivi de -0.225E+0l
¾ Le descripteur L
Il est utilisé pour le traitement des variables logiques.
Sa forme générale est: [m]Ln
Avec :
m : répétiteur
n: désigne le nombre de caractères qu’occupe la zone externe. Généralement, n est égal à 1.
A l’édition , à droite de la zone sera édité un T (TRUE) si la variable logique est vraie, sinon il
sera édité un F (FALSE).
¾ Le descripteur D
II est utilisé pour représenter des nombres en double précision.
Sa forme générale est: [m]Dn.d
Avec:
m : répétiteur
n et d : Voir le descripteur E.
La relation suivante doit être satisfaite : n ≥d+7
Exemple: Donner le format du nombre l.123456789D+l5
D15.9
¾ Le descripteur A
II est utilisé pour les variables de type caractère. Son intérêt est de permettre la lecture et
l’édition de chaînes de caractères.
Sa forme générale est: [m]An
m : répétiteur
n: longueur de la chaîne caractères.
Exemple
WRITE(l,6)X
6 FORMAT(A6)
Si X a pour valeur MATH, il sera édité comme suit: un blanc suivi de MATH. Le premier blanc
sera ignoré.
5.11.2. Les descripteurs de mise en page et d’édition
29
¾ Le descripteur X
Insère n blancs ou permet de sauter n caractères à la lecture.
Sa forme générale est: nX
Exemple
WRITE(3,5) R, P
5 FORMAT(1X,F8.7,5X,E14.7)
L’édition donnera : un blanc qui sera ignoré à l’édition suivi de 8 positions pour la valeur de R ,
suivi de cinq blancs suivi de 14 positions pour la valeur de P.
¾ Le descripteur ''
II permet l’édition de caractères non interprétés en sortie.
Exemple
WRITE(3,9) R
9 FORMAT(5X,'la valeur de R est:',F8.7)
A l’édition, nous aurons ‘la valeur de R est: ’ suivis de la valeur numérique de R sur 8
positions.
¾ Le descripteur H
Il permet d’éditer un texte.
Sa forme générale est : nH
n indique le nombre de caractère du texte à éditer après le H.
Exemple
WRITE (1,5)
5 FORMAT (lx,8HRESULTAT,/,1H,10(IH=))
6. Exemples
9 Transposition d’une matrice
dimension a(5,5),b(5,5)
read(*,*) n
do 10 i=1,n
10 read(*,*)(a(i,j),j=1,n)
do 20 i=1,n
do 20 j=1,n
c Transposition
b(j,i)=a(i,j)
20 continue
do 30 i=1,n
30 write(*,50)(b(i,j),j=1,n)
c 50 format(5(1x,f11.5))
stop
end
9 Somme de deux matrices
dimension a(4,4),b(4,4),c(4,4)
do 10 i=1,4
10 read(*,*)(a(i,j),j=1,4)
do 20 i=1,4
20 read(*,*)(b(i,j),j=1,4)
do 30 i=1,4
do 30 j=1,4
c(i,j)=a(i,j)+b(i,j)
30 continue
do 50 i=1,4
50 write(*,40)(c(i,j),j=1,4)
40 format (4(1x,e14.7))
stop
end
9 Produit de deux matrices
30
dimension a(30,40),b(40,50),c(30,50)
open(unit=5,file='dmat.dat',status='old')
open(unit=6,file='rmat.dat',status='unknown')
read(5,*)n,m,l
do 10 i=1,n
10 read(5,*)(a(i,j),j=1,m)
do 20 j=1,m
20 read(5,*)(b(j,k),k=1,l)
do 30 i=1,n
do 30 k=1,l
c(i,k)=0
do 30 j=1,m
c(i,k)=c(i,k)+a(i,j)*b(j,k)
30 continue
do 40 i=1,n
40 write(6,*)(c(i,k),k=1,l)
stop
end
9 Elément Max et Min d’un vecteur
dimension a(10)
read(5,*) (a(i),i=1,10)
rmax=a(1)
rmin=a(1)
c recherche du MIN et du MAX
do 35 i=2,10
if(rmax.le.a(i)) then
rmax=a(i)
else
if(rmin.ge.a(i)) then
rmin=a(i)
endif
endif
35 continue
write(6,40) rmax,rmin
40 format (1x,6hrmax= ,f10.4,2x,'rmin=',f10.4)
stop
end
9 lecture d’une matrice
dimension rr(3,3), r(3)
write(6,*) '---> r(i), i=1,3'
read(5,*)(r(i),i=1,3)
do 10 i=1,3
rr(i,i)=r(i)+r(i+1)
10 continue
do 20 i=1,3
rr(i,i+1)=-r(i)
rr(i+1,i)=-r(i)
20 continue
do 40 i=1,3
40 write(6,100) (rr(i,j),j=1,3)
100 format(3(1x,f12.6))
stop
end
31
Exercices
1. Quelles sont les valeurs de A et B qu’imprimerait ce programme.

A=0
B=0
DO 10 I=1,6
A=A+2*I
B=B+3*A
10 CONTINUE
WRITE(*,*) ‘A=’,A,‘B=’,B
STOP
END
2.
Que donnera en sortie le programme suivant:
K= 1
JSOM=0
31 JSOM=JSOM+K**2
K=K+3
IF(K.LT.10) GOTO 31
PRINT*,JSOM
STOP
END
3. Dessiner l’organigramme pour les programmes suivants:

a)
dimension a(6)
write(6,*) 'donner les valeurs de a(i)'
read(5,*) (a(i),i=1,6)
rmax=a(1)
i=2
100 if(a(i).gt.rmax) rmax=a(i)
I=i+1
If(i.le.6) goto 100
write(6,*) 'rmax est'
write(6,*) rmax
stop
end
b)
dimension a(10)
write(6,*) ‘donner les valeurs de a(i)’
do 20 i=1,10
20 read(5,*) a(i)
S=0.
Do 30 i=1,10
S=s+a(i)
30 continue
write(6,*) ‘la somme est égale à’
write(6,*) s
stop
end
32
7. Les sous-programmes
Un sous programme est en réalité un petit programme indépendant qui peut être utilisé
(ou appelé) par le programme principal ou par d’autres sous-programmes. Deux types de sous
programmes sont disponibles dans le langage FORTRAN:
¾ Les sous-programmes, dans lesquels nous retrouvons les fonctions, définies par l’instruction
FUNCTION et les subroutines définies par l’instruction SUBROUTINE.
¾ Les fonctions formules, qui sont des fonctions mathématiques déjà définies, c’est a dire
reconnues par le compilateur.
7.1. Le sous-programme FUNCTION

Nous voulons trouver le plus grand de trois nombre A, B, et C. Si l’on suppose que A, B, C sont
en mémoire, et que GR est la variable réelle utilisée pour stocker la plus grande valeur, le
programme Fortran est :
GR=A
IF(GR.LT.B)GR=B
IF(GR.LT.C)GR=C
STOP
END
Supposons que nous voulions écrire ce programme sous forme d’un sous programme
FUNCTION, nous appellerons notre sous-programme GR ; il a trois paramètres A, B et C.
FUNCTION GR(A,B,C)
GR=A
IF(GR.LT.B)GR=B
IF(GR.LT.C)GR=C
RETURN
END
La syntaxe de définition de FUNCTION est :
[déclaration] FUNCTION nomfct(arg1[,arg2,…,argn])
Avec :
déclaration : instruction de déclaration explicite de type autre que CHARACTER; s’il est absent,
la déclaration est implicite.
nomfct: nom de fonction qui doit être différent de celui des fonctions de la bibliothèque de
FORTRAN. Ce nom doit apparaître au moins une fois dans un sous-programme FUNCTION,
soit a gauche du signe =, soit dans une instruction READ, soit dans une instruction d’appel de
sous-programme.
arg1, arg2,…., argn : arguments; ce sont des noms de variables simples ou indicées, de sous-
programmes ou de fonctions.
Les sous-programmes définis par l’instruction FUNCTION permettent d’écrire des séquences
d’instructions différentes de celles du programme principal.
La structure générale est:
[déclaration] FUNCTION nomfct(arg1[,arg2,.....,argn])
déclarations
instructions exécutables
END
La dernière instruction exécutable doit être RETURN
Sa syntaxe est:
[étiq] RETURN
Elle transmet le résultat numérique de la fonction au programme qui lui fait appel ainsi que le
retour à ce programme l’étiquette est rarement utilisable.
33
Le sous programme FUNCTION doit toujours contenir une instruction d’affectation qui affecte
une valeur au nom de la fonction.
Il faut remarquer que chacune des fonctions de bibliothèque ABS, SQRT, etc. calcule une valeur
chaque fois que l’argument correct lui est donné.
L’appel se fait en écrivant dans n’importe quelle expression mathématique, la syntaxe suivante:
nomfct ( par1[, par2,…., parn])

Avec:
nomfct : nom de fonction.
Par1, par2 parn : paramètres effectifs.
Exemple
Supposons que trios examens et un examen terminal soient passés par une classe de 25 étudiants.
La note finale est calculée en faisant la moyenne de l’examen terminal et la plus haute note des
trois examens.
Le programme suivant qui utilise le sous-programme GR, calcule la note finale de chaque
étudiant.
DO 100 I=1,25
READ(*,*) ID, T1, T2, T3, FINAL
GRADE=0.5*(FINAL+GR(T1,T2,T3))
100 CONTINUE
STOP
END
7.2. Le sous-programme SUBROUTINE

Sa syntaxe est:
SUBROUTINE nomsub [(argi, arg2, ......,argn)]
Avec:
nomsub : nom de la subroutine , pour lequel s’appliquent les mêmes règles dictées aux variables.
argi, arg2 , argn : arguments formels ; ce sont des variables simples ou indicées , de sous-
programmes ou de fonctions.
Nous remarquerons que tous les arguments sont facultatifs, contrairement au FUNCTION où au
moins un argument doit figurer.
L’appel se fait par l’intermédiaire de l’instruction CALL. Cet appel se fait soit dans un
programme principal, soit da un sous-pmgramme.
La syntaxe d’appel est:
CALL nomsub[(parl, par2,......, pam)]
Avec:
par1, par2, pam : paramètres effectifs, qui peuvent êtres des constantes, des noms de variables
simples ou indicées, des expressions arithmétiques, des noms de sous-programmes.
Les sous-programmes définis par l’instruction SUBROUTINE permettent d’écrire des séquences
d’instructions différentes de celles du programme principal.
La structure générale est:
SUBROUTINE nomfct[(argl, arg2, .....,arg)]

declarations
instructions exécutables
RETURN
END
34
Exemples:
Pour l’élément poutre la matrice de rigidité est :
⎡ 12 6 L − 12 6 L ⎤
⎢ 6 L 4 L2 − 6 L 2 L2 ⎥
[K ]
e E.I
= 3 ⎢
L ⎢− 12 − 6 L 12 − 6 L ⎥
⎥
⎢ ⎥
⎣ 6L 2L
2
− 6 L 4 L2 ⎦
1. Le sous-programme SUBROUTINE BEAMKM calcul la matrice de rigidité pour l’élément

poutre :
REAL KM(4,4)
:
:
:
READ(5,*)NXE
DO 10 IP=1,NXE
READ(5,*)EI,ELL
CALL BEAMKM(KM,EI,ELL)
10 CALL FORMKV (KV,KM,IKM,G,N,IDOF)
:
:
:
STOP
END
SUBROUTINE BEAMKM(KM,EI,ELL)
c THIS SUBROUTINE FORMS THE STIFFNESS MATRIX OF A
C HORIZONTAL BEAM ELEMENT(BENDING ONLY)
REAL KM(4,4)
KM(1,1)=12.*EI/(ELL*ELL*ELL)
KM(3,3)=KM(1,1)
KM(1,2)=6.*EI/(ELL*ELL)
KM(2,1)=KM(1,2)
KM(1,4)=KM(1,2)
KM(4,1)=KM(1,4)
KM(1,3)=-KM(1,1)
KM(3,1)=KM(1,3)
KM(3,4)=-KM(1,2)
KM(4,3)=KM(3,4)
KM(2,3)=KM(3,4)
KM(3,2)=KM(2,3)
KM(2,2)=4.*EI/ELL
KM(4,4)=KM(2,2)
KM(2,4)=2.*EI/ELL
KM(4,2)=KM(2,4)
RETURN
END
35
2. Programme de multiplication matricielle
PROGRAM MULT_MAT
C Programme de multiplication matricielle (3x3)
REAL A(3,3),B(3,3)
CHARACTER C
C Initialisation
DATA A,B/18*0.0/
C Corps du programme principal
PRINT*, 'Programme de multiplication matricielle'
10 PRINT*, ' '
PRINT*, 'Voulez-vous :'
PRINT*, '(1)- Entrer A'
PRINT*, '(2)- Entrer B'
PRINT*, '(3)- Afficher A'
PRINT*, '(4)- Afficher B'
PRINT*, '(5)- Calculer A*B'
PRINT*, '(6)- Sortir'
READ*, C
IF (C .EQ. '1') THEN
PRINT*, ' -> A '
CALL LIRE(A)
ELSEIF (C .EQ. '2') THEN
PRINT*, ' -> B '
CALL LIRE(B)
PRINT*, ' A ='
CALL ECRIRE(A)
PRINT*, ' B ='
CALL ECRIRE(B)
PRINT*, ' A*B -> B'
CALL MULTAB(A,B)
STOP
ELSE
PRINT*, 'Ordre non compris'
ENDIF
GO TO 10
END
C
C Procédure de lecture
SUBROUTINE LIRE(D)
REAL D(3,3)
INTEGER I,J
PRINT*, ' Entrez la matrice par ligne'
READ*, ((D(I,J), J=1,3), I=1,3)
RETURN
END
C Procedure d'affichage
SUBROUTINE ECRIRE(D)
REAL D(3,3)
INTEGER I,J
36
DO I=1,3
PRINT*, (D(I,J), J=1,3)
END DO
RETURN
END
C Procedure de multiplication
SUBROUTINE MULTAB(D,E)
REAL D(3,3),E(3,3)
REAL F(3,3)
INTEGER I,J, K
DO I=1,3
DO J=1,3
F(I,J) = 0
DO K=1,3
F(I,J) = F(I,J)+D(I,K)*E(K,J)
END DO
END DO
END DO
CALL TRANS(F,E)
RETURN
END
C Procedure de transfert
C
SUBROUTINE TRANS(D,E)
REAL D(3,3),E(3,3)
INTEGER I,J
DO I=1,3
DO J=1,3
E(I,J) = D(I,J)
END DO
END DO
RETURN
END
7.3. Les fonctions formules

Supposons que nous voulions évaluer la fonction :
G(x)=x2-5x+2
Pour x=1,2,….,20. En utilisant un programme FUNCTION, nous avons :
Programme appelant Sous programme

DO 100 J=1,20 FUNCTION G(X)
VALEUR=G(FLOAT(J)) G=X*X-5.0*X+2.0
WRITE(5,*) J,VALEUR RETERN
100 CONTINUE END
STOP
END
On remarque que le sous-programme FUNCTION consiste d’une simple instruction arithmétique

(à part l’instruction de définition de la fonction, et les instructions RETURN et END). Nous
pouvons simplifier cette sorte de sous-programme FONCTION en écrivant simplement
G(X)=X*X-5.0*X+2.0 au début du programme appelant, de la manière suivante :
37
C DEFINIR LA FONCTION
G(X)=X*X-5.0*X+2.0
C CALCULER LES VALEURS FONCTIONNELLES
C
DO 100 J=1,20
VALEUR=G(FLOAT(J))
WRITE(5,*) J,VALEUR
100 CONTINUE
STOP
END
La fonction G est appelée une fonction arithmétique. Si un programme doit utiliser plusieurs fois
la même expression, cette expression sera écrite une fois en tête du programme.
La syntaxe générale d’une fonction formule est:
NF(pfl, pf2 , …….,pfn) = EAL
Avec:
NF: Nom de Fonction, construit selon les règles des variables.
pf1, pf2 ,pfn : paramètres formels de la fonction; ce sont des variables non indicées.
EAL : Expression Arithmétique ou logique.
Nous devons faire apparaître la définition de la fonction dans le programme avant toute
instruction exécutable.
EXERCICES
1.
Trouver les erreurs dans chacune des instructions des sous-programmes suivants :
(a) FUNCTION, ISUIV(A,B+C,X)
(b) SUBROUTINE NOUV(X Y,Z)
(c) SUBROUTINE (U,V,W)
(d) FUNCTION ADD(X,Y,Z)

Z=X+Y
RETERN
END
2.
Trouver la sortie du programme suivant :
JF(M)=M**2-3*M+4
K=2
L=JF(k+2)
M=JF(L-3*K)+K
WRITE(6,10) K,L,M
10 FORMAT (1X,3(I10,2X))
STOP
END
3.
Définir une fonction instruction qui calcul R = u 2 + v 2 + w 2 et l’utilise pour calculer
x
A= , B = x 2 + y 2 + z 2 , C = 4x 2 + 9 y 2 + 4z 4
x +y +z
2 2 2
38
9 Calcul des moments pour une poutre console

C ce programme est développé pour évaluer les efforts
ctranchants et et les moments fléchissants
c S est la langueur du segment (hauteur d’étage)
c F est la charge concentrée
c T est l'effort tranchant
c B est le moment fléchissant
dimension S(20),F(21),T(21),B(21)
write(6,*)'entrer le nombre de charges concentrées'
read(5,*) n
write(6,*)'entrer les valeurs des charges concentrées'
read(5,*)(F(j),j=1,n)
write(6,*)'entrer la longueur de chaque segment '
read(5,*)(S(i),i=1,n)
T(1)=F(1)
B(1)=0.
do 100 j=2,n
T(j)=F(j)+T(j-1)
B(j)=T(j-1)*S(j-1)+B(j-1)
100 continue
write(6,*)('les valeurs de T sont')
write(6,200)(T(j),j=1,n)
write(6,*)('les valeurs de M sont')
write(6,200)(B(j),j=1,n)
c pour n=5, le frormat suivant est acceptable
200 format(5(1x,f12.4))
STOP 'programme termine'
END
1.
Que donnera en sortie le programme suivant:
c PREMIER PROGRAMME RESOLU
J =1
K=3
L=2*J + K
J=3*J+2*L
K=K+2
L=J+K+L
PRINT*,J,K,L
STOP
END
Ligne 1. L’ordinateur ignore cette instruction puisqu’elle constitue un commentaire.
Ligne 2. L’ordinateur stocke 1 dans une case-mémoire appelée J
Ligne3. L’ordinateur stocke 3 dans une case-mémoire appelée K
Ligne4. L’ordinateur doit calculer 2*J+K, puis stocker le résultat dans une case-mémoire
appelée L. Puisque
2*J + K = 2 1 + 3 = 5
L’ordinateur stocke 5 en L
Ligne 5. L’ordinateur doit calculer 3*J + 2*L en utilisant les valeurs actuelles de J et de L, puis
substituer le résultat à la valeur actuelle de J. Ceci donne
39
3*J + 2*L = 3.1 + 2.5 = 13
L’ordinateur efface, donc, la valeur actuelle de J et la remplace par 13.
Ligne 6. L’ordinateur doit augmenter de 1 la valeur actuelle de K
Ligne 7. L’ordinateur additionne les valeurs actuelles de J, K, et L
J+K+L=13+5+5=23
Il efface alors la valeur actuelle de L et la remplace par 23
Ligne 8. L’ordinateur imprime les valeurs actuelles de J, K et L
13 5 23
Ligne 9. Fin de l'exécution.
40

Batata

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Batata

Enviado por

Direitos autorais:

Formatos disponíveis

Chapitre III Eléments de base du langage FORTRAN

Le langage FORTRAN ( FORmula TRANslator ) à été le premier langage évolué permettant

2. Eléments de base du langage

2.1. Les mots-clé du langage

WRITE, READ, PRINT.

2.2. Mise en place des instructions

2.2.1. Structure d'une ligne FORTRAN

Quand on parle de la programmation structurée on doit passer par 6 étapes:

Deuxième Etape (Partie déclaratif)

Troisième Etape (Partie introduction des données)

Quatrième Etape (Partie de traitement)

Cinquième Etape (Partie d’affichage des résultats).

Sixième Etape (Partie fin du programme).

¾ Le FORTRAN 90 admet également des commentaires en fin de ligne d'instruction. Dans ce

2.2.2. Les identificateurs

3.1.1. Constantes entières : elles s’écrivent avec 1 à N chiffres décimaux (N dépend de

3.2. Les variables

3.2.1. Déclaration des variables

3.2.2. Les variables indicées

4. Opérateurs et fonctions mathématiques

4.2. Opérateurs de comparaison

4.3. Opérateurs logiques

Les opérateurs logiques sont:

4.3. Fonctions mathématique

integer integer real double précision

real real real double précision

double précision double précision double précision double précision

X2 ≥ 0 ou Y<0 (X-Y)2 ≤ l.2

5. Les instructions de FORTRAN

La première instruction d’un programme est l’instruction

5.1. Instruction d’affectation

5.2. L’instruction PARAMETER

5.3. Instruction d’initialisation des variables (DATA)

Nous utilisons DATA comme suit:

5.4. Les instructions D’entrée / Sortie

Le Fortran attribue à chaque périphérique un numéro d'unité logique. Fortran attribue le

5.4.1. L’instruction PRINT

a- Sa syntaxe avec format libre :

b- Sa syntaxe avec format imposé :

5.4.2. L’instruction READ

a- Syntaxe de l’instruction READ avec format libre

b- Syntaxes de l’instruction READ avec format imposé

5.4.3. L’instruction WRITE

a- Sa syntaxe en format libre est :

5.5. Les instructions de test

5.5.1. L’instruction IF arithmétique

ExpArit : expression arithmétique

5.5.2. L’instruction IF logique

5.5.3. L’instruction IF… THEN… ELSE / ENDIF

5.6. Les instructions de branchement

5.6.1. L’instruction de branchement inconditionnel (GOTO)

nl,n2...... ni: étiquettes d’instructions exécutables.

5.7. Les instructions de répétitions (les boucles DO)

5.7.2. La boucle DO...WHILE

5.9. L’instruction d’arrêt de compilation (END)

5.11. L’instruction FORMAT

5.11.1. Les descripteurs de traitement des variables

1. Quelles sont les valeurs de A et B qu’imprimerait ce programme.

3. Dessiner l’organigramme pour les programmes suivants:

7.1. Le sous-programme FUNCTION

[déclaration] FUNCTION nomfct(arg1[,arg2,…,argn])

nomfct ( par1[, par2,…., parn])

7.2. Le sous-programme SUBROUTINE