Fa Q Fortran

FAQ FORTRAN
Date de publication : Septembre 2008
Dernière mise à jour : 15 avril 2009
Bienvenue sur la FAQ fortran, elle essayera de donner une réponse aux questions de
base du FORTRAN. Je tiens à souligner que cette FAQ ne garantit en aucun cas que les
informations qu'elle propose sont exactes ; les auteurs font le maximum, mais l'erreur
est humaine. Cette FAQ ne prétend pas non plus être complète, des cours et une listes
de livres sont donnés dans la FAQ et sur développez.com .
Ont contribué à cette FAQ :
Germain Salvato-Vallverdu (Pageperso) -

FAQ FORTRAN
1. Information générale : (12) ........................................................................................................................................................4

2. Les variables en FORTRAN (13) ............................................................................................................................................. 9
3. Les boucles (9) ........................................................................................................................................................................ 15
4. Où l'on apprend à lire écrire et compter ! (6) .........................................................................................................................19
5. Les fichiers (9) .........................................................................................................................................................................23
6. Les chaînes de caractères (5) .................................................................................................................................................. 28
7. Les variables indicées (listes, tableaux ...) : (10) .................................................................................................................... 31
8. Le programme principal et les sous programmes (6) ............................................................................................................. 35
-3-
Copyright © 2008 Developpez LLC. Tout droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble
de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à
300 000 E de dommages et intérêts.
http://fortran.developpez.com/faq/
FAQ FORTRAN
Sommaire > Information générale :

Comment utiliser cette FAQ ?
Auteurs : Germain Salvato-Vallverdu ,
Cette FAQ est plutot orienté sur l'utilisation de la norme 90 du FORTRAN et à son utilisation en calcul numérique.
Cliquez simplement sur une question pour avoir la réponse.
Comment participer à cette FAQ ?

Le plus simple est de contacter un des auteurs par message privé sur le forum de developpez.com.
D'où vient le FORTRAN ?

Le langage FORTRAN est le premier langage de programmation........
Que signifie FORTRAN ?

Le nom FORTRAN est une abréviation pour FORmula TRANslator.
Quel livre acheter ou lire ?

Des cours sont disponibles dans la rubriques FORTRAN sur développez.com.
Une liste non exaustive de livres sur FORTRAN :
• Programmer en fortran 90, Claude Delannoy
-4-
FAQ FORTRAN
• Savez-vous parler Fortran ?, Maryse Aïn
Où puis-je trouver des cours à télécharger et à consulter ?

Des cours sont disponnibles dans la rubriques FORTRAN sur développez.com.
Quels sont les compilateurs FORTRAN ?

Le langage FORTRAN nécessite une compilation pour transformer le code en langage binaire compréhensible par
l'ordinateur. La compilation crée un fichier binaire qui est exécutable. Il existe différents compilateurs de code fortran
dont voici une liste non exhaustive. Les compilateurs en italique sont payants.
Fortran 77
• g77 : disponnible dans toutes les distribution linux et dans cygwin.
Fortran 90/95...2003
•
gfortran : disponnible dans les distributions linux ou ici
•
g95 : disponnible ici
•
ifort : Le compilateur de intel. Il est disponnible gratuitement pour un usage non commercial.
•
ftn95 : Le compilateur de Silverfrost.
•
absoft : lien.
•
lahey : lien.
•
xlf90 : Le compilateur pour les machines IBM : lien.
•
pgf : Le compilateur Portland pour Fortran.
•
pathf : Le compilateur Pathscale pour fortran.
Les outils pour écrire un programme FORTRAN ?

La première chose est bien entendu de disposer d'un compilateur. Il faut ensuite écrire le code. Le plus simple est
d'utiliser un éditeur de fichier texte tel que (g)vim, nedit ou encore emacs sous linux ou notepad ou le blocknote sous
windows. Certains sont plus facile à utiliser que d'autres et disposent de la coloration syntaxique qui permet de faciliter
la lecture du code.
Logiciel pour windows que je ne connais pas ....
-5-
FAQ FORTRAN
Des stations de travail que je ne connais pas non plus : workstation ?
Qu'elle est la structure d'un programme FORTRAN ?

Le langage FORTRAN a été initialement utilisé sur des cartes perforées sur lesquelles était inscrit le code pour être
ensuite lu et exécuté sur des grosses machines qui lisaient les cartes perforées. Les cartes perforées ayant une certaine
largeur, il en était de même pour les lignes du code. Pour ces raisons historiques, jusqu'au fortran77 on utilisait le format
fixe dans lequel les lignes sont limitées en nombre de colonnes de la façon suivante :
• colonnes 1 à 5 : Etiquette éventuelle (label).

• colonne 6 : On place un chiffre ou un * dans la colonne 6 d'une ligne pour indiquer qu'elle contient la suite des
instructions de la ligne précédente.
• colonnes 7 à 72 : Ces colonnes contiennent les instructions.
• colonnes 73 à 80 : Ces colonnes étaient libres pour numéroter les cartes.
Le format fixe
123456
PROGRAM bonjour
c une ligne de commentaire commence par un c
c declaration des variables
c les instructions
write(*,*)"bonjour"
c fin du programme
END PROGRAM bonjour
Depuis Fortran 90 le format libre est disponnible qui est plus souple. Cependant beaucoup de programme sont encore
écrit en format fixe ou dans un mélange des deux. Voici les principales caractéristiques du format libre :
• Le code peut commencer à la première colonne.

• Les lignes du code ont une longueur maximale de 132 caractères.
• Les commentaires sont introduit par un ! (attention tout le reste de la ligne est un commentaire).
• Le & signifie que les instructions continuent à la ligne suivante.
• Le ; permet de séparer deux instructions écrites sur une même ligne.
La structure générale du code est ensuite assez classique. Voici le fameux programme bonjour écrit en format libre :
Le format libre
PROGRAM bonjour
! une ligne de commentaire commence par un !
! declaration des variables
! les instructions
write(*,*)"bonjour"
! fin du programme
-6-
FAQ FORTRAN
Le format libre
END PROGRAM bonjour
Comment insérer un commentaire ?

Les commentaires sont très important en programmation car ils facilitent la lecture du code. En fortran un commentaire
s'insère simplement en commençant le commentaire par un !. Celui ci peut se placer sur n'importe qu'elle colonne du
code dans la partie réservée au instructions.
Format libre insérer un commentaire

PROGRAM bonjour
! ce programme écrit bonjour
! je place un commentaire qui commence en début de ligne
write(*,*)"bonjour" ! j'écris bonjour
END PROGRAM bonjour
En format fixe on écrit un commentaire en plaçant un c dans la première colonne.
Comment stopper un programme ?

Le programme s'arrète lorsqu'il atteint la ligne comportant.
END PROGRAM nom_program
Remarque : Il suffit de END, le nom du programme est facultatif.
Pour arrêter un programme avant la fin du code, on utilise l'instruction stop. Celle-ci stoppera l'éxécution. Il est possible
de faire suivre l'instruction stop d'un message qui s'affichera lors de l'arrêt du programme. Cela peut être utile pour
débeuguer un programme, par exemple :
STOP "ligne 156"
L'instruction pause, permet de faire une pause dans l'exécution du programme sans pour autant l'arréter complètement.
Comment couper une ligne trop longue ?

En fortran77, qui utilise le format fixe, on indique au compilateur que l'instruction continue sur la ligne suivante en
plaçant un chiffre entre 1 et 9 ou une * en colonne 6 de la ligne suivante. Voici un exemple :
En format fixe
PROGRAM ligne
write(*,*)"blablablablablabla",
* "et reblablabla"
-7-
FAQ FORTRAN
En format fixe
!23456
END PROGRAM ligne
A partir du fortran90, qui utilise le format libre, il suffit de placer un & à la fin de la ligne pour indiquer qu'elle continue
à la ligne suivante. Voici un exemple :
PROGRAM ligne
write(*,*)"blablablablablabla", &
"et reblablabla"
END PROGRAM ligne
-8-
FAQ FORTRAN
Sommaire > Les variables en FORTRAN

