Université Abdelmalek Essaadi

Faculté des sciences-Tétouan

Département de Physique

Filière master PTR & PMA

Module
Programmation Fortran

Pr. Otman El-hajjaji

[email protected]
Année universitaire 2022/23

1
Introduction
A partir des années 50 du dernier siècle, l’informatique (traitement des informations par
voie automatique) commence à prendre de l’ampleur. La compagnie IBM a publié la
description d’un langage qu’il a nommé FORTRAN (FORmula TRANslator). La première
version FORTRAN І est apparue en 1956, puis avec le fil des années plusieurs versions ont
était développées jusqu’au 1978 où le FORTRAN 77 fait son apparition suivi du Fortran 90.
D’autres versions ont vu le jour après, Fortran 95, Fortran 2000, 2005...

Le langage Fortran reste le langage le plus utilisé par les scientifiques dans les codes de
calcul (par exemple physique des réacteurs). Les dernières versions sont devenues des vrais
langages orientés objet. Dans ce cours nous allons étudier le langage fortran 90.

Structure d’un programme Fortran

Un programme Fortran est une succession d’opérations permettant d’obtenir un résultat
final.

Program nom_du_programme

Déclaration des variables

Instruction

End [Program nom_du_programme]

Remarque : [ ] instruction optionnelle

2
 I. Nom du programme
Le nom du programme est soit un mot soit un nombre de mots alpha numérique (lettres et
chiffres) [somme8], Factoriel, Racine_carre,...

Remarques :

- Dans le cas où le nom comporte un ensemble de mots, l’espace est représenté par
le tiré _. Le nom du programme doit absolument figurer en première ligne.
- Les différents accents ne sont pas acceptés par le compilateur.

Exemple : - Program somme

- Program racine_carre

II. Déclaration des variables

Il existe deux types de variables, les variables simples et les variables indicées
(Tableaux)

II.1 Variables simples

On représente les variables simples à l’aide de leur identificateur (un identificateur est
un nom que le programmeur attribut à une variable).

Un identificateur sert à désigner les différents objets manipulés par le programme : variables,
fonctions, noms de types ... ils sont formés d'une suite de caractères (lettres ou chiffres). Sa
longueur est limitée à 31 caractères.

Exemple : Somme ; 5 caractères.

Le fortran ne différencié pas entre une majuscule et une minuscule. (Somme≡ somme≡
𝑆𝑂𝑀𝑀𝐸).

Cinq types de variables intrinsèques sont utilisés :

3
 Type Signification

Integer Entier

Real Réel
Double precision Double précision
Complex Complexe
Character Chaine de caractère
Logical Variables logiques

Ce sont des variables alphanumériques avec une lettre comme premier caractère. Par
défaut, le langage Fortran traite les lettres de I jusqu’à N comme des entiers les autres lettres
comme des réels. Cette affectation automatique peut être annulée par la commande Implicit
none

Dans ce cas, il faut absolument expliciter le type de la variable au début du programme.

II.1.1 Variable entière (Integer)

La syntaxe de cette déclaration est : Integer :: a,b,c

a, b et c peuvent prendre par exemple les valeurs +123, 0, -548, +99999. Le signe + est
optionnel (on ne l’écrit pas) alors que le signe moins est obligatoire.

II.1.2 Variable réelle (Real)

La syntaxe de déclaration est : Real :: i,y,z

i, y et z peuvent avoir comme valeurs : 0.,-0.9, 123.5, dans le cas des grands nombres la
variable s’écrit 7.23E+5 =7.23105 alors que dans le cas des faibles nombre on écrit

2.0E-03=2.010-3. En fortran la virgule est représentée par un point.

- La mantisse (nombre de chiffres après le point) peut comporter jusqu’à 7 chiffres

significatifs.

- 32 bits (4 octes), 1.210−38 ≤ |𝑥| ≤ 3.41038

N.B : Le point doit être toujours présent dans le cas d’un réel (3.)

4
II.1.3 Double précision (real*8)

La syntaxe est : double precision :: d,e

Pour une variable en double précision, l’exposant commencera alors avec la lettre ″D″
au lieu de ″E″ et peut comporter 3 chiffres. Elle prend un espace mémoire plus important et
le temps de calcul est plus long. Donc il ne faut l’utiliser qu’en cas de besoin

