UNIVERSITE HASSANII-MOHAMMADIA

FACULTE DES SIENCES BEN M’SIK

DEPARTEMENT DE PHYSIQUE
CASABLANCA.

Mastère Matière et Rayonnement

Module
Simulation/Programmation

*********************************

PROGRAMMATION EN LANGAGE FORTRAN

**********************************

Prof: LAHCEN ELARROUM

Année 2006/2007

FORTRAN Pr . LAHCEN EL ARROUM 1

I- MICRORDINAREURS ET LANGAGES DE PROGRAMMATION
1) MICRORDINATEUR (schémas simple) :

EPROM RAM

µP

I/O

Périphériques :
Clavier ;
HD ;
Ecran ;

µP : Traite l’information logique (codée 0 ou 1) ;

EPROM : Contient le Programme système (BIOS);
RAM : Contient les Programmes et donnée de l’utilisateur ;
I/O : Circuits ou cartes d’interfaces.
Remarque : (Hardware : matériel et Software : logiciel).

2) Les informations traitées par le microprocesseur :

Ce sont des mots binaires. Il y’a deux types :

a) Mots adresses (101110000101011) : numéro d’une case mémoire;

b) Mots adressés :

* Instructions (code opération|code opérande) :( 01 | 110101);

* Données (opérande ou résultat d’une opération) (01001011) .

Le langage de bas niveau « compris par l’ordinateur » est le langage machine (binaire).
Le nombre de bits constituant un mot (4, 8,16, 32, 64 ou 128) dépend du microprocesseur.

FORTRAN Pr . LAHCEN EL ARROUM 2

3)Langages évolués :
C’est difficile et fastidieux d’écrire un programme en langage machine, même pour un
spécialiste. Dou la nécessité d’avoir des langages proches à l’utilisateur appelés « langages
évolués »
( FORTRAN,BASIC, PASCAL, C, …..).

4) Code source et code objet :

Les instructions codées en langage évolué (le code source) constituent le programme source.
Les instructions codées en langage machine (le code objet) constituent le programme objet.
Un programme source doit être traduit en programme objet. Ceci peut-être fait
automatiquement par le micro-ordinateur, piloté par
un programme de traduction.

Il existe deux types de traducteurs :

a) Les interpréteurs :
ils pilotent la traduction d’une instruction , du code source au code objet, puis il laissent le
microprocesseur exécuter le code machine obtenu. Ensuite ils recommencent pour
l’instruction suivante ( Le BASIC est un langage interprété).
b) Les compilateurs :
Il pilotent la traduction de la totalité du code source en code objet puis ils libèrent la machine
qui peut être alors autorisée à exécuter le code machine obtenu ( Le FORTRAN est un
langage compilé).

4) Débugger :
C’est un utilitaire permettant de contrôler l’exécution d’un programme et d’effectuer sa mise
au point.

5) L’analyse d’un problème :

Un ordinateur ne sait pas résoudre votre problème. Mais il peut le faire à votre place à
condition de lui ordonné de le faire en lui montrant comment par un langage de
programmation (fortran, C++,…).

Exemple : Résoudre : ax2+bx+c=0.

a) Algorithme :
Calculer delta (∆) ;

−b
Si ∆=0 alors on a une racine double ( x1 = x 2 = );
2a
−b± ∆
Si ∆>0 alors on a deux racines distinctes ( x 1, 2
= );
2a

Si ∆<0 alors il n’y a pas de solution dans R.

FORTRAN Pr . LAHCEN EL ARROUM 3

b) Organigramme :
C’est une représentation très détaillée d’une analyse. Ci-dessous on donne les éléments de
base d’un organigramme :

Début ou fin TRAITEMENT

SORTIE
TEST

Organigramme de résolution d’une équation du 2emeordre.

FORTRAN Pr . LAHCEN EL ARROUM 4

II- LANGAGE FORTRAN

1)HISTORIQUE:

Le FORTRAN (FORmula TRANslateur : Traduction des formules), Créé par IBM en 1954
pour l’écriture de programme Scientifiques, est encore le plus utilisé :
*Plus ancien des langages scientifiques ce qui a donne un cumule de millions de lignes de
programmes impossibles à réécrire rapidement .
*L’évolution du langage lui même( en fonction de l’évolution matériel et des besoin plusieurs
version normalisées sont développés : American National Standars Institute (ANSI) a
développé le FORTRAN 66 (1968) puis le FORTRAN 77 (1978). ISO a développé
FORTRAN 90 (1992) actuellement on a le Fortran 95 et 2000.

2) Généralités sur le langage Fortran

2-1 Mise en page d'un programme
Le contenu des lignes en Fortran doit respecter les quelques règles suivantes :
Une ligne en FORTRAN77 ne peut contenir qu'au maximum 80 caractères.
• Une ligne de commentaire doit commencer par un c ou une * en première colonne.
• Tout ce qui suit un ! dans une ligne est aussi considéré comme un commentaire.
• Les instructions :
• doivent commencer à partir de la colonne 7 (ou plus) ;
• ne doivent pas dépasser la colonne 72.
• Les Labels (ou étiquettes) sont entre les colonnes 1 et 5 ; ce sont des numéros (de 1 à
99999) attribués aux lignes du programme pour pouvoir y accéder directement via des
fonctions de déplacement dans le programme.

Pour couper une instruction sur plusieurs lignes, on met un caractère quelconque (excepté
« 0 ») en colonne 6 des lignes de suite.

Le champ (de 73 à 80) n'est pas interprété par le compilateur FORTRAN 77. Il permet de
commenter une ligne de commande.
La figure 2.1 illustre ces règles.

FORTRAN Pr . LAHCEN EL ARROUM 5

Figure 2.1: Exemples de contenu de lignes en Fortran
Ce « Format fixe »:
Zone étiquette (Colonnes 1 à 5)
Zone instruction (colonnes 7 à 72)
Colonne suite (colonne 6)
n’est pas obligatoire en fortran90 et plus . Il est considéré maintenant comme obsolète . Pour
ces version on utilise le « format libre »: Dans le mode « format libre » les lignes peuvent
être de longueur quelconque à concurrence de 132 caractères.
Il est également possible de coder plusieurs instructions sur une même ligne en les séparant
avec le caractère « ; ».
Exemple print*, ‘entrez une valeur : ‘
read*,n
peut s’écrire
print*, ‘entrez une valeur : ‘ ; read*,n

En format fixe les lignes qui commencent par C,c, * ou ! En colonne 1 sont des
commentaires. Par contre en format libre seul le caractère « ! » rencontré sur une ligne
indique que ce qui suit est un commentaire. Lorsque le 1er caractère non blanc d’une ligne est
le caractère « ! » , la ligne en question est une ligne complète de commentaire
Exemple: if (n < 100 .or. n > 199) ! Test cas d'erreur
....
! On lit l'exposant
read *,x
! On lit la base
read *,y
if (y <= 0) then ! Test cas d'erreur
print *,' La base doit être un nombre >0'
else
z = y**x ! On calcule la puissance

FORTRAN Pr . LAHCEN EL ARROUM 6

 end if
Remarque:

Le fortran 77 est contenu dans le fortan90. C’est un format fixe du fortran90.

L’extension du format fixe est .for ou .f

Ex.for Exple1.f Exple2.for

L’extension du format libre .f90

Exple3.f90

2-2 Organisation d'un programme FORTRAN

Un programme fortran est une succession de « pavés » élémentaires qu'on
appellera blocs fonctionnels. Il en existe 3 sortes :
1. Le programme principal inclus entre program (facultatif) et end

program nom
...
end

2. Les subroutines inclus entre subroutine et end

subroutine nom (arguments)

...
end

3. Les fonctions inclus entre function et end

type function nom (arguments)

...
end

Programme principal
Le programme principal est obligatoirement présent. Il n'existe qu'un seul programme
principal. Qui se devise en en deux parties distinctes:
a) Partie déclaration :
C'est dans cette partie qu'on définit les objets (type + nom) qui seront manipuler par le
programme.
b) Partie instructions.

Remarque: L'exécution d'un programme FORTRAN consiste à dérouler dans l'ordre toutes
les instructions de la partie exécutable du programme principal. Certaines instructions

FORTRAN Pr . LAHCEN EL ARROUM 7

déroutent le pointeur de programme vers d'autres blocs fonctionnels (subroutines ou
fonctions)
3) Les données
3-1 Les différents types de données
Le tableau 3.1 résume l'ensemble des types de données manipulables en Fortran.:

Grandeur Nature de la grandeur Type en fortran

Grandeurs numériques Entière integer

Réels real
double precision

Complexes complex

Caractéres Character

Grandeurs logiques (vraies ou Logical

fausse)

a) Type integer

Un integer contient un entier. Il est représenté par son écriture en base 2 signée sur 4 octets
(31 bits pour la valeur plus un bit pour le signe). Ses valeurs possibles sont dans l'intervalle
[-231,231-1]. Soit dans l’intervalle [-2147483648, 2147483647].