Quels sont les caractères utilisables pour les variables en FORTRAN ?
En fortran, les variables ainsi que les noms de programmes, de sous programmes, de fonctions ou de modules sont
limités à 31 caractères et doivent obligatoirement commencer par une lettre. En fortran, sont considérés comme des
lettres les 26 lettres de l'alphabet latin plus le caractère underscore _ . On peut ensuite utiliser les 26 lettres de l'alphabet
latin le caractère underscore ou un chiffre.
Exemples de noms de variables

! variables correctes
_top
top
top122
_abcdefghijklmnopqrstuvwxyz1234 ! 31 characteres max
! variables incorectes
2var ! les variables doivent commencer par une lettres
var-top ! pas de tiret
var*top ! pas d'étoile
var+top ! pas de plus
état ! pas de lettre accentuée
12345678910abcdefghijklmnopqrstuvwxyz_ ! trop de caractères
ATTENTION : Fortran ne prend pas en compte la casse des caractères. Ainsi Vect VECT et vect sont les mêmes
variables.
Quels sont les type de variables les plus usuels en fortran ?

Comment dans la pluspart des langages les variables peuvent être : des nombres entiers, integer, des chaînes de
caractères, character, des nombres réels, real ou double precision ou des éléments logique (true, false), logical
Chacun de ces types de variables peut être un scalaire (un seul nombre), ou une liste de nombres. On parle alors de
variables indicées. Celles-ci peuvent avoir un seul indice (liste, vecteurs ...) ou plusieurs indices (matrices, tenseur ect ...).
Ils existent d'autres type de variables moins utilisés
Comment déclarer un nombre entier ?

Les variables contenant des nombre entier sont de type integer
Déclaration d'un entier

! i est un entier
-9-
FAQ FORTRAN
Déclaration d'un entier

integer::i
Comment déclarer un nombre réel en simple précision ?

Les variables contenant des nombres réels simples précisions sont de type real, elles sont enregistrées sur 4 octets soit 32
bits. Les nombres réels stockés sur 4 octets sont généralement limités entre 10-38 et 10+38. Leur précision est d'environ
10-7. Un nombre réel simple précision a donc en général 7 chiffres significatifs.
Déclaration d'un réel simple précision

! r est un nombre réel simple précision
real::r
! en fortran77 on précise le nombre d'octet

real*4 r
Qu'est ce qu'un nombre réel double précision ?

Les variables contenant des nombres réels doubles précisions sont de type double precision.
Contrairement aux réels simples précisions, les réels doubles précisions sont stockés sur 8 octets, soit 64 bits. De cette
manière la gamme des nombres pouvant être enregistrés dans un réel double précision est plus étandue que celle pouvant
être enregistre dans un réel simple précision. Elle s'étend environ de 10-308 à 10+308 et donne des chiffres avec une
précision d'environ 10-15 soit 15 chiffres significatifs.
Déclaration d'un réel double précision

! d est un nombre réel double précision
double precision::d
! en fortran 77 on précise le nombre d'octets

real*8 d
Comment déclarer une variable chaîne de caractères ?

En fortran, lorsqu'on déclare une chaine de caractère on spécifie sa longueur avec len. Une chaine de caractère peut
contenir des lettres, des chiffres, des symboles ou des espaces vides, elle est de type character.
Déclaration d'une chaine de caractère

! mot est une chaine de caratère de 100 lettres.
character(len=100)::mot
! en fortran77 la syntaxe se rapproche de celle de la déclaration des réels
- 10 -
FAQ FORTRAN
Déclaration d'une chaine de caractère

character*100 mot
Comment déclarer une variable logique ?

Une variable logique est de type logical. Elle prend deux valeurs possibles : .TRUE. ou .FALSE.
Déclaration d'une variable logique

! test est une variable logique
logical::test
Comment utiliser des parametres ?

Une variable peut être déclarée comme paramêtre. On doit alors assigner sa valeurs dés sa déclaration et elle n'est pas
modifiable dans le reste du programme. On peut se servir de cette variable pour protéger les valeurs des constantes
ou encore pour définir les dimensions des variables indicées. On peut se servir d'une variable paramètre pour déclarer
la dimension d'une variable indicée.
Déclaration d'un paramètre

! on déclare que p est un paramètre entier
integer,parameter::p=10
! puis on se sert de p pour donner la dimension d'une variable indicée

double precision,dimension(1:p)::liste
! T est la température ambiante 300K

double precision,parameter::T=300.d0
! le nombre pi
double precision,parameter::pi=acos(-1.d0)
! remarque : l'utilisation d'une fonction ici n'est pas acceptée par tous les compilateurs
Comment calculer la partie entière d'un nombre réel ?

La partie entière d'un réel est donnée par la fonction int().
Calcul de la partie entière d'un réel

! n est la partie entière de x
n = int( x )
Comment arrondir un réel à son entier le plus proche ?

L'entier le plus proche d'un réel x est donnée par la fonction nint().
- 11 -
FAQ FORTRAN
Calcul de l'entier le plus proche d'un réel

! n est l'entier le plus proche de x
n = nint( x )
Comment transformer un entier en réel ?

Les fonctions real() et dble() permettent respectivement de transformer un entier en un réel simple précision et un réel
double précision.
Transformer un entier en réel

PROGRAM convert
implicit none
integer::n
real::r
double precision::d
! r est un réel simple précision

r = real(n)
! d est un réel double précision

d = dble(d)
write(*,*)n,r,d
END PROGRAM convert
Qu'est ce qu'un dépassement de capacité mémoire ?

Chaque variable est enregistrée dans un espace donné de la mémoire et sur un certain nombre d'octets. Il s'en suit qu'il
existe un nombre maximal et minimal au delà desquels il est impossible d'enregistrer la valeur dans une variable. Ainsi
au cours de l'exécution d'un programme, il faut qu'aucune des valeurs enregistrées dans une variable soit suppérieures
à ces limites.
Pour calculer ces valeurs il faut savoir comment sont enregistrés les nombres dans la mémoire de l'ordinateur. Les
nombres entier sont généralement enregistrés sur 32 bits. Les nombres sont enregistrés en base 2 et chaque bit peut
prendre la valeur 1 ou 0. Le premier bit est un bit de signe donc on utilise 31 bits pour enregistrer la valeur absolue du
nombre. Le dernier bit correspond à 20, l'avant dernier à 21 ect ... L'entier le plus grand que l'on peut enregistrer en
base 2 correspond au nombre pour lequel on a placé un 1 dans les 31 bits réservés.
Donc Nmax = 1x230+1x229+1x228+...+1x21+1x20
Donc Nmax = 2147483646
Les nombres réels sont enregistrés sous forme scientifques 1.2345 E +123, en base 2. Les réels simples précisions sont
enregistrés sur 32 bits et les réels doubles précisions sur 64 bits. Comme pour les entiers le dernier bit est pour le signe.
Puis, suivant que l'on est en double ou simple précision, on a 52bits ou 23 bits pour enregistrer la mantisse qui est la
partie devant l'exposant et 11bits ou 8bits pour enregistrer l'exposant. Dans l'exposant il y a également un bit pour le
signe de l'exposant ce qui ramène le nombre à 10bits pour les réels doubles précisions et 7bits pour les simples précisions.
- 12 -
FAQ FORTRAN
Avec 10bits l'exposant maximum pour un double précision est de 1023. Comme le nombre est stocké en base 2, la
mantisse est multipliée au maximum par 21023 (et pas 101023). La gamme de nombres pouvant être enregistrée en réel
double précision est donc entre 10-308 et 10+308.
Avec 7bits l'exposant maximum pour un simple précision est de 127. La gamme de nombres pouvant être enregistrée
en réel simple précision est donc entre 10-38 et 10+38.
La fonction huge() permet d'afficher la valeur des nombres maximum utilisables.
Utilisation de la fonction huge