- La mantisse comporte 15 à 16 chiffres significatifs

- 64 bits (8 octes), 2.210−308 ≤ |𝑥 | ≤ 1.810308

Exemple : 1.237456899D+01 ; 2.5D-123

II.1.4 Variable complexe (cmplx (x,y))

La syntaxe est : complex :: z ; z=(20. , -30)

Une variable complexe se présente sous la forme d’un doublet de réels (x,y) placés entre
parenthèse et séparés par une virgule. Le premier réel (x) représente la partie réelle alors que
le deuxième (y) représente la partie imaginaire.

II.1.5 Variable caractère (character)

Elle est formée par une suite de caractères alphanumérique quelconque encadré par une
apostrophe (‘). On utilise cette variable pour composer des messages ou initialiser des
chaines de caractères.

Syntaxe : character (LEN=12) :: Nom

LEN : définit le nombre maximal de caractère. Dans notre exemple la variable Nom doit
avoir au maximum 12 caractères.

Exemple : character (LEN=12) :: Nom

- Nom=’pays’
- Nom=’bonjour-KHADIJA’ n’est pas valide car le nombre de caractères est supérieur
à 12.

5
 II.1.6 Variable logique

Elle permet de déclarer les variables logiques, et elle a deux valeurs : .True. (vrai) ou .False.
(faux). Elles sont utilisées pour effectuer des tests.

Exemple : logical :: converge=.FALSE.

II.2 Variables indicées (tableaux)

Tous les types précédents peuvent (real, integer) être structurés en tableaux avec
l’attribut dimension. Un tableau est un ensemble de variables de même type. On représente
une variable indicée (tableau) par un identificateur suivi d’indice placé entre parenthèse et
séparé par une virgule dans le cas où le nombre est supérieure à 1. La forme déclarative
générale est la suivante :

Type, dimension (indices) :: nom_tableau

Le nombre d’indices dans un tableau varie de 1 à 7. Ces indices sont des constantes ou
variables entières. Les indices du tableau peuvent être positifs ou négatifs.

Exemple:

Integer, dimension (31) :: jour

Real, dimension(10) :: somme
Character(LEN=8), dimension(15) :: mois
Integer, dimension(-2,2) :: dim
Real, dimension(1 : 3,0 : 4,1 : 20) :: tab
character, dimension(1 : 3 , 4 : 6) :: pays

L’accès à chaque composante du tableau se fait de la façon suivante :

mois ( 1 ) = ‘janvier’
tab ( 2 , 3 , 20 ) = 2 . e−5
pays ( 1 , 5 ) = ’ maroc ’

6
 Character (LEN=8), dimension(15) :: mois, spécifie que mois est le nom d’un tableau de 15
éléments.
mois ( 1 ) = ‘janvier’ , spécifie que le premier élément a une valeur = janvier.

III. Affectation des valeurs aux variables

Elle peut se faire de plusieurs façons :

III.1 Affectation simple

Une valeur réelle ou entière peut être attribuée à une variable de la façon suivante.

Variable = valeur

Exemple : Real :: masse

masse = 3.

III.2 Affectation par print et read

La valeur de la variable peut être donnée à partir du clavier par l’instruction :

Print *, ‘Introduire la valeur de x’

Read *, x

III.3 Affectation par Data