b) Type real
un real contient un nombre réel. Il est codé en virgule flottante (floating « virgule mobile »)
sur 4 octets . Chaque nombre est représenté sous la forme x=±0.mx2e où m est la mantisse
codée sur 23 bits et e est l'exposant, codé sur 8 bits ( -127 < e < 128). Les valeurs (en valeur
absolue) sont comprises dans l'intervalle [1.401x10-45,3.403x1038] et il stocke environ 7
chiffres significatifs.

c) Type double precision

Le double precision est un real plus précis, codé en virgule flottante sur 8 octets dont une
mantisse codée sur 52 bits et un exposant codé sur 11 bits ( -1023 < e < 1024).
Les valeurs (en valeur absolue) sont comprises entre[ 4.941x10-324,1.798x10308] avec 15
chiffres significatifs.

d)Type complex :
Assemblage de 2 real dans un même objet.

FORTRAN Pr . LAHCEN EL ARROUM 8

3-2 Constantes numériques

a) Constantes integer
Une constante de type integer est écrite sans point décimal.
Exemples : 1 123 -28 0

b) Constantes real
Une constante de type real doit obligatoirement comporter : soit le point décimal, même s'il
n'y a pas de chiffres après la virgule ; soit le caractère e pour la notation en virgule flottante.
Pour les nombres écrits 0.xxxxx, on peut omettre le 0 avant le point décimal.

Exemples : 0. 1.0 1. 3.1415 31415e-4 1.6e-19 1e12 .001 -36.

c) Constantes double précision

Une constante double précision doit obligatoirement être écrite en virgule flottante, le e étant
remplacé par un d.

Exemples : 0d0 0.d0 1.d0 1d0 3.1415d0

31415d-4 1.6d-19 1d12 -36.d0

d) Constantes complex
Une constante de type complex est obtenue en combinant deux constantes réelles entre
parenthèses séparées par une virgule. 2.5+i s'écrira (2.5,1.)

Exemples : (0.,0.) (1.,-1.) (1.34e-7, 4.89e-8) (1.d2,-2.d3)

e) Constantes chaînes de caractères:

C’est une suite de caractères encadrée par les délimiteur ’ ou ". Si par mis cette suite il y a un
délimiteur, alors celui-ci doit être doublé.
Exemple:
‘Bonjour’
‛l’ensemble’ ou l’’ensemble’ doit être "L’ensemble"

3-3 Définition de constantes symboliques

Elles permettent de référencer une constante à l'aide d'un symbole.
Elles ne peuvent être modifiées au milieu du programme et sont affectées une fois pour toutes
avec le mot-clé parameter dans la section déclarations.

Syntaxe parameter(const1=valeur1,const2=valeur2, ...)

Le type de chaque constante doit être déclaré explicitement ou en suivant les mêmes règles de
typage automatique que les variables (cf 4.3). Une constante est toujours locale à un bloc
fonctionnel.

Exemple

FORTRAN Pr . LAHCEN EL ARROUM 9

double precision q
parameter(max=1000, q=1.6d-19)

4) Les variables
Une variable est un emplacement en mémoire référencé par un nom, dans lequel on peut lire
et écrire des valeurs au cours du programme. Les variables permettent (entre autres) de :
Manipuler des symboles ;
Programmer des formules.

Avant d'utiliser une variable, il faut :

Définir son type ;
Lui donner un nom.

C'est la déclaration. Elle doit être écrite dans la première partie (la partie déclaration) d'un
bloc fonctionnel (programme principal, subroutine ou fonction) dans lequel intervient la
variable.
Dans les langages modernes, toute variable doit être déclarée.
En FORTRAN, il y a des exceptions obéissant à des règles bien précises

Une variable est par défaut locale : seul le bloc fonctionnel où elle est déclarée peut y accéder.
Elle est globale si tous les blocs fonctionnels peuvent y accéder.
Pour rendre une variable globale on utilise l'instruction common voir le paragraphe (10.6).

4-1-Déclaration de variables :
Dans le programme principal, On déclare une variable entre le mot-clé Program et la
première instruction exécutable.
Dans un sous programme, on la déclare entre le mot-clé Subroutine et la première instruction
exécutable.
Dans une fonction, la déclaration se fait entre le mot clé Function et la première instruction
exécutable

Syntaxe :
type var1, var2, var3, .....
ou
type::var1,var2,var3… (obligatoire lors d’initialisation : Real:: x=102.58)
On peut déclarer plusieurs variables du même type sur une même ligne.

Exemple
integer i,j,k integer:: i,j,k
real alpha, beta ou real ::alpha, beta
double precision x,y double precision:: x,y
complex z complex ::z

4-2-Noms des variables

Pour nommer une variable, il faut respecter les règles suivantes :
Caractères autorisés : toutes les lettres, tous les chiffres, le caractère « blanc » (déconseillé), le
caractère « _ » ;
Le premier caractère doit être une lettre ;
Seuls les 6 premiers caractères sont significatifs : epsilon1 et epsilon2 représentent la même
variable ;

FORTRAN Pr . LAHCEN EL ARROUM 10

(Rappel) en fortran, il n’y a pas de différence entre minuscules et majuscules :
DOUBLE PRECISION :: X,Y et double precision :: x,y représentent la même chose en
fortran
4-3-Règles de typage implicite :
On peut ne pas déclarer une variable (fortement déconseillé), en utilisant les règles suivantes :
Une variable dont le nom commence par i,j,k,l,m,n est automatiquement de type integer. Une
variable commençant par toute autre lettre (de a à h et de o à z) est automatiquement de type
real.

Directive implicit :
Elle permet modifier ces règles par défaut de typage de manière locale à un bloc fonctionnel..

Syntaxe:

implicit type (lettre1-lettre2, lettre3, ....) Toute variable commençant par une lettre comprise
entre lettre1 et lettre2 ou par lettre3 sera par défaut du type indiqué

Exemples

implicit real (a-c,e,w-z) : Tout ce qui commence par a,b,c,e,w,x,y,z sera real

implicit double precision (a-h,o-z) : tout ce qui commence par i,j,k,l,m,n sera integer, tout
le reste double precision (Très Utilisé ).

implicit complex (z): Tout ce qui commence par z est complex par défaut.

implicit none : Aucune variable n'est utilisable si elle n'est pas déclarée.

Remarque: La déclaration d'une variable l'emporte sur les règles implicites.

4-4-Affectation d'une variable :

Syntaxe :
nomvar = constante Exemple : x=1.23
nomvar = autre variable Exemple : x=y
nomvar = opération Exemple : x=y+3.2*z

Fonctionnement :
Lit la valeur de toutes les variables à droite du signe = ;
Effectue les opérations demandées ;
Affecte le résultat à la variable à gauche de =.

Exemple : i = i + 1
Augmente le contenu de la variable i de 1 (on dit aussi « incrémenter » une variable).

FORTRAN Pr . LAHCEN EL ARROUM 11

5- Opérateurs et expressions:
5-1-Opérateurs arithmétiques

opérateur Operating

+ Addition (opérateur binaire)

+ Identité (opérateur unaire)

- Soustraction (opérateur binaire)

- Opposé (opérateur unaire)

* multiplication

/ division

** puissance

5-2-Les expressions :

Règle d’usage interprétation

O1 + O2 Ajouter O2 à O1

+O1 Égale à O1

O1 - O2 Soustrait O2 à O1
-O1 Inverse le signe de O1
O1 * O2 Multiplie O2 par O1

O1 / O2 O1 devisé par O2

O1 ** O2 Élève O1 à la puissance O2

O1 et O2 sont deux opérandes

Les opérandes O1 et O2 peuvent êtres:

Une constante numérique,
Une variable numérique, précédée ou non d’un opérateur unaire ( + ou -)
Une expression arithmétique entre parenthèses.
Dans une expression, l’ordre dont lequel sont effectués les opération en fortran est: ** ,
/, *, et enfin + et -.
On peut aussi grouper des sous expressions entre parenthèses.

FORTRAN Pr . LAHCEN EL ARROUM 12

 a+b
Exemples x=a+b/c-d évalue b et x=(a+b)/(c+d) évalue
a+ −d c+d
c
5-3-Conversion de type dans une opération :
Lorsque deux opérandes de types différents interviennent de chaque coté d'un opérateur :
1. l'opérande de type le plus faible est converti dans le type de l'autre opérande
2. l'opération est effectuée, et le type du résultat est le type le plus fort
Les types sont classés dans l'ordre suivant (du plus fort au plus faible) :
complex
double precision
real
integer
logical

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 precision, le résultat de b**2-4*a*c sera double precision,
mais attention, le produit a*c sera effectué en simple précision, d'où une perte de précision
possible.

Pièges classiques
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.
Idem pour i/j où i et j sont deux variables integer. Écrire : real(i)/j

5-4-Conversion de type dans une affectation