write(*,*)"Le plus grand entier ", huge (0)
write(*,*)"Le plus grand réel ", huge (0.0)
write(*,*)"Le plus grand réel en double précision ",huge (0.0d0)
Déclaration implicit ou explicite ?

En FORTRAN, on a le choix d'utiliser un mode de déclaration des variables explcite dans lequel on déclare toutes les
variables ou un mode de déclaration implicite dans lequel on définit un type par défaut pour certaines variable.
L'instruction suivante impose que l'on déclare toutes les variables :
Déclaration de toute les variables

PROGRAM bonjour
implicit none
! toutes les variables doivent être déclarée
integer::i,j
double precision::d
! suite du programme utilisant i j et d
END PROGRAM bonjour
L'instruction suivante définit que toutes les variables qui commencent par une lettre entre i et n inclu soient de type
integer et que les autres soient de type real (on remarquera que i et n sont les deux premières lettres de integer). On peut
définir un type implicite pour les double précision en remplaçant real par double precision dans l'instruction suivante.
Déclaration implicite des

PROGRAM bonjour
implicit real (a-h,o-z)
! il est inutiles de déclarer les variables i,j et d de l'exemple précédent
! suite du programme utilisant i j et d
END PROGRAM bonjour
La commande implicit none est une nouveauté du FORTRAN90 et divise la communauté des utilisateurs de FORTRAN.
Certains considèrent que la déclaration implicite des variables simplifie et limite grandement la déclaration des
variables. D'autres trouvent que la déclaration implicite est dangereuse et rend plus difficle la lecture d'un programme.
Nous ne trancherons pas sur cette question ici, à chacun de faire son choix.
- 13 -
FAQ FORTRAN
Avantages de la déclaration implicite des variables

• Simplification et allègement de la déclaration des variables
Avantages de la déclaration explicite de toutes les variables

• Evite les erreurs duent aux fautes de frappes des variables
• Facilite la lecture d'un programme inconnue
- 14 -
FAQ FORTRAN
Sommaire > Les boucles

Comment dire Si ... et Sinon ... (Boucle IF THEN ELSE) ?
La structure If...Then...(ElseIf)...Else...EndIf permet d'introduire des conditions et d'exécuter certaines lignes de code
si ces conditions sont vrais.
Syntaxe générale d'une boucle IF

If ( condition1 ) Then
! instructions à réaliser si condition1 est vrai
ElseIf (condition2 ) Then
ElseIf (condition3 ) Then
Else
! instructions à réaliser si aucun des trois conditions n'est vrai
Endif
Si on a une seule condition et une seule instruction, on peut également utiliser le If logique dont la syntaxe est :
Syntaxe du If logique
If ( condition ) instruction à réaliser si condition est vrai
Comment écrire une condition d'égalité ?

En programmation le signe = est réservé à l'assignation d'une valeur à une variable. Pour tester l'égalité de deux
variables on utilise le signe == (.eq. en FORTRAN77).
! écrire i et j s'ils sont égaux

If (i == j ) write(*,*)"i et j sont égaux"
Il est dangereux d'écrire une condition d'égalité entre des réels. En effet, les nombres réels sont soumis à un arrondi du à
leur enregistrement sur un nombre limité de bits. Il s'en suit que la manipulation des réels peut conduire à l'introduction
d'erreur numérique. Celle-ci sont généralement suffisament faible pour ne pas perturber les résultats mais aboutissent
au fait que 2 réels ne sont, en pratique, jamais égaux car ils n'ont pas été arrondis de la même manière.
Quelle est la différence entre = et == ?

En fortran comme dans la plupart des langage de programmation le signe = se lit "reçoit" et sert à assigner une valeur
à une variable. Le signe == sert lui à tester l'égalité entre deux variables.
! on affecte 1 à la variable i
i = 1
! on teste si i et j sont égaux
- 15 -
FAQ FORTRAN
If (i == j ) write(*,*)"i et j sont égaux"
Comment écrire supérieur, inférieur, supérieur ou égal et inférieur ou égal ?

Le tableau suivant récapitule les différents comparateurs :
Comparateur Symbole en FORTRAN90 Symbole en FORTRAN77

supérieur i>j i .gt. j
supérieur ou égal i >= j i .ge. j
Inférieur i<j i .lt. j
Inférieur i <= j i .le. j
Différent i /= j i .ne. j
Quels sont les opérateures logiques ?

Le tableau suivant regroupe les différents opérateurs logiques.
Opérateur Effet
condition1 .AND. condition2 condition1 ET condition2
condition1 .OR. condition2 condition1 OU condition2
.NOT. condition1 L'inverse de condition1
Exemple d'utilisation d'opérateur logique

If ( i > 10 .AND. i < 20 ) Then
! i est entre 10 et 20
ElseIf ( i == 10 .OR. i == 20 ) Then
! i égale 10 ou 20
ElseIf ( .NOT. i == 1 ) Then
! i n'est pas égal à 1
Endif
Comment faire répéter une série d'instructions (boucle DO) ?

Il est quelque fois intéressant de répéter un grand nombre de fois une même instructions sur une série de variables.
La boucle DO...ENDDO est faite pour ça. Dans l'exemple suivant on va répéter les instructions pour des valeurs d'un
entier i allant de l'entier debut à l'entier fin par incrément de pas.
Syntaxe générale d'une boucle DO

! i est un entier qui sert de compteur
integer::i,debut,fin,pas
Do i=debut,fin,pas
! instructions
Enddo
Voici par exemple comment calculer la somme des 20 premiers entiers :
- 16 -
FAQ FORTRAN
Somme des 20 premiers entiers

PROGRAM somme
implicit none
integer::i,som
Do i=1,20,1
som = som + 1
Enddo
write(*,*)"somme :",som
END PROGRAM somme
Les éléments définissant le debut, la fin et le pas de la boucle peuvent être des expressions arithmétiques entières.
Il est possible de ne pas définir de compteur et de faire une boucle infinie. Il faut alors ajouter une instruction de sortie
à l'intérieur de la boucle en utilisant la commande exit
Comment sortir prématurément d'une boucle DO ?

Il est parfois intéressant de pouvoir sortir d'une boucle d'où avant la fin du compteur. Ou encore de ne pas mettre de
compteur et de sortir de la boucle lorsqu'une condition est réalisée. Pour cela on se sert de la commande exit
Do i=1,10,1
! instructions
If( condition ) exit ! si condition est vrai on sort de la boucle
Enddo
Comment passer une itération d'une boucle DO ?

Supposons que le compteur d'une boucle DO...ENDDO aille de 1 à 10 mais que l'on ne veux pas passer par la valeur 6.
Dans ce cas on utlise la commande cycle pour passer la valeur 6 du compteur et recommencer à l'itération 7.
Exemple
Do i=1,10,1
If( condition ) cycle ! si condition est vrai on passe à l'itération suivante
! instructions
Enddo
Comment construire une liste de choix (SELECT CASE) ?

Soit choix un entier. La boucle Select Case permet en fonction de la valeur de choix d'exécuter une série d'instructions.
Il s'agit en fait d'une boucle du même genre qu'une série d'instruction If ElseIf EndIf.
Boucle select case

Select case(choix)
case(1)
! si choix égal 1 exécuter les instructions suivantes
case(2,3)
- 17 -
FAQ FORTRAN
Boucle select case

! si choix égal 2 ou 3 exécuter les instructions suivantes
case(4:10)
! si choix est compris entre 4 et 10 inclus exécuter les instructions suivantes
case(11:)
! si choix est suppérieur ou égal à 11 exécuter les instructions suivantes
case default
! sinon exécuter les instructions suivantes
End Select
- 18 -
FAQ FORTRAN
Sommaire > Où l'on apprend à lire écrire et compter !

Comment faire écrire quelque chose ?
On utilise tout simplement la traduction litérale de l'anglais, la commande write dont voici la syntaxe générale :
Syntaxe générale de la commande write