Elle permet d’initialiser des variables au début du programme, ces variables sont écrites
entre deux slachs (//)

Exemple : Real :: x,y,z

Data x,y,z /2.,3.,5./

III.4 Affectation par l’attribut : Parameter

L’attribut ‘parameter’ permet de donner une valeur à une variable. Cette valeur ne peut pas
être modifiée dans le programme, sinon une erreur sera déclarée par le compilateur. Cette
instruction est utilisée pour déclarer et protéger les constantes physiques.

7
Exemple: Real, parameter :: pi=3.14159265
N=6.023.1023

Character (LEN=12), parameter :: yes=’yes’

Ces affectations se font aussi aux variables indicées.

III.5 Autres Commandes

Il y a d’autres commandes qu’on utilise pour réaliser un programme. On cite entre autres :

Continuation ″&″

En fortran 90 les lignes ont une longueur maximale de 132 caractères. On peut écrire
plusieurs instructions sur une même ligne à condition de les séparées par un point virgule.
Une instruction peut s’écrire sur plusieurs lignes en utilisant le caractère de continuation
″&″. Une chaine de caractère écrite sur plusieurs lignes doit être précédée par le symbole
″&″ en plus de celui de la ligne précédente.

Exemple : Print*, ‘Dans ce travail la somme &

& doit être positive’, somme

Commentaire ″ ! ″

Pour expliquer le but et la nature du programme et par fois les instructions utilisées on
utilise le symbole ″ ! ″. Ce symbole peut être placé n’importe où dans la ligne (au début, au
milieu). Tous ce qui est à droite du symbole ″ ! ″ est ignoré par le compilateur

Exemple :

! Ce programme calcule la resolution de l’equation du second degre

Delta=b*b-4*a*c ! Discriminant

8
 IV Instructions
IV.1 Opérations
IV.1.1 Opération arithmétique et puissance

En fortran on utilise les opérations +,-, *, / pour réaliser les opérations arithmétiques.

Le symbole ″=″signifie une affectation à une variable donnée (y=2+x). Les puissances
sont indiquées par (**). Elles sont prioritaires sur les multiplications (*) et sur les divisions
(/) et même prioritaire sur l’addition et la soustraction. Par précaution, il faut utiliser les
parenthèses.

Exemple : 3+5*9**4≡3+(5*(9**4))=32808

Remarque : le type de la puissance est : entier (Ex : 9**5)

IV.1.2 Opérations logiques

Elles agissent sur les variables booléennes (proposition vraie ou fausse)

.NOT. Négation. La proposition est vraie si les deux propositions sont fausses.

.AND. Ajouter 2 variables. La proposition est vraie si les deux propositions sont vraies.

.OR. La proposition est vraie si une des deux propositions est vraie.

IV.1.3 Opérations relationnelles

Elles permettent de comparer les variables non logiques mais de même type (deux réels ou
deux entiers, ...)

Expression Signification
> Strictement supérieur à
< Strictement inférieur à
>= Supérieur ou égale à
<= Inférieur ou égale
== Egale à
/= Différent de

9
 IV.2 Les instructions de contrôle

Ce sont des instructions qui permettent de faire des tests où des itérations sur des
variables.

IV.2.1 Test if

C’est un test qui peut porter sur une ou plusieurs conditions.

• Test sur une seule condition

La syntaxe s’écrit : IF (expression logique) Instruction

L’instruction n’est exécutée que si l’expression logique est vraie. Sinon on passe à
l’instruction suivante.

Exemple :

[nom] If (expression logique) then Instructions (s’exécutent si l’expression est vraie)

Else Instructions (s’exécutent si l’expression est fausse)

End if [nom]

 Le nom du test est facultatif, il est utilisé dans le cas où le programme présente
plusieurs tests if.

Exemple:

ln(𝑥)
Soit la fonction f(x)={ 𝑠𝑖 𝑥 > 0
𝑥
1 𝑠𝑖𝑛𝑜𝑛

Faire un programme qui permet d’afficher les valeurs de f(x) pour différentes valeurs de x.

• Test pour plus d’une condition

Dans le cas où on a plusieurs tests à faire, la syntaxe est la suivante :
[Nom] if (expression 1 logique) then
Instructions (s’exécutent si l’expression 1 est vraie)
Else if (expression 2 logique) then

10
 Instructions (s’exécutent si l’expression 1 est fausse et l’expression 2est vraie)
Else
Instructions (s’exécutent si les deux expressions 1 et 2 sont fausses)
End if [Nom]

Remarque : il y’a autant de ″end if″ que de ″if″.

Exemple : Ecrire un programme qui permet d’afficher les valeurs de f(x) pour les différentes
valeurs de x

0 𝑠𝑖 𝑥 < 0 𝑜𝑢 𝑥 > 2
Y= { √𝑥 𝑠𝑖 𝑥 ∈ [0,1]
1 𝑠𝑖 𝑥 > 1

Remarques :

En fortran, parfois un utilise les instructions suivantes :

• GOTO numéro
L’instruction GOTO permet d’aller à la ligne correspondante au numéro de l’étiquette.
• STOP
L’instruction STOP permet d’arrêter l’exécution du programme

IV.2.2 Instruction select case

C’est une instruction qui permet de choisir entre plusieurs choix en fonction de la valeur
d’une expression scalaire de type entier, réel ou caractère.

La syntaxe s’écrit :

[Nom] : select case (expression)

Case (liste 1)

Instruction 1

Case (liste 2)

Instruction 2

End select [nom]

11
IV.2.3 Structure d’itération

a) Boucle finie : DO ↔ END DO

Syntaxe :
Do variable = Vmin, Vmax [, pas]
Instruction
End do

La variable est de type entier. La boucle s’arrête une fois la variable est supérieure à
Vmax. Par défaut le pas est égal à 1, il peut être positif ou négatif

Boucle conditionnelle Do while ↔ end do

Syntaxe :
Do while (Instruction logique)
Instruction
End do

Les itérations s’arrêtent une fois la condition n’est pas satisfaite.

b) Boucle infinie
Ce sont des boucles sans contrôles, on sort de la boucle avec l’instruction exit.
Syntaxe :
[Nom] do
Instructions
If (condition) then
Exit [nom]
End If
Instructions
I=i+1
End do [nom]

Remarque: l’instruction (exit) peut être utilisée pour tous les types de boucle.

12
 c) Boucle imbriquée (multiple)