Lorsqu'une variable est affectée avec une expression de type différent, le résultat de
l'expression est converti dans le type de la variable.
Exemples
i=1.3456 affectera la variable integer i avec 1.
Attention :
x=2/3 affectera la variable real x avec 0.0 !!!

5-5-Opérateurs relationnels:
Opérateurs Opérations

.LT. Ou < Strictement plus petit Ces opérateurs admettent des opérande de
type integer , real ou character.

.LE. Ou <= Inférieur ou égal Seul les opérateurs == , /= peuvent

s’appliqués à des expressions de type
.EQ. Ou == égal complex

.NE. Ou /= Non égal

. GT. Ou > Strictement plus grand

FORTRAN Pr . LAHCEN EL ARROUM 13

.GE. Ou >= Supérieur ou égal

5-6- Opérateurs logiques:

opérateur opération

.NOT. Négation logique Les opérandes doivent être des expression de type logical

.AND. Conjonction logique

.OR. Disjonction inclusive

.EQV. Equivalence logique

.NEQV. Non équivalence logique

5-6-1- Tables de vérité:

Opérateur négation .NOT.

L .NOT.L
L : Variable logique (type logical)
.TRUE .FALS.
.FALS. .TRUE.

Les autres opérateurs:

L1 L2 L1.AND.L2 L1.OR.L2 L1.EQV.L2 L1.NEQV.L2

.false. .false. .false. .false. .true. .false.
false. .true. false. .true. .false. .true.

.true. false. false. .true. .false. .true.

.true. .true. .true. .true. .true. .false.

Logique positive, on adopte le codage suivant : .false. = 0 et .true.=1

L1 L2 L1.AND.L2 L1.OR.L2 L1.EQV.L2 L1.NEQV.L2

0 0 0 0 1 0
0 1 0 1 0 1
1 0 0 1 0 1
1 1 1 1 1 0

FORTRAN Pr . LAHCEN EL ARROUM 14

5-7-Opérateur de concaténation // :
L’opérateur de concaténation n’admet que des expressions de type character

Expression Interprétation
C1 // C2 Concatène C1 avec C2 C1 et C2 sont deux chaînes de caractères

Exemple:
‘BON’ // ‘jour’ donne ‘BONJOUR’
Character (len=10):: C1=‘BON’
C1=C1//’JOUR’ ! INVALIDE
C1=TRIM(C1)//’JOUR’ ! VALIDE

5-8-Fonctions mathématiques:
Une fonction FORTRAN est une boite dans laquelle rentre un ensemble de grandeurs d'un
type donné (les arguments) et de laquelle sort une grandeur d'un type donné (cf 10.4).
Certaines fonctions mathématiques sont prédéfinies dans le langage (tables 5.8.1 et 5.8.2). On
n'utilisera pas la même fonction selon le type de l'argument. Par exemple la fonction sinus
sera SIN pour un argument réel, DSIN pour un argument double precision, CSIN pour un
argument complexe.
Important :
Le ou les arguments d'une fonction sont toujours entre parenthèses.
Chaque fonction a son domaine de définition. Son non-respect entraîne une erreur
d'exécution, c'est-à-dire que le programme s'arrête.
Exemples
z=(a*sin(x)+b*cos(y)) / (a*sinh(x)+b*cosh(y))
Pour définir p en double precision :
pi=4d0*datan(1d0)

Tableau 5.8.1: Fonctions arithmétiques prédéfinies.

real double precision complex Fonction

SIN DSIN CSIN sin(x)

COS DCOS CCOS cos(x)
TAN DTAN tg(x)
ASIN DASIN arcsin(x)
ACOS DACOS arccos(x)
ATAN DATAN arctg(x)
SINH DSINH sh(x)
….. …… ……..
LOG10 DLOG10 log10(x)
LOG DLOG CLOG ln(x)

FORTRAN Pr . LAHCEN EL ARROUM 15

 EXP DEXP CEXP exp(x)
SQRT DSQRT x
Tableau 5.8.2: Fonctions diverses prédéfinies.
integer real double precision complex Fonction
MAX0 AMAX1 DMAX1 max(x,y)
MIN0 AMIN1 DMIN1 min(x,y)
IABS ABS DABS CABS |x| ou |z|
INT AINT DINT Partie entière
Reste dans la division
MOD AMOD DMOD
entière

5-9-Fonctions de conversion
Ces fonctions permettent de convertir explicitement des données d'un type en un autre type.
La figure 5.9.1 donne les noms des différentes fonctions permettant à partir d'un type initial
d'obtenir un autre type de valeur.

Figure 5.9.1: Fonctions de conversion de types.

6-Entrées / Sorties
On appelle « Entrées / Sorties », tout ce qui permet à un programme de dialoguer avec
l'extérieur :
• l'utilisateur via le clavier, l'écran, une imprimante, etc. ;
• les disques via des fichiers ;
• d'autres machines via le réseau ;
• ...
Le langage FORTRAN permet d'écrire ou de lire des données sur différentes choses.
Pour écrire, on utilise l'instruction write :
• à l'écran ,
• sur un fichier,
• dans une chaîne de caractères.
Pour lire, on utilise l'instruction read :
• sur le clavier,
• dans un fichier.
• dans une chaîne de caractères.

On distingue les lectures/écritures : formatées et non-formatées

6-1- Écriture formatée
a) Syntaxe :
write(unité d'écriture, formatage) liste de données

FORTRAN Pr . LAHCEN EL ARROUM 16

L'unité d'écriture est un entier (voir « fichiers » ). Pour l'écran, on utilise *.
Le formatage indique sous quelle forme on va écrire les données. Il existe un formatage par
défaut qui laisse FORTRAN écrire comme il veut : le format libre * .
b) Format *

Exemples
write(*,*) i,j,x,y :écrit les valeurs des variables i,j,x,y sur une ligne, séparées par des blancs.
write(*,*) 'z vaut',z :écrit la chaîne « z vaut », suivie de la valeur de la variable z.
Important : se souvenir qu'une instruction write écrit une ligne puis revient à la ligne. Donc
un write est égal à une ligne d'affichage.

6-2-Formats d'écriture
Un format est une série de codes, chaque code définissant le format d'écriture d'un élément
d'une donnée.

a) Définition du format

Deux solutions :
Directement dans l'instruction write avec une chaîne de caractères :

write(*,'format') liste

Dans une ligne labellée contenant l'instruction format :

nn format(définition du format)
write(*,nn)

Cette solution permet d'utiliser le même format dans plusieurs instructions write.

b) Format entier
Dans un format, la notation in permet d'afficher un entier. L'entier est écrit sur n caractères en
tout : S'il y a besoin de plus, l'écriture échoue.
Si cela suffit, on ajoute éventuellement des blancs à gauche.

Exemples :

i=11 10 format(i6,i6)
j=20312 i=11
write(*,'(i6,i6)') i,j ou j=20312
write(*,10) i,j

donne:

FORTRAN Pr . LAHCEN EL ARROUM 17

C) Format réel virgule flottante
Dans un format, la notation en.m permet d'afficher un réel en virgule flottante sur n caractères
en tout avec m chiffres significatifs, c'est à dire :
S'il y a besoin de plus, l'écriture échoue.
Si cela suffit, on ajoute éventuellement des blancs à gauche.

Pour que le format soit cohérent, il faut n > m + 7

Exemples :
x=-1456.2
y=1.6e-19
write(*,'(e14.5,e14.5)') x,y

Affiche
Pour x

Suivit pour y de

d) Format chaîne:
Dans un format, la notation an permet d'afficher une chaîne de caractères.
Si n est spécifié, la chaîne est écrite sur n caractères en tout, en ajoutant des blancs à gauche
pour compléter.
Si n n'est pas spécifié,
la chaîne est écrite avec son nombre de caractères total (tel que déclaré!).
.
Exemples de formats mixtes

i=36
px=-1456.2
write(*,'(a,i4,a,e12.5)') 'i vaut', i, ' et x vaut', px

affichera
i vaut 36 et x vaut -0.14562E+04

Les formatages doivent être utilisés si c'est absolument nécessaire. Dans la plupart des cas le
format par défaut (*) suffit largement, et il est inutile de perdre du temps a formater les sorties
écran.

FORTRAN Pr . LAHCEN EL ARROUM 18

6-3-Lecture formatée:
La lecture formatée s'applique
au clavier aux fichiers texte

a) Principe
On lit une ligne de caractères d'un seul coup, la lecture étant validée par :
la frappe de la touche RETURN pour une lecture clavier,
une fin de ligne pour une lecture de fichier texte.
Les données sur une même ligne doivent être séparées par des blancs.

b)Syntaxe
read(unité de lecture, formatage) liste de variables
L'unité de lecture est un entier (voir « fichiers » ). Pour le clavier, on utilise *.
Le formatage indique sous quelle forme on va lire les données
(voir write).
c)Conseil
Le plus simple est d'utiliser tout le temps le format libre *. Exception: pour lire des variables
caractères ou chaînes de caractères, le format libre ne fonctionne pas.
Utiliser le format chaîne a.
c) Example
real a,b,c
read(*,*) a,b,c