write( "où" , "comment")
! où = où est ce que je dois écrire.
! comment = comment est ce que je dois écrire, le format.
On spécifie où est ce qu'on doit écrire en donnant le numéro logique de la sortie à utiliser. Par exemple, 6 désigne l'écran.
On spécifie comment est ce qu'on doit écrire en donnant le format faire un lien vers format.
Un exemple d'utilisation de la commande write

! exemples pour écrire bonjour
! sur la sortie standard au format standard

write(*,*)"bonjour"
! sur la sortie 18 au format a qui est celui des chaine de caractères

write( 18 , "(a)" )"bonjour"
Les étoiles désignes les valeurs par défaut. La sortie standard de la commande write est l'écran, Le format étoile est
un format standard qui dépend des compilateurs. En général, les numéros logiques de 1 à 10 sont réservés et désignent
divers périfériques de l'ordinateur (par exemple 6 est l'écran). Les nombres suivants peuvent être attribué à des fichiers
ou d'autres périfériques.
Si l'on souhaite écrire plusieurs variables ou chaînes de caractères, on les sépare par une virgule.
Exemple avec plusieurs variables

real::a,b,c
a = 2.0
b = 4.0
c = 6.0
write(*,*)"a = ",a," b = ",b," c = ",c
Comment lire quelque chose ?

On utilise tout simplement la traduction litérale de l'anglais, la commande read dont voici la syntaxe générale :
Syntaxe générale de la commande read

read( "où" , "comment" )
! où = où est ce que je dois lire
! comment = comment est ce que je dois lire
On spécifie où est ce qu'on doit lire en donnant le numéro logique de l'entrée à utiliser. Par exemple, 5 désigne le clavier.
On spécifie comment est ce qu'on doit lire en donnant le format dans lequel est écrit ce que l'on souhaite lire. faire
un lien vers format.
- 19 -
FAQ FORTRAN
Exemples de lectures avec la commande read

! on demande à l'utilisateur de saisir un entier
write(*,*)"écrire un entier positif"
! on lit l'entier sur * = le clavier au format * et on l'enregistre dans entier
read(*,*)entier
! on affiche à l'écran l'entier que l'on vient de lire
write(*,*)"vous avez écris ",entier
La structure précédente contenant un write-read-write est vivement recommandée car elle permet de vérifier ce que
l'on a lu.
Pour lire plusieurs variables en même temps, on les sépare par une virgule. Dans l'exemple suivant, l'utilisateur devra
saisir son nom puis tapper "Entrée", puis saisir son prénom et tapper "Entrée".
Exemples de lectures avec la commande read

write(*,*)"Quel est votre nom et votre prenom ?"
read(*,*)nom,prenom
write(*,*)" nom = ",nom," prenom = ",prenom
Comment imprimer quelque chose à l'écran ?

Pour écrire quelque chose à l'écran, on va utiliser la commande write, en spécifiant le numéro logique de l'écran, 6, ou
en utilisant la sortie standard, *, qui correspond à l'écran.
Exemple d'impression à l'écran

write(6,*)"coucou"
write(*,*)"coucou"
Comment lire une entrée au clavier ?

Pour lire quelque chose à partir du clavier, on va utiliser la commande read, en spécifiant le numéro logique du clavier,
5, ou en utilisant l'entrée standard, *, qui correspond au clavier.
Exemple de lecture au clavier

! lecture d'un entier au clavier
read(5,*)entier
read(*,*)entier
Comment repérer une erreur de lecture ?

Avec err
On peut utiliser l'option err dans l'instruction read pour renvoyé l'exécution du programme à une certaine ligne du
code repérée par une étiquette s'il y a une erreur de lecture. Dans ce cas il est nécessaire d'utiliser le format fixe.
- 20 -
FAQ FORTRAN
Exemple d'utilisation de err

PROGRAM erreur
implicit none
integer::entier
write(*,*)"entrer un entier"
read(*,"(i5)",err=100)entier ! lecture avec un format i5
write(*,"(i5)")entier ! écriture avec un format i5
! suite des instructions
STOP "fin normale du programme"

100 STOP "erreur de lecture"
END PROGRAM erreur
Avec iostat
On peut utiliser l'option iostat dans l'instruction read qui permet d'enregistrer dans un entier un nombre qui permet
d'indentifier s'il y a une erreur et de quel type. La valeur de l'entier dépend du compilateur mais son signe est normalisé.
Si l'entier est nul, il n'y a pas d'erreur. Dans le cas de la lecture d'un fichier, une valeur négative signifie que l'on a
atteint la fin du fichier. Une valeur positive signifie toujours une erreur.
Exemple d'utilisation de iostat

PROGRAM erreur
implicit none
integer::entier,io
write(*,*)"entrer un entier"
read(*,"(i5)",iostat=io)entier ! lecture avec un format i5
If( io /= 0 ) Then
write(*,"(i5)")entier ! écriture avec un format i5
Else
STOP "erreur de lecture"
Endif
! suite des instructions

...
END PROGRAM erreur
Comment faire une opération mathématique ?

On utilise les symboles habituels des opérations d'additions (+), de soustractions (-), de multiplications (*) et de la
division (/). La puissance se fait par une double étoile.
Opérateurs mathématiques
PROGRAM calcul
implicit none
integer::i,j,som,sous,prod,div,pui
i = 2
j = 3
! addition de i et j
som = i + j
! soustraction de i et j
sous = i - j
- 21 -
FAQ FORTRAN
Opérateurs mathématiques
! multiplication de i et j
prod = i * j
! division de i et j
div = i / j
! i puissance j
pui = i ** j
END PROGRAM calcul
- 22 -
FAQ FORTRAN
Sommaire > Les fichiers

Comment est écrit le contenu d'un fichier ?
Il existe deux types de fichiers : les fichiers ASCII et les fichiers binaires. Les fichiers ASCII sont des fichiers dans
lesquels ce qui est écrit est formaté et lisible par quelqu'un, par exemple un fichier texte. Comme leur nom l'indique
les fichiers binaires sont écrits en langage binaire et ne sont pas directement lisible par quelqu'un. Il doit se servir d'un
programme pour les lires et formater ce qu'ils contiennent.
En FORTRAN, on peut créer soit des fichiers formatés (ASCII) soit des fichiers binaires et lire ou écrire sur ces deux
types de fichiers. Pour cela on spécifie lors de l'ouverture du fichier de quel type il est avec l'option form.
Choix du type de contenu d'un fichier

! ouverture d'un fichier binaire
open(11, file="fichier_binaire", form="unformatted")
! ouverture d'un fichier ASCII

open(11, file="fichier_ASCII", form="formatted")
Par défaut, si l'on ne précise pas l'option form dans l'instruction open les fichiers sont formatés (ASCII).
Comment lire ou écrire dans un fichier ?

On utilise les instructions read et write en spécifiant le numéro logique attribué au fichier sur lequel on veut écrire. La
syntaxe de lecture va dépendre de l'accès (direct ou séquentiel) et du type de contenu des fichiers (ASCII ou binaire) :
Exemple lecture écriture dans un fichier

! pour lire sur un fichier séquentiel formaté
write( "où", "comment")
! pour écrire sur un fichier séquentiel formaté

read( "où", "comment")
! on associe le fichier toto au numéro logique 11

open(11,file="toto",form="formatted",access="sequential")
! on lit un entier sur toto

read(11,*)entier
! on écrit un entier sur toto

write(11,*)999,entier
! pour lire/écrire sur un fichier binaire on ne précise pas le format

open(11,file="fichier_binaire",form="unformatted")
write(11)entier
read(11)entier
! pour lire/écrire sur un fichier à accès direct on précise l'enregistrement à lire

opent(11,file="fichier_direct",form="unformatted",access="direct")
write(11,rec=3)entier
- 23 -
FAQ FORTRAN
Exemple lecture écriture dans un fichier

read(11,rec=10)entier
Comment FORTRAN accède-t-il au contenu d'un fichier ?