Il se trouve parfois qu’on a affaire à un calcul qui nécessite deux boucles (ou plus) une
dans l’autre. La boucle interne est exécutée en premier.

Exemple: résultat:

Do I=3, 5 3, 5
Do J=5, 7 3, 6
Print*, I, J 3, 7
End do 4, 5
End

Do Do J=5, 7 5,3
I=3, 5 5,4
Print*, I, J 5,5
End do 6,3
End 6,4
…

IV.3 Organigramme d’un programme

Un organigramme permet une représentation facile du programme. Les opérations dans

un organigramme sont représentées par des symboles de formes bien normalisées. Ces
symboles sont reliés entre eux par des lignes fléchées qui indiquent le chemin, on a :

13
 Symboles Leur rôle

Utilisé pour les calculs

Utilisé pour la lecture et

l’affichage

Utilisé pour le début et la fin

Utilisé pour représenter des tests

V. Les Entrées / Sorties

On appelle Entrée/Sortie, le transfert d’information entre la mémoire de l’ordinateur et

les unités périphériques (clavier, écran, disck dur, ….) les instructions d’entrée et de sortie
sont respectivement : read (lire), print(écrire), write. On distinct deux formes
d’entrées/sorties : Forme libre : appelé aussi format standard et Format avec spécification
précise. Ces deux formats peuvent être utilisés quand on fait l’entrée/sortie sur un fichier.

V.1 Format libre

Dans ce format la syntaxe de l’écriture : print*, write(*,*).

Les données sont affichées sur l’écran sous forme de caractères ou de valeurs numériques.

Exemple : print*, ‘Donner la valeur de x’

Print*, ‘la valeur de y est ‘ , y

La syntaxe de lecture est : read*, read(*,*).

Les données sont communiquées à l’aide de clavier.

Exemple : read*, a,b,c

Ces syntaxes peuvent aussi être utilisées quand il s’agit de l’écriture et de la lecture dans un
fichier. Le fichier est généralement nommé nom_de_fichier.txt, .dat, .out,…

14
 La syntaxe est : open (unit=nombre entier, file=’factoriel.txt’)

(Forme compacte ; forme la plus utilisée)

*Open (unit=nombre entier, file=’factoriel .txt, status=new(ou old))

• Old : le fichier existe déjà
• New : fichier à créer
 Forme option
Les nombres 5 et 6 sont réservés respectivement au clavier et à l’écran.

Exemple :
Open (unit=2,file=’resultat.txt’)
Write (2,*) ‘la valeur est’, x
Close (2) : fermeture de fichier

V.2 Format référencié