attend de l'utilisateur qu'il frappe trois réels au clavier séparés par des espaces puis la touche
RETURN ( ). On peut entrer les nombres en format virgule flottante.

Pour entrer (1,2) dans a, (1,6.10-19) dans b et (32) dans c, l'utilisateur pourra taper :
1.2 1.6e-19 32
Un exemple classique d'écriture suivie d'une lecture sur la même ligne :

write(*,'(a,$)') 'Entrez x :'

read(*,*) x

Le message sera affiché, mais le curseur ne reviendra à la ligne que lorsque l'utilisateur aura
entré x suivi de RETURN. Programme:
write(*,'(a,$)')'Entrez x :'
read(*,*)x
print*,x
end

FORTRAN Pr . LAHCEN EL ARROUM 19

7-Contrôle de l'exécution:
Un programme enchaîne les instructions qu'on lui donne une à une dans l'ordre. Pour réaliser
un vrai programme, il faut tout de même disposer de moyens pour faire des tests et des
boucles : on appelle cela le contrôle d'exécution.

7-1-Instructions conditionnelles
a) Objectif
Exécuter une séquence d'instructions si une condition logique est vérifiée, sinon en exécuter
une autre.

b) Syntaxes et exemples :

*Pour exécuter une série d'instructions uniquement si une condition logique est vraie :

syntaxe :
if (condition logique) then Programme :
…. ...
endif
x=12.5;y=8.
If(x>=y)then
Print*,’x=’,x,’et’,’y=’,y
endif
end
Puisque la condition logique est vraie, le programme ci-contre affichera sur l’écran
x=12.500000 et y= 8.000000

On peut aussi spécifier une autre série d'instructions à exécuter si la condition logique est
fausse :
Programme:
Syntaxe : a=5;b=6
if (condition logique) then D=b**2-4*a*c
...... If(D>=0)then
else Print*,’racines reelles’
...... Else
endif Print*,’pas de racines dans R’
Endif
end

Le programme ci-contre affichera « pas de racines dans » R car D<0.

FORTRAN Pr . LAHCEN EL ARROUM 20

* On peut même enchaîner plusieurs conditions logiques :
Syntaxe:
if (condition logique 1) then
...
else if (condition logique 2) then
...
else if (condition logique 3) then
...
else
...
Endif

Programme1: Programme2: Programme3 :

x=12.;y=-9.
x=12.;y=-9 x=12.;y=-9 If(-x-y<=0)then
If(-x-y>=0)then If(-x-y>=0)then Print*,’POSITIF’
Print*,’POSITIF’ Print*,’POSITIF’ Elseif(x<y)then
Elseif(x<y)then Elseif(-x<y)then Print*,’NEGATIF’
Print*,’NEGATIF’ Print*,’NEGATIF’ Else
Else Else Z=x**2-y;Print*,’Z=‘,Z
Z=x**2-y;Print*,’Z=‘,Z Z=x**2-y;Print*,’Z=‘,Z Endif
Endif Endif End

Le programme exécute le bloc d'instructions suivant la première condition logique vraie puis
reprend après endif. Ainsi le programme2 ci-dessus affichera « NEGATIF » et le
programme3 affichera « POSITIF »
Si aucune condition logique n'est vraie, le bloc else est exécuté. Ainsi le programme1
calculera Z et affichera Z=153.0000
7-2 Test arithmétique:
a) Syntax :
If(u) n1,n2,n3 u: variable ou expression arithmétique
b) Fonctionnement:
C) Programme de résolution d’une équation
du 2éme ordre, utilisant le teste arithmétique:

a=50.2;b=407.3,c=18.
D=b**2-4*a*c
If(D)1,2,3
3 Print*,’x1=‘,(-b+sqrt(D))/(2*a)
Print*,’x2=‘,(-b-sqrt(D))/(2*a)
Goto 4
2 Print*,’x1=X2=‘,-b/(2*a)
goto4
1 Print*,’pas de racine dans R’
4 END
L’éxécution donne: x1=-4.4436906E-02
FORTRAN Pr . LAHCEN EL ARROUM 21
 x2=-8.0169109.
Si on change la valeur de b par 47 l’exécution donne: « Pas de racine dans R ».

7-3- Boucles:
Une boucle permet d’exécuter une séquence d’instructions plusieurs fois d’affilée. Le nombre
de boucle peut être déterminé à l’avance ou par basculement d’une condition logique.

7-4-Boucles do ... enddo (indexée)

On effectue la boucle un nombre de fois prédéterminé.

a) Syntaxes

do var = deb, fin ou do var = deb, fin, pas

... ...
enddo enddo

var : variable de type integer

deb, fin et pas : objets de type integer (constantes ou variables).

b) Fonctionnement

var prend d'abord la valeur de deb et s’incrémente de pas à chaque boucle.

Dès que var > fin, la boucle s'arrête et l'exécution continue après le enddo.
L'entier pas peut être omis et vaut 1 par défaut.
Si fin<deb et pas>0 ou bien fin>deb et pas<0, la boucle n'est jamais exécutée.

C) Exemple: Calcul la somme des entiers <=100

PROGRAM iteration_do
INTEGER i, somme, n

n=100! affectation de n
somme=0
DO i=1,n,1
somme=somme+i
END DO
print*,'somme=',somme
END PROGRAM iteration_do

Resultat: somme=5050

FORTRAN Pr . LAHCEN EL ARROUM 22

7-5- Boucles do ... while
On effectue la boucle tant qu'une condition logique est vérifiée.

a) Syntaxe
do while (condition logique)
...
...
...
enddo

b) Fonctionnement
On rentre dans la boucle seulement si la condition logique vaut .true. et on exécute la boucle
tant qu'elle reste à .true..
Dès qu'à la fin d'une boucle, la condition est .false., l'exécution reprend après enddo.
c) Remarque:
Le programme ou la condition logique reste toujours vrais (.tue.), ne s’arrêtera jamais
1
d- exemple: Sommation de la série ∑ n >=1
jusqu'a ce que le terme général soit
n2
inférieur a ε fois la somme partielle courante :

PROGRAM iteration_while
INTEGER :: n ; DOUBLE PRECISION :: somme
DOUBLE PRECISION, PARAMETER :: epsilon = 1.d-3
LOGICAL :: fini
! Initialisation
n=0; somme=0.d0; fini=.FALSE.
DO WHILE (.not. fini)
n=n+1
somme=somme + 1d0/n**2
fini=(1d0/n**2 .LT. epsilon*somme)
END DO
print *,"Nombre d'iterations : ", n
print *,"Somme = ", somme
END PROGRAM iteration_while

7-6-Do sans contrôle de boucle:

Ce sont des boucles DO sans contrôle de boucle. Pour lesquelles on utilise une instruction
conditionnelle avec une instruction EXIT, pour en sortir.
a-syntax:

Do
bloc1
IF (expression) EXIT
Bloc2
…..
end do

FORTRAN Pr . LAHCEN EL ARROUM 23

avec :
+ expression une expression de type LOGICAL,
+ Bloci des séquences de code Fortran.
b-Exemple:

PROGRAM iteration_exit
integer::n=0,somme=0
Do
n=n+1
Somme=somme+n
If(n==100)exit
Enddo
Print*,’somme=‘,somme

END PROGRAM iteration_exit

Ce programme calcule la somme des nombres entiers <=100. On retrouve le même

résultat (somme=5050) que pour la boucle avec Do indexé précédente

7-7-Instructions goto et continue

a-Syntaxe : goto No de label

En arrivant sur une telle ligne, le programme est branché directement sur la ligne
comportant le label mentionné. En général,, cette ligne contient seulement l'instruction
qui ne fait rien continue.

a- Exemple:
program somme_produit
doubleprecision::a,b,somme,prod;integer::oper
write(*,*) 'donner deux réels'; read(*,*)a,b
write(*,*)'donner 1 (produit) un autre entier pour (por somme)';read(*,*)oper
if(oper==1) then
prod=a*b;print*,'a*b=',prod
goto 10
endif
somme=a+b;print*,'a+b=',somme

10 continue
End

9-Les tableaux
A partir des types simples du FORTRAN (qu’on a déjà vu), on peut former des
vecteurs, des matrices, et même des tableaux à plusieurs indices.
9-1-Déclaration
type var (m1,m2,….,mn)
type , dimension(m1,m2,….,mn)::liste_tab (recommandée)

FORTRAN Pr . LAHCEN EL ARROUM 24

m1, m2,... déterminent la taille du tableau. Elles doivent être des constantes entières. Il
est interdit de mettre des variables entières. Autrement dit : la taille d'un tableau
FORTRAN est fixée une fois pour toutes.
n <= 7 : un tableau peut avoir jusqu'a 7 dimensions.
mi : est une expression qui peut être spécifie a l'aide :
* d'une constante entière (littérale ou symbolique) ;dans ce cas, la borne inférieure du
tableau est 1,
* d'une expression de la forme cste1 : cste2 avec cste1, cste2 des constantes entières telles
que cste1 <= cste2,
* liste _tab est une liste de tableaux.