Chaque ligne d'un fichier s'appelle un enregistrement. En fortran il existe deux moyens d'accéder au contenu d'un
enregistrement : un accès direct ou un accès séquentiel. Dans un accès direct, on lit ou écrit directement l'emplacement
que l'on veut. Dans un accès séquentiel, il est nécessaire de lire tous les emplacements qui précèdent celui que l'on
souhaite lire.
De façon imagée, on peut assimiler une lecture à accès séquentiel à la lecture d'une cassette vidéo (il faut lire le début
de la cassette avant de lire la partie qui nous intéresse) ; on peut assimiler une lecture à accès direct à la lecture d'un
CD ou DVD sur lequel on lit directement la musique ou le chapitre que l'on souhaite.
Les enregistrement des fichiers à accès direct ont une taille fixe qui est déterminée à l'ouverture du fichier. Celle des
fichiers à accès séquentiel peut varier d'un enregistrement à l'autre. Si la taille des enregistrement varie beaucoup d'une
ligne à l'autre, il s'ensuit qu'un fichier séquentiel est généralement plus léger qu'un fichier direct.
On précise le type d'accès aux enregistrements du fichier par l'option acces de l'instruction open. Dans le cas d'un accès
direct il faut également préciser la longueur des enregistrements par l'option recl qui est un entier correspondant au
nombre de caractères pour les fichiers ASCII.
Choix du type d'accès aux enregistrement d'un fichier

! ouverture d'un fichier à accès direct avec 100 caractères par enregistrement (=lignes)
open(11, file="fichier_direct", acces="direct", recl=100)
! ouverture d'un fichier à accès séquentiel

open(11, file="fichier_sequentiel", acces="sequential")
Comment ouvrir un fichier ?

Pour agir sur un fichier depuis un proramme fortran on lui attribue un numéro logique. Pour cela, on utilise l'instruction
open. Le numéro logique définit le chemin qui permettra d'accéder au fichier pour le lire ou écrire dedans.
Les numéros logiques inférieurs à 10 sont réservés, on ne les utilise pas.
Synataxe générale de open