Dans ce cas, le format est fixé par l’opérateur via l’instruction ‘format’. Ce format est une
instruction qui se trouve dans une ligne avec une étiquette. Format est valable pour la lecture
et l’écriture (c'est-à-dire même forme).

write(2,10) a,b,c
10 format(2X, ‘(liste des descripteurs)’)
Write(2,‘(liste des descripteurs)’)a,b,c, (voir page Format d’entrée/sortie)
Exemple :
Program Format_Entree_sortie
Implicit none
Real :: a,b,c,delta
Print *, 'Introduire les valeurs de a, b et c '
Read (*, *) a,b,c
delta = b**2-4*a*c !Calcul du discriminent
print *, 'delta =', delta
Open(unit=3,file='test.txt') !Ouverture du fichier

15
 Write(*,10)delta !Ecriture sur ecran
Write(*,fmt='(2X,''La valeur de delta est :''F10.5)')delta
Write(*,'(2X,''La valeur de delta est :''F10.5)')delta
Write(3,10)delta ! Ecriture dans le fichier test.txt
Close(3) ! Fermeture du fichier
10 format (2X,'La valeur de delta est :'F10.5)
end
V.3 Lecture et écriture des tableaux (Voir II.2)

On peut remplir, lire et écrire des tableaux de plusieurs façons :

• Instruction data
Real dimension (5) :: a
Data a/3.,2.,3.,6.,5./
• Real dimension (5) :: a=/1.,2.,3.,4.,5./

• A partir d’une boucle

Real dimension (5) :: a
Do i=1,5
a(i+1)=a(i)+i
Enddo

• A partir d’un fichier

Open (unit=3,file= ‘données.txt’)

1. 10.
Do i=1,5 2. 20.
3. 30.
Read(3,*)a(i),b(i) 4. 40.
5. 50.
Enddo
Close (3)

16
 Interpolation
Soit une fonction f dont les valeurs pour x=a et x=b sont f(a) et f(b).
f(x)=a1x+b1 et soit x=c un point compris entre a et b
𝑓(𝑎) = a1 a + b1 𝑓(𝑎)−𝑓(𝑏) 𝑓(𝑎)−𝑓(𝑏)
{ ➔ a1= et b1=f(a)- a
𝑓 (𝑏) = a1 b + b1 𝑎−𝑏 𝑎−𝑏

𝑓(𝑎)−𝑓(𝑏) 𝑓(𝑎)−𝑓(𝑏)
 f(x)= x+f(a)- a
𝑎−𝑏 𝑎−𝑏

𝑓(𝑎)−𝑓(𝑏)
= (x-a)+f(a)
𝑎−𝑏
La valeur de l’inconnue f(c) est déterminée par :

𝑓(𝑎)−𝑓(𝑏)
f(c) = (c-a)+f(a)
𝑎−𝑏

VI. Function et subroutine

VI.1 Function (fonction)

Function est un petit programme à l’extérieur du programme principal.

Program Calcul program Calcul
- -
- -
- -
Appel à la fonction Appel à la fonction
End contains
Type function Real function
- -
- -
Fonction
End End

Type function (arg1, arg2,….)

A l’intérieur de la fonction on doit avoir une instruction de type nom_fonction=expression

NB :

17
• le nom de la fonction ne doit pas figurer à la droite de l’expression.
• Toutes les instructions utilisées dans le programme principal peuvent l’être dans la
fonction.

Syntaxe
Type function nom_fonction(arg1, arg2,….)

Implicit none

Déclaration des variables

Instruction

End function

VI.2 Subroutine (sous-programme)

Il arrive parfois qu’on doit faire une même opération plusieurs fois dans le même
programme, subroutine permet de décomposer le programme principal sous forme de block.
Le sous-programme est appelé de programme principal par la syntaxe :

Call nom-subroutine (arg1, arg2,…)

o Syntaxe :
Subroutine nom-subroutine (arg1, arg2,…)
Implicit none
Déclaration des variables
Instruction
Return
End [subroutine]

L’instruction ″return″ fait retourner le programme à la ligne qui suit l’appel de la

subroutine. Les variables utilisées seulement dans le sous programme sont déclarées dans
ce dernier. Même chose pour le programme principal. Il est souhaitable de préciser, dans la
fonction et le sous programme, la déclaration des attributs suivants :

• Type Intent (in) : A, B, C : Déclaration des variables d’entrée.

18
 • Type Intent (out) : D, E, F : Déclaration des arguments de sortie.
• Type Intent (inout) : E, F : pour les arguments mixtes

Si le sous programme ne nécessite pas l’argument, on écrit seulement nom-subroutine ()

Dans ce cas, l’appel de la subroutine se fait par : call nom-subroutine ()

19