Exemples:
real v(100)
double precision a(100,100)
integer i(20)

Il est recommandé d’utiliser l’attribut dimension et des constantes symboliques

(parameter::m=10)

INTEGER, PARAMETER :: m = 10
REAL, DIMENSION(0:m-1) :: Y
REAL, DIMENSION(1+m*m,10) :: Z
REAL, DIMENSION(100) :: R
REAL, DIMENSION(1:5,1:5, 1:5) :: S
REAL, DIMENSION(-10:-1) :: X

9-2 -Rang, profil, étendue d’un tableaux:

* Le rang (Rank) d'un tableau est son nombre de dimensions.

* Le nombre d'éléments dans une dimension s'appelle l'étendue (extent) du tableau dans cette
dimension.
* Le profil (shape) d'un tableau est un vecteur dont chaque élément est l'étendue du tableau
dans la dimension correspondante.
* La taille (size) d'un tableau est le produit des éléments du vecteur correspondant a son
profil.
* Deux tableaux sont dits conformant s'ils ont le même profil.

Exemple:

REAL, DIMENSION(15) :: X
REAL, DIMENSION(1:5,1:3) :: Y, Z

*Le tableau X est de rang 1, Y et Z sont de rang 2.

* L'etendue de X est 15, Y et Z ont une étendue de 5 et 3.
* Le prol de X est le vecteur (/ 15 /), celui de Y et Z est le vecteur (/ 5,3 /)
* La taille des tableaux X, Y et Z est 15.
* Les tableaux Y et Z sont conformants.

9-3 Ordre des éléments

FORTRAN Pr . LAHCEN EL ARROUM 25

En mémoire la notion de tableau n'existe pas : les éléments sont ranges les uns a la suite des
autres. Pour accéder a ces éléments, dans l'ordre mémoire,Fortran fait d'abord varier le
premier indice, puis le second et ainsi de suite.
Par exemple, les éléments d'un tableau a deux dimensions sont ordonnes comme suit :

REAL, DIMENSION(5,3) :: C
C(1,1),C(2,1),..,C(5,1),C(1,2),C(2,2),..,C(5,3)

9-4- Initialisation:
a- Le symbole =
Fortran permet de manipuler globalement l'ensemble des éléments d'un tableau. On pourra
alors utiliser le symbole "=" comme pour
l'initialisation d'une variable scalaire.

Exemple
Pour initialiser a 5 l'ensemble d'un tableaux :

real,dimension(2,3)::mat=5.
do i=1,2
do j=1,3
print*,'line',i ;print*,mat(i,j);
enddo
enddo
end

b-Le constructeur de vecteurs :

Un constructeur de vecteur est un vecteur de scalaires dont les valeurs sont encadrées par les
caractères (/ et /) :

tableau = (/ expr1, expr2, ..., exprn /)

* tableau est un tableau de rang 1,

* expri est : - un scalaire,
-une boucle DO implicite de la forme

FORTRAN Pr . LAHCEN EL ARROUM 26

(expr scalaire, variable = m1,m2[,m3]) avec variable une variable INTEGER correspondant
a l'indice de cette boucle et m1, m2, m3 des constantes entières délimitent la boucle (voir
boucle DO).
• Le constructeur et le tableau doivent être conformants.
Exemple: le programme suivant affichera 100 1 7 100 puis GREEN:

IMPLICIT NONE
REAL, DIMENSION(4) :: heights = (/ 5.10, 5.6, 4.0, 3.6 /)
CHARACTER(len=5), DIMENSION(3) :: colours = &
(/ 'RED ', 'GREEN', 'BLUE ' /)
INTEGER :: i
INTEGER, DIMENSION(10) :: ints = (/ 100, (i, i=1,8), 100/)
print*,ints(1),ints(2),ints(8),ints(10)
print*,colours(2)
end

C- L'instruction DATA
Comme pour les variables simples, on peut utiliser l'instruction DATA pour initialiser les
tableaux lors de leur déclaration. Elle permet d'initialiser tout ou partie de tableaux a l'aide
d'une liste de constantes encadrée par le caractère /
La notation n*valeur peut être employée pour répéter une même valeur.
Les éléments à initialiser peuvent être spécifies au moyen d'une boucle DO implicite :
(tab(i), i = m1,m2[,m3]).
Exemple:

Real :: alpha, Beta, Gama, epsilon; INTEGER :: i, j

REAL, DIMENSION(20) :: A, B; INTEGER, DIMENSION(10) :: ints
REAL, DIMENSION(2,3) :: MAT
DATA Alpha, Beta, Gama,epsilon /12.5,11.,48.6,1.e-10/
DATA A/20*7.0/, B/10., 3.87, 10.5/
DATA (ints(i),i=1,4)/4*6.0/, A(10)/-1.0/
DATA MAT/1., 2., 3., 4., 5., 6./
DATA ((MAT(i,j),j=1,3),i=1,2)/1., 2., 3., &
4., 5., 6./
print*,epsilon,B(3),B(5),MAT(8,1)
end

Le programme ci-dessus donnera 1 Warning ( Plus de variables B que de valeurs) au cours de

la compilation et affichera: 1.0000000E-10 10.500000 0.0000000E+00 8.4077908E-45.

9-5-Manipulation des Tableaux:

a- Expressions de type tableau:
Les tableaux peuvent être utilises en tant qu'opérandes dans une expression :
* les opérateurs intrinsèques sont applicables à des tableaux conformants,
* les fonctions élémentaires s'appliquent à l'ensemble du tableau.
Dans ces cas, les fonctions ou opérateurs sont appliques a chaque élément du tableau (log,
sqrt, ...).
Exemple
REAL, DIMENSION(-4:0,0:2) :: B=4.
REAL, DIMENSION(5,3) :: C=2. Ce programme affichera la même valeur pour B
puis pour C :
-10.00000 -10.00000 puis
FORTRAN Pr . LAHCEN EL -8.0695070E-2
-8.0695070E-2 ARROUM 27
(Mêmes initiations et mêmes opérations)
REAL, DIMENSION(0:4,0:2) :: D=3,E
B = C * D - B**2
E = SIN(C)+COS(D)
print*,B(-2,2),B(0,2)
print*,E(2,2),E(0,2)
End
b) Sections de tableaux:
Les sections réguliers de tableaux sont décrites a
l'aide d'un triplet :[limite1]:[limite2][:pas]
* cette notation est équivalente a une pseudo boucle,
* une section de tableau est aussi un tableau,
* le rang d'une section de tableau est inférieur ou égal a celui du tableau global,
* la section démarre a limite1 et se termine à ou avantlimite2,
*pas est l'incrément des indices.

Exemple:

A(:) ! Le tableau global

A(3:9) ; A(3:9:1) ! A(3) à A(9) par pas de 1
A(m:n) ! A(m) à A(n)
A(m:n:k) ! A(m) à A(n) par pas de k
A(8:3:-1) ! A(8) a A(3) par pas de -1
A(8:3) ! A(8) a A(3), pas de 1 => taille nulle
A(m:) ! de A(m) a la borne supérieure de A
A(:n) ! de la borne inférieure de A à A(n)
A(::2) ! borne inf. de A a borne sup., pas de 2
A(m:m) ! section constituée de 1 élément(ce n'est pas un scalaire !)
A(m) ! section équivalente a un scalaire

Seules les opérations sur des sections conformantes sont valides :

REAL, DIMENSION(1:6,1:8) :: P
P(1:3,1:4) = P(1:6:2,1:8:2) ! VALIDE
P(2:8:2,1:7:3) = P(1:3,1:4) ! INVALIDE
P(2:6:2,1:7:3) = P(2:5,7) ! INVALIDE
Exemple:
REAL, DIMENSION(1:6,1:8) :: P

FORTRAN Pr . LAHCEN EL ARROUM 28

 P(2:5,7) est une section 1D tandis que
P(2:5,7:7) est une section 2D : ces 2
tableaux ne sont donc
pas conformants.

Exercice1:
Écrire un programme complet qui lit au clavier deux matrices de même taille m x n et effectue
leur somme. On part du principe que ces matrices ont au plus 50 lignes et 80 colonnes. On
déclare donc 3 tableaux 50 x 80, et on utilise deux variables nligne et ncolon pour stocker les
tailles réelles des matrices que l'on traite. Ces tailles réelles sont bien sûr demandées à
l'utilisateur.
parameter (mligne=50, mcolon=80)
double precision, dimension (mligne, mcolon)::a,b,c
integer nligne, ncolon
write(*,*) 'Nombre de lignes des matrices'
read(*,*) nligne
write(*,*)'Nombre de colonnes des matrices'
read(*,*) ncolon
write(*,*)'Matrice a'
do i=1,nligne
read(*,*) (a(i,j), j=1,ncolon)
enddo
write(*,*)'Matrice b'
do i=1,nligne
read(*,*) (b(i,j), j=1,ncolon)
enddo
do i=1,nligne
do j=1,ncolon
c(i,j)=a(i,j)+b(i,j)
enddo
Print*,(c(i,j),j=1,ncolon)
enddo
end

Exercice 2:

FORTRAN Pr . LAHCEN EL ARROUM 29

1) Écrire un programme qui calcul:
a) un tableaux C(0:2,0:3) à partir de deux tableaux conformant a(2:4,2:6) et b(-1:1,0:3) tel que
C(i,j)=a(i,j)*b(i,j) .
b) Et la matrice mc(2,2) produit de deux matrices ma(2,3) et mb(3,2) (mc=ma*mb)