! syntaxe minimale
open( numero , file="nom du fichier")
! exemples
open( 11, file="monfichier")
open( 23, file=fichier) ! où fichier est une variable chaine de caractère
open( i, file="monfichier) ! où i est un entier ou une exepression arithmétique
Par défaut les fichiers sont des fichiers ASCII (formatés) et à accès séquentiel. Voici une syntaxe plus complète de
l'instruction open. Pour connaître l'ensemble des options consulter l'un des cours disponibles.
- 24 -
FAQ FORTRAN
Syntaxe plus complète de open

! syntaxe complète
open( numero , file="mon_fichier", acces="sequential"/"direct", &
form="formatted"/"unformatted", &
action="read"/"write"/"readwrite", &
position="asis"/"rewind"/"append" )
Comment fermer un fichier ?

Les fichiers sont automatiquement fermés si l'exécution rencontre une instruction stop ou end. On peut fermer un
fichier avant la fin de l'exécution du programme avec l'instruction close.
syntaxe de l'instruction close

! fermeture du fichier
close( numero logique du fichier)
! exemples
close(11)
close(i)
close(2*i + 1)
Comment protéger un fichier en écriture ?

S'il vous arrive d'écraser un de vos fichiers au cours de l'exécution de vos programmes cette option de l'instruction open
est faites pour vous. Elle permet à l'ouverture du fichier de définir ses permissions de lecture et d'écriture.
Choix des permissions à l'ouverture d'un fichier

! ouverture en lecture seule
open(numero, file="mon_fichier", action="read")
! ouverture en écriture seule

open(numero, file="mon_fichier", action="write")
! ouverture en lecture et écriture (défaut)

open(numero, file="mon_fichier", action="readwrite")
Comment tester l'existance d'un fichier ?

Il peut être utile à l'intérieur d'un programme fortran, de détecter l'existence d'un fichier avant de lire ou écrire dedans.
Pour cela on utilise l'instruction inquire. Elle ne se limite pas à cela mais voici un exemple d'utilisation pour tester
l'existence d'un fichier.
! on utilise une variable logique

logical::exite
! on teste l'existence de mon_fichier

inquire( file="mon_fichier", exist=existe)
! la réponse est dans la variable existe

If ( existe ) Then
- 25 -
FAQ FORTRAN
! existe = .true.
write(*,*)"le fichier existe"
ElseIf( .NOT. existe) Then
! existe = .false.
write(*,*)"le fichier n'existe pas"
STOP
Endif
Comment écrire directement à la fin d'un fichier ?

Par défaut, à l'ouverture d'un fichier, on écrit ou on lit sur la première ligne du fichier. Dans l'instruction open l'option
position permet de choisir la ligne sur laquelle on se positionne lors de l'ouverture du fichier.
Ecrire à la fin du fichier

! on ouvre le fichier avec position = "append"
open( 10, file="mon_fichier", position="append")
! on va écrire à la suite du fichier

write(10,*)"j'écris sur la dernière ligne"
Comment repérer la fin d'un fichier ?

Lors de la lecture d'un fichier, on peut rajouter dans l'instruction read l'option end=etiquette qui permet de renvoyer
l'exécution du programme à la ligne marquée par l'étiquette lorsque l'on atteind la fin du fichier. Dans ce cas il faut
utiliser les étiquettes et le format fixe.
Détection de la fin du fichier avec end

! on va lire un fichier dont on ne connait pas le nombre de ligne
open(10, file="fichier")
i=0
Do
read(10,*,end=1000)var1,var2
i = i + 1
Enddo
1000 write(*,*)"la lecture a atteind la fin du fichier"
write(*,*)"le nombre de ligne est : ",i
Lors de la lecture d'un fichier, on peut rajouter dans l'instruction read l'option iostat=entier. Si la fin du fichier est
atteinte, entier prendra une valeur négative. La valeur dépend du compilateur on testera donc simplement le signe.
Détection de la fin du fichier avec iostat

! on va lire un fichier dont on ne connait pas le nombre de ligne
open(10, file="fichier")
i=0
Do
read(10,*,iostat=io)var1,var2
If( io < 0 ) exit
i = i + 1
Enddo
write(*,*)"la lecture a atteind la fin du fichier"
- 26 -
FAQ FORTRAN
Détection de la fin du fichier avec iostat

write(*,*)"le nombre de ligne est : ",i
- 27 -
FAQ FORTRAN
Sommaire > Les chaînes de caractères

Comment affecter une valeur à une chaîne de caractères ?
Une chaîne de caractères se note entre guillemets simples ou doubles. On affecte une valeur à une chaîne de caractères
avec le signe = comme pour les autres types de variable.
Exemple de chaîne de caractères

character(len=20)::chaine
chaine = "une chaine de caractère"
Une chaîne de caractères a une certaine longueur, donnée lors de sa déclaration (le paramètre len). Elle ne peut
pas contenir plus de caractères que le nombre indiqué lors de sa déclaration. Si la chaîne de caracères que l'on
veut enregistrer dans une variable est plus longue que la longueur de la variable, seuls les premiers caractères sont
enregistrés. Si la chaîne de caractères que l'on veut enregistrer dans une variable est plus courte que la longueur de la
variable les caractères manquants sont complétés par des espaces (peut dépendre du compilateur).
Exemples
character(len=4)::courte
character(len=20)::longue
courte = "bonjour"
! la variable courte ne contient que "bonj"
longue = "bonjour"
! la variable longue contient "bonjour "
Comment trouver la longueur d'une chaine de caractère ?

On utilise la fonction len qui renvoie un entier dont la valeur est la longueur de la chaine.
Utilisation de len
character(len=100)::mot
integer::long
! longueur de mot
long = len(mot)
mot = "bonjour"
! dans mot on a mis la chaine de caractères "bonjour" pour connaitre la longueur
! de cette chaine on doit en premier supprimer les blancs en bout de chaine
! on utilise trim
long = len( trim( mot ) )
! dans ce cas long = 7 qui est la taille de bonjour
Comment repérer une sous-chaine dans une chaine ?

La fonction index(chaine1,chaine2) renvoit un entier dont la valeur est égale à la position du premier caractère de
chaine2 dans chaine1. Si chaine2 n'est pas présente dans chaine1 elle renvoit 0.
- 28 -
FAQ FORTRAN
Cette fonction peut être très utile par exemple pour repérer une ligne dans un fichier où est inscrit un repère.
Exemple d'utilisation de index

...
character(len=100)::ligne
integer::k
! ouverture du fichier
open(10,file="resultats",action="read")
! recherche du repère
Do
ligne = ""
read(10,"(a)")ligne
k = index( ligne , "repere" )
! si k n'est pas 0 c'est que ligne contient "repere"
If( k /= 0 ) exit
Enddo
! lecture des informations souhaitées sur ligne ou sur la suite du fichier

...
Comment lire et écrire dans une chaine ?

Les commandes read et write permettent de lire ou écrire dans une chaîne de caractère. Il suffit d'inscrire le nom de la
chaîne de caractère dans source de lecture ou la destination d'écriture.
Exemple de lecture ou écriture dans une chaîne de caractère

! écriture dans num
integer::k
character(len=4)::num
k=1234
write(num,"(i4)")k
! * * * * * * * * *
! lecture dans ligne

character(len=100)::ligne
character(len=4)::var
! ligne contient " x = 3 "

read(ligne,*)var,entier
L'écriture dans une variable chaîne de caractère par rapport à une simple affectation présente l'intérêt que l'on peut
choisir le format dans lequel on écrit.
Comment supprimer les espaces à la fin d'une chaîne de caractères ?

On utilise la fonction trim qui renvoie une chaîne de caractères dans laquelle les espaces à la fin de la chaîne ont été
supprimés.
Exemple d'utilisation de la fonction trim

- 29 -
FAQ FORTRAN
Exemple d'utilisation de la fonction trim

chaine = "bonjour"
write(*,*)chaine,"XX"
! résultats :bonjour XX
write(*,*)trim(chaine),"XX"
! résultats :bonjourXX
Attention, fortran complète les automatiquement les chaînes de caractères par des espaces, donc si on remplace
le contenu d'une variable chaîne de caractère par son contenu en ayant supprimé les espaces ils sont rajoutés
automatiquement pour compléter la longueur de la variable chaîne de caractères.
Attention à la longueur des chaînes

! on reprend l'exemple précédent
character(len=7)::courte
chaine = "bonjour"
! chaine contient "bonjour "
chaine = trim(chaine)
! comme les caractères manquants sont complétés par des espaces
! chaine contient toujours "bonjour "
courte = trim(chaine)
! courte contient "bonjour"
La fonction trim est très utile pour écrire des noms de fichier dans une variable chaîne de caractères car elle permet
d'avoir des noms de fichier sans espaces.
- 30 -
FAQ FORTRAN
Sommaire > Les variables indicées (listes, tableaux ...) :

Qu'est ce qu'une variable indicée ?
Une variable simple correspond à une zone mémoire et contient une valeur. Il est possible de regrouper sous un même
nom de variable un ensemble de zone mémoire et donc un ensemble de valeurs. Chaque valeur (ou zone mémoire) de
la même variable est alors repérés par un indice.
C'est variables sont, par exemple, des listes (variables à un indices) ou des tableaux (variables à 2 indices) ect ... Elles
sont très largement utilisée dans les programmes.
Comment déclarer une variable indicée ?

Pour déclarer une variable indicée, il faut préciser son type (entier, réel, chaîne de caractères ...) et sa dimension, c'est
à dire le nombre d'éléments qu'elle contient.
Pour ce qui est de la dimension, depuis Fortran90 on a deux possibilités : une déclaration statique ou dynamique. Dans
une déclaration statique, la dimension de la variable est donnée au départ et est fixée pour le reste du programme. A
l'exécution du programme une zone mémoire dont la taille dépend de la dimension est réservée pour toute la durée
de l'exécution.
Déclaration statique
! une liste d'entier
integer,dimension(1:10)::liste
! un tableau de réel double précision

double precision,dimension(1:10,-5:5)::tableau
! un autre tableau de réel double précision

double precision,dimension(10,10)::tableau
! cette déclaration est équivalente à
double precision,dimension(1:10,1:10)::tableau
On remarque que lorsqu'on donne la dimension d'une liste ou d'un tableaun, on peut préciser les valeurs min et max
des indices. Ceux-ci ne commencent pas forcément à 1 ou 0. Dans le troisième exemple on ne donne que la dimension,
10, l'indice commence alors à 1.
Dans une déclaration dynamique, on ne précise que le nombre d'indices souhaités. Puis, pendant l'exécution, on alloue,
avec la commande allocate, la mémoire nécessaire au moment ou on a besoin de la variable. On peut ensuite libérer la
zone mémoire lorsqu'on n'en a plus besoin, avec la commande deallocate.
Déclaration dynamique
! une liste d'entier
integer,dimension(:),allocatable::liste
allocate( liste( ndim ) )

....
deallocate( liste(:) )
! un tableau de réel double précision

double precision,dimension(:,:),allocatable::tableau
allocate( tableau( 1:ndim ,-ndim:ndim ) )

....
- 31 -
FAQ FORTRAN
Déclaration dynamique
deallocate( tableau(:,:) )
L'intérêt d'allouer les variables indicées de façon dynamique est de n'utiliser que la mémoire nécessaire au moment où
on en a besoin. De plus, on peut calculer la dimension d'une variable indicée dans le programme et avoir une variable
indicée de la dimension souhaitée.
Remarque : Dans les sous programmes la déclaration dynamique est impossible, sauf dans le cas des modules.
Dans le cas de la déclaration statique, l'utilisation des paramètres pour déclarer les dimensions des variables est utile.
Comment affecter une valeur à une variable indicée ?

On utilise la même syntaxe que pour une variable normale, sauf qu'il faut préciser le ou les indices.
Affecter une valeur

! liste des premiers entiers impairs
liste(1) = 1
liste(2) = 3
liste(3) = 5
liste(4) = 7
! la matrice unité en dimension 2

M(1,1) = 1.d0 ; M(1,2) = 0.d0
M(1,1) = 0.d0 ; M(1,2) = 1.d0
Comment agir sur tout ou une partie d'une variable indicée ? (Fortran90)
En fortran77, pour agir sur plusieurs éléments d'une variable indicée, il faut écrire une instruction pour chaque élément
ou écrire une boucle. Le fortran90 permet d'agir sur plusieurs éléments en une seule instructions.
affectation multiple
integer,parameter::ndim=10
integer,dimension(1:ndim)::liste
double precision,dimension(ndim,ndim)::matrice
! liste(:) se réfère à l'ensemble des éléments de liste

! matrice(:,:) se réfère à l'ensemble des éléments de matrice
! j'affecte 0 à tous les éléments de liste

liste(:) = 0
! j'affecte 0.d0 à tous les éléments de matrice

matrice(:,:) = 0.d0
! on met un 1.d0 dans la première ligne de matrice

matrice(1,:) = 1.d0
! on met un 2 dans les éléments de ndim/2 à ndim de liste

liste( ndim/2 : ndim ) = 2
- 32 -
FAQ FORTRAN
Remarque : Il n'est pas nécessaire de préciser les : entre parenthèses, le nom de la variable est suffisant. Cependant par
un souci de clarté et de lisibilité du programme il est préférable de l'écrire.
Comment faire des opérations sur des variables indicées ? (Fortran90)

Le fortran 90 permet d'additionner et soustraire des variables indicées de même dimension sans utiliser de boucles. On
utilise simplement les opérations standards comme pour une variable normale.
Exemple d'opérations
double precision,dimension(3)::u,v,w,x
! somme de deux vecteurs

w(:) = u(:) + v(:)
! différence de deux vecteurs

w(:) = u(:) - v(:)
! ou encore
w(:) = 3.d0*u(:) - 0.5d0*v(:) + 2.d0*x(:)
La multiplication ou division de variables indicées ayant un sens particulier (produit scalaire, produit de matrice), des
fonctions spéciales sont disponibles.
Remarque : Il n'est pas nécessaire de préciser les : entre parenthèses, le nom de la variable est suffisant. Cependant par
un souci de clarté et de lisibilité du programme il est préférable de l'écrire.
Comment additionner tous les éléments d'une variables indicées ? (Fortran90)

On utilise la fonction sum(arg).
Exemple de somme
double precision,dimension(ndim)::liste
double precision::somme
somme = sum( liste(:) )
! normalisation de liste
liste(:) = liste(:) / sqrt( sum( ( liste(:) )**2 ) )
somme = sum( matrice(:,:) )
Comment multiplier tous les éléments d'une variable indicée ? (Fortran90)

On utilise la fonction product(arg).
Exemple de produit
- 33 -
FAQ FORTRAN
Exemple de produit
double precision,dimension(ndim)::liste
double precision::produit
produit = product( liste(:) )
produit = product( matrice(:,:) )
Comment transposer une matrice ? (Fortran90)

On utilise la fonction transpose(arg).
Exemple de produit
double precision,dimension(ndim,ndim)::A,tA
tA(:,:) = transpose( A(:,:) )
Comment multiplier deux matrices ? (Fortran90)

On utilise la fonction matmult(arg1,arg2) qui permet de faire un produit de matrice. Il est cependant nécessaire que le
premier indice soit celui de la ligne et le second celui de la colonne.
Produit de matrices
double precision,dimension(ndim,ndim)::A,B,P
double precision,dimension(ndim)::X,Y
! Le produit de matrice A*B

P(:,:) = matmult( A(:,:) , B(:,:) )
! Matrice vecteur
Y(:) = matmult( A(:,:) , X(:) )
ATTENTION : Comme dans un produit de matrice, le nombre de colonnes du premier argument de matmult doit être
égal au nombre de lignes du second argument.
Comment calculer un produit scalaire ? (Fortran90)

On utilise la fonction dot_product(arg1,arg2), qui calcule le produit scalaire des vecteurs donnés en arguments 1 et 2.
Exemple de produit scalaire

double precision,dimension(ndim)::X,Y
double precision::scalaire
scalaire = dot_product( X(:) , Y(:) )
- 34 -
FAQ FORTRAN
Sommaire > Le programme principal et les sous programmes

Quelle est la différence entre une FUNCTION et une SUBROUTINE ?
Les function et les subroutine sont littéralement traduits de l'anglais par fonction et sous-programme. Ce sont les deux
types de sous programmes disponnibles en Fortran.
Les différences majeures entre une fonction et une subroutine sont :

• Une function est également une variable qui contient le résultat de la fonction alors que le ou les résultats d'une
subroutine sont en paramètres. Il s'ensuit qu'une fonction doit être déclarée.
• Pour appeler une subroutine on utilise la commande call alors qu'une function n'en a pas besoin.
• Une function doit forcément renvoyer un résultat stocké dans une variable (qui peut être un tableau). Une
subroutine peut ne renvoyer aucun résultat et juste réaliser une action (écrire dans un fichier, nettoyer
l'écran ...).
Les fonctions
Voyons un exemple simple d'une fonction et de son appel. Une fonction est, par exemple, de la forme f(x) = a*x + b.
Voici un programme qui utilise cette fonction :
Un exemple de fonction
PROGRAM test_function
! programme principal
implicit none
integer::i
real::f,a,b,x,y
a = 1.d0
b = 2.d0
x=0.d0
Do i=1,100
x = x + 0.1d0
write(*,*)x,f(a,b,x) ! appel de la fonction
Enddo
! autre exemple
x=0.d0
Do i=1,100
x = x + 0.1d0
y = f(a,b,x) ! appel de la fonction
write(*,*)x,y
Enddo
END PROGRAM test_function
! * * * * * * * * * * * *
FUNCTION f(a,b,x)
implicit none
real,intent(in)::a,b,x
real::f ! dans une fonction son nom est déclaré
f = a*x + b ! quelque part dans une fonction on doit assigner une valeur à f
END FUNCTION f
Les subroutines
- 35 -
FAQ FORTRAN
Pour continuer l'exemple précédent, on peut programmer une subroutine qui va lire les paramètres a et b de la fonction
f(a,b,x).
Un Exemple de subroutine
PROGRAM test_function
! programme principal
! la subroutine n'est pas déclarée
implicit none
integer::i
real::a,b,f,x
call lec(a,b) ! on utilise call pour appeler une subroutine
x = 0.d0
Do i=1,100
x = x + 0.1d0
write(*,*)x,f(a,b,x)
Enddo
END PROGRAM test_function
! * * * * * * * * * * * * * *
SUBROUTINE lec(a,b)
implicit none
real,intent(out)::a,b ! on précise que a et b sont des argument de sortie
write(*,*)"entrer a et b"
read(*,*)a,b
write(*,*)"a = ",a
write(*,*)"b = ",b
END SUBROUTINE lec
! * * * * * * * * * * * * * *
FUNCTION f(a,b,x)
implicit none
real,intent(in)::a,b,x
real::f ! dans une fonction son nom est déclaré
f = a*x + b ! quelque part dans une fonction on doit assigner une valeur à f
END FUNCTION f
Les argument d'une subroutine peuvent être de plusieurs types

• argument sortant : integer,intent(out)::p1
• argument entrant : integer,intent(in)::p2
• argument entrant/sortant : integer,intent(inout)::p3
Les arguments entrants ne peuvent pas être modifiés dans la subroutine. Une subroutine doit assigner une valeur à
un argument sortant.
Comment récupérer un paramètre/argument en ligne de commande ?

Quand on travaille dans un terminal il arrive souvant qu'on rajoute à la suite d'un programme des paramètres. par
exemple : mon_programme.x p1 p2 p3. Pour récupérer p1, p2 et p3 on utilise la subroutine getarg.
- 36 -
FAQ FORTRAN
Utilisation de la subroutine getarg

call getarg( entier , chaîne de caractère)
L'entier correspond à la place de l'argument. Par exemple, dans notre cas, 1 correspond à p1, 2 à p2 et 3 à p3. La valeur
0 permet de récupérer le nom du programme. Ceci peut être mis à profit pour si l'exécutable est enregistré sous des
noms différents afin d'avoir une exécution différente selon le nom du programme. Les paramètres p1, p2 ou p3 sont
enregistrés dans une variable de type chaîne de caractères. Voici un exemple d'utilisation :
Exemple d'utilisation de getarg

PROGRAM test_getarg
implicit none
integer::i,p1,p2,p3
integer,dimension(3)::p
character(len=10)::parm,nom
! on récupère le nom du programme

call getarg(0,nom)
! on récupère les valeurs des paramètres

call getarg(1,parm)
read(parm,*)p1
call getarg(2,parm)
read(parm,*)p2
call getarg(3,parm)
read(parm,*)p3
! on peut faire une boucle

Do i=1,3
call getarg(i,parm)
read(parm,*)p(i)
Enddo
END PROGRAM test_getarg
Qu'est ce qu'une variable locale/globale ?

Une variable est une zone mémoire à laquelle on associe un nom pour pouvoir écire ou lire ce qu'elle contient. Lorsqu'on
utilise des sous programmes il faut savoir si les variables qu'on utilise sont accessibles par tous les sous programmes
(variables globales) ou juste dans le programme ou sous programme dans lequel elles sont déclarées.
En fortran toutes les variables déclarées au début d'un programme principal, d'une fonction ou d'une subroutine sont
des variables locales. Ainsi si l'on déclare un entier i dans 3 sous programme, ces 3 variables i seront associées à 3 zones
mémoires différentes et indépendantes.
Pour utiliser des variables globales, communes à plusieurs sous programmes, on utilise les common (fortran77) ou des
module (fortran90).
Comment passer des variables en arguments vers/depuis une subroutine ?

La méthode la plus simple pour qu'une subroutine et son programme appelant se passent des variables est de les mettre
comme arguments de la subroutine. Il faut ensuite préciser s'ils sont entrant (ils viennent du programme appelant et
- 37 -
FAQ FORTRAN
ne doivent pas être modifié), sortant (ils viennent de la subroutine vers le programme appelant et doivent être assignés)
ou les deux.
Exemple d'arguments
PROGRAM test_arg
implicit none
integer::a,b,c
a = 2
c = 1
call sub(a,b,c)
END PROGRAM test_arg
! * * * * * * *
SUBROUTINE sub(a,b,c)
! il n'est pas nécessaire que les arguments aient le même nom, seule la position est importante
! mais ça facilite la lecture du programme
implicit none
integer,intent(in)::a ! a n'est pas modifiable
integer,intent(out)::b ! b doit être assigné
integer,intent(inout)::c ! c peut être modifié
b = a + c
c = c + 1
END SUBROUTINE sub
Il n'est pas obligatoire de préciser l'intent, cela peut cependant éviter certaines erreurs et facilite la lecture du
programme.
Comment utiliser un common pour partager des variables entre sous programmes (F77) ?
Le common permet de déclarer un zone mémoire commune dans laquelle seront enregistrées des variables. Elles seront
accessibles par tous les sous programmes dans lesquels le common est déclaré. Reprenons l'exemple utilisé par les
arguments pour comparer.
Utilisation d'un common pour transferer des variables

! * * * *
! syntaxe d'un common
common /nom de la zone commune/ liste des variables
! * * * *
PROGRAM test_arg
implicit none
integer::a,b,c
common /arg/ a,b,c ! je déclare le common
a = 2
c = 1
call sub
! * * * * * * *
- 38 -
FAQ FORTRAN

SUBROUTINE sub
implicit none
integer::a,b,c
common /arg/ a,b,c ! j'utilise le common
b = a + c
c = c + 1
END SUBROUTINE sub
Il n'est plus nécessaire de donner les variables a,b et c en argument de la subroutine sub car elles sont accessibles par
l'intermédiaire du common.
Dans ce cas les variables de la zone commune sont toutes modifiables par la subroutine, pour préciser un intent il faut
utiliser les paramètres.
Pour ne pas avoir à reécrire dans chaque sous programme le common, il était courant d'inclure un fichier qui contenait
les variables du common. Ceci avait également l'avantage de ne pas avoir à modifier tous les common dans tous les sous
programmes à chaque modification. Voici un exemple :
Utilisation de include
PROGRAM test_arg
implicit none
include "arg"
a = 2
c = 1
call sub
! * * * * * * *
SUBROUTINE sub
implicit none
include "arg"
b = a + c
c = c + 1
END SUBROUTINE sub
! * * * * * * * * * * * * * * *
!contenu du fichier arg
integer::a,b,c
common /arg/ a,b,c
Comment utiliser un module pour partager des variables entre sous programmes (F90) ?
Les modules sont la grande nouveauté du fortran 90 et apporte au fortran un soupçon de programmation orientée
objet. L'utilisation des modules pour partager des variables entre des sous programmes n'est qu'une infime partie de
ce qu'ils apportent. Dans ce cas, leur utilisation est similaire à celle du common. On va créer un module, dans lequel
seront déclarées des variables qui seront disponnibles dans tous les sous programmes qui utilisent le module.
- 39 -
FAQ FORTRAN

MODULE arg
implicit none
integer::a,b,c
END MODULE arg
! * * * * * * *
PROGRAM test_arg
USE arg
implicit none
a = 2
c = 1
call sub
! * * * * * * *
SUBROUTINE sub
USE arg
implicit none
b = a + c
c = c + 1
END SUBROUTINE sub
L'utilisation d'un module apporte cependant une contrainte. Ils doivent être compilés avant le programme principal.
Plusieurs solutions sont possibles :
• Lors de la compilation placer le nom du module en premier, par exemple : ifort module.f90 program.f90
• Si le programme est court et que tous les sous programmes et modules sont dans un même fichier, placer les
modules en premier, en tête du fichier dans l'ordre qu'ils apparaissent. Puis compiler simplement le fichier
comme un programme normal.
• Compilez à l'avance vos modules (s'arréter à la compilation, création de l'objet). Puis lors de la compilation du
programme ajouter les .o des modules.
Pour les compilateurs ifort, g95 ou gfortran, la compilation (création de l'objet) se fait en ajoutant l'option -c.
Il est possible de n'utiliser qu'une partie d'un module avec l'instruction only. On va ainsi sélectionner les variables qui
seront accessibles et celles qui ne le seront pas. Voici un exemple :
Utilisation de only
MODULE arg
implicit none
integer::a,b,c
double precision::x
END MODULE arg
! * * * * * * *
PROGRAM test_arg
USE arg, only : a,c ! seuls a et c sont utiles
implicit none
a = 2
c = 1
- 40 -
FAQ FORTRAN
Utilisation de only
call sub
! * * * * * * *
SUBROUTINE sub
USE arg, only : a,b,c ! seuls a b et c sont utiles
implicit none
b = a + c
c = c + 1
END SUBROUTINE sub
- 41 -

Fa Q Fortran

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Fa Q Fortran

Transféré par

Droits d'auteur :

Formats disponibles

FAQ FORTRAN

Date de publication : Septembre 2008

Dernière mise à jour : 15 avril 2009

Germain Salvato-Vallverdu (Pageperso) -

1. Information générale : (12) ........................................................................................................................................................4

Sommaire > Information générale :

Cliquez simplement sur une question pour avoir la réponse.

Comment participer à cette FAQ ?

D'où vient le FORTRAN ?

Que signifie FORTRAN ?

Quel livre acheter ou lire ?

Une liste non exaustive de livres sur FORTRAN :

• Programmer en fortran 90, Claude Delannoy

• Savez-vous parler Fortran ?, Maryse Aïn

Où puis-je trouver des cours à télécharger et à consulter ?

Des cours sont disponnibles dans la rubriques FORTRAN sur développez.com.

Quels sont les compilateurs FORTRAN ?

Les outils pour écrire un programme FORTRAN ?

Logiciel pour windows que je ne connais pas ....

Des stations de travail que je ne connais pas non plus : workstation ?

Qu'elle est la structure d'un programme FORTRAN ?

• colonnes 1 à 5 : Etiquette éventuelle (label).

c declaration des variables

• Le code peut commencer à la première colonne.

! declaration des variables

Comment insérer un commentaire ?

Format libre insérer un commentaire

! je place un commentaire qui commence en début de ligne

write(*,*)"bonjour" ! j'écris bonjour

END PROGRAM bonjour

En format fixe on écrit un commentaire en plaçant un c dans la première colonne.

Comment stopper un programme ?

END PROGRAM nom_program

Remarque : Il suffit de END, le nom du programme est facultatif.

STOP "ligne 156"

Comment couper une ligne trop longue ?

END PROGRAM ligne

END PROGRAM ligne

Sommaire > Les variables en FORTRAN

Exemples de noms de variables

Quels sont les type de variables les plus usuels en fortran ?

Ils existent d'autres type de variables moins utilisés

Comment déclarer un nombre entier ?

Déclaration d'un entier

Déclaration d'un entier

Comment déclarer un nombre réel en simple précision ?

Déclaration d'un réel simple précision

! en fortran77 on précise le nombre d'octet

Qu'est ce qu'un nombre réel double précision ?

Déclaration d'un réel double précision

! en fortran 77 on précise le nombre d'octets

Comment déclarer une variable chaîne de caractères ?

Déclaration d'une chaine de caractère

! en fortran77 la syntaxe se rapproche de celle de la déclaration des réels

Déclaration d'une chaine de caractère

Comment déclarer une variable logique ?

Déclaration d'une variable logique

Comment utiliser des parametres ?

Déclaration d'un paramètre

! puis on se sert de p pour donner la dimension d'une variable indicée

! T est la température ambiante 300K

Comment calculer la partie entière d'un nombre réel ?

Calcul de la partie entière d'un réel

write(,)"bonjour" ! j'écris bonjour

If (i == j ) write(,)"i et j sont égaux"

write(,)"a = ",a," b = ",b," c = ",c