2) Prévoir des sorties sur écran qui:

a) montre comment les données sont rangées dans la mémoire.
b) Montre le résultat du produit(c=a*b) de deux tableaux conformant
c) Montre le produit (mc=ma*mb) de deux matrices .
d) Remarquer que mc et c sont différents et que le calcul de mc nécessite une analyse « un
petit algorithme » que vous êtes sensé de connaître par cœur:

mc(i, j ) = ∑ ma(i, k ) * mb(k , j )

k =1, 2

e) Exécuter ce programme lorsque a,b,c ne sont pas conformant. Résultat? Solution?

implicit none
real,dimension(1:2,1:3)::a;real, dimension(2:3,2:4)::b;real,dimension(-1:0,0:2)::c
real,dimension(2,3)::ma;real,dimension(3,2)::mb;real,dimension(2,2)::mc;integer i,j,k
data ((a(i,j),i=1,2),j=1,3)/1.,2.,3.,4.,5.,6./,((b(i,j),i=2,3),j=2,4)/1.,2.,3.,4.,5.,6./
data ((ma(i,j),i=1,2),j=1,3)/1.,2.,3.,4.,5.,6./,((mb(i,j),i=1,3),j=1,2)/1.,2.,3.,4.,5.,6./
c=a*b !c,a,b sont conformants
print*,'comment les données sont rangées dans la mémoire ma par
exple';print*;print*!aeré
do i=1,2
print*,(ma(i,j),j=1,3)
enddo;print*;print*
print*,'produit intrinseque de a et b qui est different du produit de matrice
';print*;print*
do i=-1,0
print*,(c(i,j),j=0,2)
enddo;print*;print*
do 1 i=1,2
do 2 j=1,2
mc(i,j)=0
do 3 k=1,3
mc(i,j)=mc(i,j)+ma(i,k)*mb(k,j)
3 continue
2 continue
1 continue
print*,'produit de deux matrice mc=ma*mb';print*;print*
do 4 i=1,2
print*,(mc(i,j),j=1,2)
4 continue;print*;print*
end

Résultat (sur ecran):

FORTRAN Pr . LAHCEN EL ARROUM 30

comment les données sont rangées dans la mémoire ma par exple

1.000000 3.000000 5.000000

2.000000 4.000000 6.000000

produit intrinseque de a et b qui est different du produit de matrice

1.000000 9.000000 25.00000

4.000000 16.00000 36.00000

produit de deux matrice mc=ma*mb

22.00000 49.00000
28.00000 64.00000

Press any key to continue

Lorsque a, b, c ne sont pas conformant, le compilateur indique erreur de « conformité ».

Solution établir un algorithme correspondant à cette situation et réécrire votre programme (au
niveau du produit de tableaux a*b)

10) Fonctions et subroutines :

Premier objectif
Il arrive fréquemment que l'on doive faire plusieurs fois la même chose au sein d'un même
programme, mais dans un contexte différent. Par exemple :

Calculer la fonction pour plusieurs valeurs de x :

Calculer les coordonnées polaires d'un point défini par un couple de réels (x,y) :

Second objectif :
On a un problème décomposable en plusieurs sous problèmes. On cherche à
« enfermer » chaque sous problème dans un bloc et à faire communiquer ces blocs.
Exemple : écrire un programme qui lit trois matrices au clavier, en fait le produit, puis affiche
le résultat. On écrira trois blocs de base :
un qui permet de lire une matrice au clavier

FORTRAN Pr . LAHCEN EL ARROUM 31

un qui effectue la somme de deux matrices

un qui affiche une matrice à l'écran

Les objets FORTRAN correspondants à ces blocs sont les subroutines ou les fonctions.
Chacun de ces blocs peut être écrit séparément, et il est relié à l'extérieur par des « portes »
d'entrée/sortie repérées par un nom .
Ce nom n'a de sens que pour le bloc, et il est là pour identifier une entrée ou une sortie.
Les connexions des boites avec l'extérieur sont appelés en FORTRAN
« paramètres formels », et seront traités comme des variables dans les instructions
exécutables.

10-1-Les subroutines
C'est une séquence d'instructions appelable d'un point quelconque du programme. Elle peut
être appelée depuis le programme principal, ou depuis une autre subroutine ou fonction.
Une subroutine est définie par :
un nom
des paramètres formels, qui ont comme les variables :
un nom
un type
Écriture d'une subroutine
subroutine nomsub(pf1, pf2, pf3, ...)
type pf1
type pf2
type pf2
...
Déclaration des variables locales
...
Instructions exécutables
...
return
end
Les instructions de la subroutine peuvent manipuler :
les paramètres formels (comme des variables normales),
les variables locales,
les variables d'un common.

FORTRAN Pr . LAHCEN EL ARROUM 32

Les instructions de la subroutine ne peuvent pas manipuler les variables locales du
programme principal ou d'une autre subroutine ou fonction
Appel d'une subroutine
L'appel d'une subroutine se fait depuis un bloc fonctionnel quelconque (programme
principal, subroutine, fonction) avec l'instruction call.
call nomsub (v1, v2, v3, ...) Les arguments v1, v2, v3 peuvent être :
*des variables du bloc fonctionnel,
*des constantes (déconseillé !).
Important
Les types des arguments v1, v2, v3,... doivent correspondre exactement à ceux des paramètres
formels pf1, pf2, pf3,...
Exemple
Écrire une subroutine qui calcule les coordonnées polaires associées à des coordonnées
cartésiennes (x,y).

Code source d'une subroutine de calcul de coordonnées polaires à partir de coordonnées

cartésiennes:
subroutine polar(x, y, r, theta)
double precision x, y, r, theta
double precision pi
double precision temp
pi=4*datan(1d0)
r=dsqrt(x**2+y**2)
temp=datan(y/x)
if (x.gt.0d0) then
theta=temp
else if (x.lt.0d0) then
theta=-temp
else if (x.eq.0d0) then
if (y.ge.0d0) then
theta=pi/2
else
theta=-pi/2
endif
endif
return
end
Un exemple d'appel de cette subroutine dans le programme principal :
program calculcoordonnées
double precision a, b, rho, phi ! Arguments
Print*,’donner les coordonnées cartisiennes’,a,b
call polar (a, b, rho, phi)
Print*,’rho=’,rho
Print*,’phi=’,phi
end

FORTRAN Pr . LAHCEN EL ARROUM 33

Programme de calcul de coordonnées polaires à partir de coordonnées cartésiennes:
program calculcoordon
double precision a, b, rho, phi ! Arguments
Print*,'donner les coordonnées cartisiennes'
read(*,*)a,b
call polar (a, b, rho, phi)
Print*,'rho=',rho
Print*,'phi=',phi
end
subroutine polar(x, y, r, theta)
double precision x, y, r, theta ;double precision pi ;double precision temp
pi=4*datan(1d0)
r=dsqrt(x**2+y**2)
temp=datan(y/x)
if (x.gt.0d0) then
theta=temp
else if (x.lt.0d0) then
theta=-temp
else if (x.eq.0d0) then
if (y.ge.0d0) then
theta=pi/2.
else
theta = -pi/2
endif
endif
return
end

10-3- Fonction FUNCTION:

Sytaxe: Exemple:

Type Fuction nomf(x) Program calculder

Type x Real x,y,r
nomf=…. x=10.;y=20.
Return Print*,r(x,y)
End End
real function r(x,y)
real x,y
r=sqrt(x**2+y**2)
Return
end

10-4-Déclaration external
Objectif

FORTRAN Pr . LAHCEN EL ARROUM 34

Utiliser le nom d'une fonction ou d'une subroutine comme argument d'une autre fonction ou
subroutine.
Examinons le problème suivant : Écrire une subroutine qui calcule l'intégrale pour une
fonction f quelconque. Que faudra-t-il faire entrer et sortir de la subroutine ?
la fonction f ;
les bornes d'intégration a et b ;
la valeur de l'intégrale.
Or quel est le moyen en FORTRAN de programmer une fonction f(x) ? C'est d'utiliser une
fonction FORTRAN, qui renverra par exemple une valeur real.
On peut donc prédire la forme de la subroutine d'intégration :
subroutine integ (a, b, f, valint)
Les paramètres formels a, b et valint seront double precision, mais de quel type est f ?
C'est le nom d'une fonction FORTRAN, et pour déclarer un paramètre formel aussi bizarre, on
écrira : external f

Exemple:Structure générale d'un programme d'intégration simple.

Program integral
double precision somf
external f
double precision f
call integ(1d0,2d0,f,somf)
print*,'intergral de f=',somf
end
subroutine integ(a,b,f,valint)
Double precision a,b,valint,h
external f
Double precision f
x1=a;x2=b;h=(b-a)/10000.
x=x1;valint=0
8 valint=valint+(f(x+h)+f(x))*h/2.
x=x+h
if(x.lt.x2) goto 8
return
end
Double precision function f(x)
f=x**2+3d0
return
end

Contrôle N°1 en programmation et simulation (MMR1 : 2007)

1) soit le programme fortran suivant :
Real, dimension(0:2,3:5)::a
Real, dimension(1:3,0:2)::b,c1,c2

FORTRAN Pr . LAHCEN EL ARROUM 35

 data ((a(i,j),i=0,2),j=3,5)/1,3,5,7,9,2,4,6,8/
data ((b(i,j),i=1,3),j=0,2)/1,3,5,7,9,2,4,6,8/
c1=a*b;c2=a/b
do i=1,3
print*,(c1(i,j),j=0,2)
enddo
print*,'****************************************************'
do i=1,3
print*,(c2(i,j),j=0,2)
enddo
end

a) donner le rang et le profil des tableaux a,b,c1,c2

a b c1 c2
Rang
profil
b) que peut-on dires de ces tableaux :
c) Apres exécution de ce programme, donner les tableaux :

? ? ? ? ? ? ? ? ? ? ? ?
       
a =  ? ? ? , b =  ? ? ? , c1 =  ? ? ? , c 2 =  ? ? ? 
? ? ? ? ? ? ? ? ? ? ? ?
       
1) a- Ecrire un sous-programme Fortran qui calcule le produit Pm=m1*m2 de deux
4
matrices m1(3,4) et m2(4,4), sachant que) Pm( i , j ) = ∑ m1( i , k ) * m 2( k , j )
k =1
b- Ecrire un programme principal :
-qui lit m1 et m2 (au clavier)
-qui appelle le sous- programme précédant et affiche Pm sur l’écran.

3) soit le programme suivant :

Program integral
double precision somf
type f
type f
call subroutine integ(1d0,2d0,f,somf)
end
subroutine intg(a,b,f,valint)
type a,b,valint
type f
type f
……
valint=valint+(f(x1+h)+f(x1))*h/2
.......

FORTRAN Pr . LAHCEN EL ARROUM 36

return
end
type function f(x)
f=x**2+3d0
return
end

a)commenter indiquer la fonction de ce programme.

b) remplacer type par le type qu’il faut.

Solution du 1er contrôle:

EX1(10 points)
a) a b c1 c2
Rang 2 2 2 2
profil (3,3) (3,3) (3,3) (3,3)

b) Ces tableaux sont conformants.

c) 1 7 4 1 7 4  1 49 16   1 1 1
       
a =  3 9 6 , b =  3 9 6 , c1 =  9 81 36 , c 2 = 1 1 1
5 2 8 5 2 8  25 4 64   1 1 1
       

Resultant de l’éxecution du programme:

1.000000 49.00000 16.00000
9.000000 81.00000 36.00000
25.00000 4.000000 64.00000
****************************************************
1.000000 1.000000 1.000000
1.000000 1.000000 1.000000
1.000000 1.000000 1.000000
Press any key to continue

EX2(5points)- Programme Produit de deux matrices:

program produitmat
implicit none;integer n1,n2;parameter(n1=3,n2=4)
doubleprecision, dimension(1:n1,1:n2)::m1;doubleprecision, dimension(1:n2,1:n1)::m2
doubleprecision, dimension(1:n1,1:n1)::pm;integer i,j,k
write(*,*),'donner la matrice m1'
read (*,*),((m1(i,j),i=1,n1),j=1,n2)
write(*,*),'donner la matrice m2'
read (*,*), ((m2(i,j),i=1,n2),j=1,n1)
call Pmat(m1,m2,pm,n1,n2)
write(*,*),((pm(i,j),i=1,n1),j=1,n1)

FORTRAN Pr . LAHCEN EL ARROUM 37

end
subroutine Pmat(fm1,fm2,fpm,n1,n2)
doubleprecision, dimension(1:n1,1:n2)::fm1;doubleprecision, dimension(1:n2,1:n1)::fm2
doubleprecision, dimension(1:n1,1:n1)::fpm;integer i,j,k
do j=1,n2
do i=1,n1
fpm(i,j)=0d0
do k=1,n2
fpm(i,j)=fpm(i,j)+fm1(i,k)*fm2(k,j)
enddo
enddo
enddo
return
end

FORTRAN Pr . LAHCEN EL ARROUM 38

l’exécution avec deux matrices unité donne:
donner la matrice m1
1111
1111
1111
donner la matrice m2
111
111
111
111
4.00000000000000 4.00000000000000 4.00000000000000
4.00000000000000 4.00000000000000 4.00000000000000
4.00000000000000 4.00000000000000 4.00000000000000
Press any key to continue

Exe3-(5poits)
a) Ce programme permet de calculer l’intégral de la fonction x**2+3 dans l’intervalle [1,2]
b) On remplace type:

• Dans le programme principale par:

External f
Double precision f
• Dans le sous programme par:

External f
Double precision f
• Dans la Fonction par:

Double precision function

11- Fichiers:
Accès à un fichier = Lecture ou Écriture dans ce fichier.
En Fortran ,il y a des fichiers à accès séquentiel et des fichier à accès direct.
Fichiers à accès séquentiel: à partir de l'ouverture du fichier, on lit les données dans l'ordre où
elles sont stockées, sans pouvoir accéder directement à une donnée particulière. Au fur et à
mesure des lectures ou écritures, un pointeur de fichier avance automatiquement d'une donnée
à la suivante.
Fichiers à accès direct: pour ces fichiers on accède directement à une donnée particulière.
On ne parlera que des Fichiers à accès séquentiel:
Les fichiers séquentiels sont divisés en deux types : le fichiers formatés et les fichiers
binaires.

11-1- fichiers formatés :

Ce sont des fichiers texte, c'est-à-dire organisés en lignes de caractères, que l'on pourrait lire
ou écrire avec un éditeur.
Lorsque l'on écrit un objet FORTRAN sur ce type de fichier, celui-ci est converti en chaîne de
caractère selon un formatage défini par l'utilisateur ou par défaut
(voir « Écritures formatées » 6.1)
Ce type de fichier est pratique car on peut les visualiser par un éditeur de texte, et presque
tous les logiciels savent lire des fichiers texte.

FORTRAN Pr . LAHCEN EL ARROUM 39

L'écran et le clavier sont des cas particuliers de fichiers formatés.

11-2-Les fichiers binaires:

Les objets FORTRAN sont écrits sur ce type de fichier tels qu'ils sont stockés en mémoire.
Par exemple, pour écrire un réel, on écrit directement les 4 octets constituant son codage en
virgule flottante.
De ce fait, ce type de lecture/écriture est plus rapide et engendre des fichiers plus petits.
L'inconvénient est que ces fichiers ne sont pas consultables par un éditeur de texte.

11-3- Ouverture d'un fichier

Il s'agit d'ouvrir un fichier déjà existant ou d'en créer un nouveau. Le FORTRAN associe au
nom du fichier un entier appelé « unité », auquel toutes les instructions FORTRAN de
manipulation des fichiers se référeront. Autrement dit le fichier n'est appelé par son nom qu'au
moment de l'ouverture.

a) Syntaxe
open(numéro d'unité, file=chaîne de caractère, form=chaîne de caractères, status=chaîne
de caractères, err=numéro de label)

Lors de l'ouverture d'un fichier, le pointeur de fichier est automatiquement placé avant la
première donnée, sauf s'il est ouvert avec status='append'.
b)Description

Numéro d'unité : tout entier compris entre 10 et 99. On peut également mettre une variable
integer contenant cet entier.
file=
suivi d'une constante chaîne de caractère indiquant le nom du fichier en clair
par (exemple ‘ProdMat') ou bien une variable de type chaîne contenant le nom du
fichier.
form=
chaîne de caractère pouvant être :
'formatted' ouvre ou crée un fichier formaté. C'est le défaut.
'unformatted' ouvre ou crée un fichier binaire.
status=
chaîne de caractère pouvant être :
'new' crée un nouveau fichier, ou génère une erreur s'il existe.
'old' ouvre un ancien fichier, ou génère une erreur s'il n'existe pas.
'unknown' ouvre le fichier quoi qu'il arrive. C'est le défaut.
'append' ouvre le fichier et se place automatiquement à la fin de celui-ci.
err=
numéro de label vers lequel le programme sera dérouté en cas d'erreur à l'ouverture.

Exemples
open(10,file=‘ProdMat'):
ouvre le fichier formaté ProdMat du répertoire courant, qu'il existe ou non, et l'attache à
l'unité 10.
integer unite
character*80 nomfich
...
unite=10

FORTRAN Pr . LAHCEN EL ARROUM 40

 nomfich=‘ProdMat'
open(unite,file=nomfich)
Fait la même chose que l'exemple précédent.
character*80 nomfich
nomfich=‘ProdMat.dat'
open(10,file=nomfich, form='unformatted', status='new',err=99)
...
! (l'ouverture a réussi)
99 write(*,*) 'Fichier ', nomfich, 'deja existant'

Essaye de créer un nouveau fichier binaire ProdMat.dat et affiche un message d'erreur au

cas où ce fichier existe déjà.

11-4-Fermeture d'un fichier

close(numéro d'unité) Cette instruction détache le numéro d'unité du nom du fichier. Pour
tout nouvel accès au fichier, il faut l'ouvrir à nouveau avec l'instruction open.
Notons que si le programme se termine normalement, tous les fichiers sont automatiquement
fermés.

11-5-Lecture / Écriture sur un fichier:

a) Syntaxe
read(numéro d'unité, format, err=numéro de label, end=numéro de label) liste de
données
write(numéro d'unité, format, err=numéro de label) liste de données

* On n'indique pas de format ,pour un fichier non formaté, .

* Pour un fichier formaté, on indique un format.
* Pour les lectures/écritures formatées, le format * est le format par défaut, les autres formats
s'utilisent comme pour les écritures écran, lectures clavier (voir « formats d'écriture » 6.2).
• Les autres paramètres optionnels sont :

err=numéro de label : En cas d'erreur, le programme est dérouté vers ce label.

end=numéro de label : Utilisable en lecture (lorsqu'on arrive à la fin du fichier, autrement dit
quand il n'y a plus rien à lire, le programme est dérouté vers le label mentionné).

Remarque importante : Lorsque l'on effectue une instruction write dans un fichier
séquentiel, toutes les données suivant la position courante du pointeur de fichier sont
effacées.
Ainsi si l'on ouvre un fichier existant avec comme status 'old' ou 'unknown', et que l'on fait
tout de suite un write, toutes les données seront effacées. Aussi, si l'on veut ajouter des
données dans un fichier déjà existant, il faut l'ouvrir avec status='append'.
b) Exemples:
Stockage de données x,y:
Écrire un programme (ou une subroutine ) recevant en entrée deux vecteurs x et y double
précision contenant n données chacun, et une chaîne de 80 caractères contenant un nom de
fichier, qui écrit sur un fichier texte une valeur de x et une valeur de y par ligne.

FORTRAN Pr . LAHCEN EL ARROUM 41

! subroutine ecritxy (x, y, nomfich)
character*80 nomfich
double precision, dimension(0:10):: x, y

open(20,file='nomfich')
n=10
do i=1,n

x(i)=dfloat(i);y(i)=x(i)**2
write(20,*) x(i), y(i)
enddo

close(20)
! return
end
Si on enlève! On a une subroutine qu’on peut appeler d’un programme principal
L’exécution donne un fichier texte qu’on peut lire avec Word par exemple:

1.00000000000000 1.00000000000000
2.00000000000000 4.00000000000000
3.00000000000000 9.00000000000000
4.00000000000000 16.0000000000000
5.00000000000000 25.0000000000000
6.00000000000000 36.0000000000000
7.00000000000000 49.0000000000000
8.00000000000000 64.0000000000000
9.00000000000000 81.0000000000000
10.0000000000000 100.000000000000

Affichage d'un fichier texte :

Ouvrir le fichier texte nomfich.txt dont on ne connaît pas à priori le nombre de lignes et
afficher à l'écran toutes les lignes de ce fichier texte:

character*80 ligne
open(20,file='nomfich.txt')
10 continue
read(20,'(a)', end=99) ligne
write(*,*) ligne
goto 10
99 continue
end

FORTRAN Pr . LAHCEN EL ARROUM 42

Résultat de l’exécution sur l’écran :

1.00000000000000 1.00000000000000
2.00000000000000 4.00000000000000
3.00000000000000 9.00000000000000
4.00000000000000 16.0000000000000
5.00000000000000 25.0000000000000
6.00000000000000 36.0000000000000
7.00000000000000 49.0000000000000
8.00000000000000 64.0000000000000
9.00000000000000 81.0000000000000
10.0000000000000 100.000000000000
Press any key to continue

11-6- Fichiers séquentiels (.dat):

On utilise beaucoup les fichiers séquentiels binaires (.dat). Ces fichiers n’occupent pas autant
de place mémoire que les fichiers texte. On peut traité facilement ces fichiers en utilisant un
utilitaire qui est ORIGINE.

a) Ouverture d’un fichier:

Open (unité logique, file=‘nom.dat’)

b) Écriture dans un tel fichier (Unité logique=2):

Exemple:
Double precision :: x,y
Integer i
Open (2, file='yfctx.dat')
Do i=1,10
x=dfloat(i)
Y=x**2
Write(2,*) x,y
end do
end
Exécution:
Lecture avec origine: Traçage de y en fonction de x avec origine:

1 1 100

2 4
3 9 80

4 16
5 25 60

6 36
Y

7 49 40

8 64
20
9 81
10 100 0
1 2 3 4 5 6 7 8 9 10 11
x

FORTRAN Pr . LAHCEN EL ARROUM 43

Analyse des donnée avec origine: fit polynomial (Y=A+B1+B2*x^2):

[13/12/1998 21:12 "/Graph1" (2451160)]

B
Polynomial Regression for yfctx_B: 100 Polynomial Fit of yfctx_B
Y = A + B1*X + B2*X^2
80

Parameter Value Error

------------------------------------------------------------ 60

A -7,10543E-15 9,20956E-15

Y
B1 1,77636E-15 3,8463E-15 40

B2 1 3,40768E-16
------------------------------------------------------------ 20

R-Square(COD) SD N P 0
1 2 3 4 5 6 7 8 9 10 11
------------------------------------------------------------ x

1 7,83025E-15 10 <0.0001
------------------------------------------------------------
12- Compilation et exécution d’un programme Fortran:
12-1-Sous Windows (extension .for, .f ou .f90):
•Saisir le programme
•Compiler le programme (build puis compile )
NB:
*assurer que vous êtes entrain de compiler le programme concerné (dernière version) si non
fermer tous les workspace puis ouvrir le programme corrigé.
*Les versions visuel Fortran imposent certaines limites ( dimension des tableaux, temps
d’exécution ect..):
•Si votre programme nécessite d’enlever ces contraintes , alors procéder comme suite:
Progect
settings
Fortan
Run time
Enlever les contrainte ( enlever x)
* Exécution ( build puis Execute)

12-2- Sous Unix (extension .f):

Compilateur FORTRAN SUN:
• Assurer que vous aver installer le pactage FORTRAN (F77)
• Pour compiler un programme externe dans nomfich.f:
Console:

f 77 nomfich.f

Le fichier se nome alors a.out . Si vous préférer appeler votre exécutable Chose utiliser
l’option –O

FORTRAN Pr . LAHCEN EL ARROUM 44

 f 77 nomfich.f –O chose

Il existe de nombreuses options de f 77. En voici deux qui sont très utiles:

f 77 – g nomfich.f –O chose

- g est indispensable si vous voulez par la suite déboguer votre programme. L’oubli de – g
rendra impossible l’utilisation du débugger. Utiliser –g systématiquement lorsque vous mettez
au point votre programme.

Un programme Fortran version 90 (Program1.f90) peut être transformer en version 77

(Program1.f) par l’instruction suivante :

CP Progam1.f90 Program1.f

NB: Quel que soit le support du cours utilisé. Le fortran (et tout autre Langage)
s’apprend par l’application. A force de Forger on devient forgeron.

FORTRAN Pr . LAHCEN EL ARROUM 45

 Bibliographie:
(1) Initiation au Fortran: Olivier LOUISNARD ,Jean-Jacques LETOURNEAU et Paul
GABORIT; Ecole des mines d’ALBI CARMAUX

(2) Fortran 77: Laurent Mazet : http://www.softndesign.org/manuels/fortran.html.

(3) Langage Fortran support de cours :Patrick Corde et Anne Fouilloux; INSTITUT DU
DEVELOPPEMENTET DES RESSOURCE EN INFORMATIQUE SCIENTIFIQUE ;
(Messagerie : Prenom.Nom@idris.fr).

(4) COURS DE FORTRAN 90: Luc Mieussens mieussens@mip.ups-tlse.fr ;laboratoire

MIP Université Paul Sabatier - Toulouse 3.

(5) Fortran 90 Les concepts fondamentaux; Michael Met calf et John Reid; Edit EFNOR..

………………

FORTRAN Pr . LAHCEN EL ARROUM 46