Types du fortran

Le type d’une variable détermine :
le nombre d’octets à réserver en mémoire
un mode de représentation interne
l’ensemble des valeurs admissibles
l’ensemble des opérateurs qui peuvent lui être appliqués
Types prédéfinis
INTEGER entier
CHARACTER caractère
LOGICAL deux valeurs, .TRUE. ou .FALSE.
REAL réel simple précision
DOUBLE PRECISION réel double précision COMPLEX complexe simple précision

Précision des nombres

Les types prédéfinis en Fortran 90 sont en fait des noms génériques renfermant chacun un certain nombre de variantes ou sous-types que l’on peut sélectionner à l’aide du paramètre KIND lors de la déclaration des objets.
Ce paramètre est un mot-clé à valeur entière. Cette valeur désigne la variante souhaitée pour un type donné.
Les différentes valeurs du paramètre KIND sont dépendantes du système utilisé. Elles correspondent, en général, au nombre d’octets désirés pour coder l’objet déclaré.

Rappel d’arithmétique flottante

Les nombres réels sont représentés de façon approximative en mémoire (représentation en virgule flottante), avec la convention standardisée de la forme m 2e, où m est la mantisse, 1 m 2 et e l’exposant.
Certains réels sont par définition impossibles à représenter en numération classique : 1=3, …
La représentation en un nombre fixe d’octets oblige le processeur à faire appel à des approximations afin de représenter les réels.
Le degré de précision de la représentation par virgule flottante des réels est directement proportionnel au nombre de bits alloué à la mantisse, alors que le nombre de bits alloué à l’exposant conditionnera l’amplitude de l’intervalle des nombres représentables.
Plusieurs propriétés de l’arithmétique (associativité, distributivité,…) ne sont plus valides en arithmétique flottante !
Utilisation de KIND
Exemples
r e a l ( kind =8) : : x ! r e e l double p r e c i s i o n
i n t e g e r ( kind =2) : : i ! e n t i e r code s u r 2 o c t e t s , i n t e g e r normal s u r 4
On peut indiquer le sous-type désiré lors de l’écriture des constantes en les suffixant (pour les constantes numériques) ou de les préfixant (pour les constantes chaînes de caractères) par la valeur du sous-type à l’aide du caractère « _ ».
Exemples
n = 23564_4 ! e n t i e r s u r 4 o c t e t s
x = 12.87976543245_8 ! r e e l s u r 8 o c t e t s
Fonction KIND
Renvoie la valeur entière qui correspond au sous-type de l’argument spécifié
Exemples
kind ( 1 . 0 ) ! v a l e u r associee au sous t y p e r e e l s i m p l e p r e c i s i o n
kind ( 1 . 0 d0 ) ! v a l e u r associee au sous t y p e r e e l double p r e c i s i o n
r e a l ( kind=kind ( 1 . d0 ) ) : : x ! d e c l a r e x comme r e e l double p r e c i s i o n
! q u e l l e que s o i t l a machine u t i l i s e e
Remarque
Les types définis via cette fonction KIND sont assurés d’être portables au niveau de la compilation.
Chaîne de caractères
Pour déclarer une chaîne de caractères on précise sa longueur. Si elle n’est pas indiquée elle est égale à 1.
Exemples
CHARACTER( len=n ) : : ch_car
CHARACTER : : c

Manipulation de chaînes

LEN_TRIM(string) : longueur (entier) de la chaîne débarrassée de ses blancs de fin
TRIM(string) : débarrasse string de ses blancs de fin
LGE(string_a, string_b) : VRAI si string_a « supérieure ou = » à string_b (Lexically Greater or Equal), et les variantes LGT, LLE, LLT (on peut aussi utiliser >=, >,<=, <).
ADJUSTL(string) : débarrasse string de ses blancs de tête (cadrage à gauche) et complète à droite par des blancs. Idem avec ADJUSTR à droite.

Instruction IMPLICIT NONE

Par défaut, les variables dont l’identificateur commence par les caractères I à N sont de type INTEGER.
Toutes les autres sont de type REAL.
L’instruction IMPLICIT NONE change cette règle car elle impose à l’utilisateur la déclaration de chaque variable.
Cette instruction est vivement recommandée car elle permet la détection d’un certain nombre d’erreurs à la compilation.
IMPLICIT NONE se place avant les déclarations des variables.
L’instruction ne s’applique qu’à l’unité de programme qui la contient.

Constantes littérales

Une constante réelle simple précision doit obligatoirement comporter :
I soit le point décimal, même s’il n’y a pas de chiffres après la virgule
I soit le caractère E pour la notation en virgule flottante
Une constante double precision doit obligatoirement être écrite en virgule flottante, le E étant remplacé par un D
Une constante de type COMPLEX est obtenue en combinant deux constantes réelles entre parenthèses séparées par une virgule
Une constante chaîne de caractères est une suite de caractères encadrée par le délimiteur « ’ » ou «  » »
Exemples
x = 0 .
y = 1 . 0
z = 1.6e 04
d = 2 . 7 d 3
zero = 0 . d0
c p l x = ( 1 . 3 2 e 3, 4 . 3 )
CHARACTER (LEN=10) : : ch
ch =  » Bonjour  » ; ch ( 4 : 7 ) =  » s o i r « 

Initialisations

Une initialisation pourra s’effectuer au moyen de l’instruction DATA
I les variables initialisées par ce moyen héritent de l’attribut SAVE : leur emplacement mémoire est permanent
Fortran permet d’initialiser une variable lors de sa déclaration à l’aide du symbole « = »
I Dans ce cas, les caractères : : sont obligatoires
I Ces variables héritent aussi de l’attribut SAVE
Exemples
REAL a , b , c
INTEGER n
DATA a , b , n / 1 . 0 , 2 . 0 , 1 7 /
LOGICAL : : f l a g = .TRUE .
Constantes symboliques
L’attribut PARAMETER permet de donner un nom symbolique à une constante littérale
Exemples
INTEGER, PARAMETER : : n = 1000
DOUBLE PRECISION : : PI , ZERO
PARAMETER ( PI = 3.14159265d0 , ZERO = 0 . d0 )

1 Généralités
2 Déclarations & variables
3 Opérateurs et expressions
4 Structures de contrôles
5 Tableaux
6 Gestion de la mémoire
7 Types dérivés et modules
8 Procédures
9 Entrées-Sorties
10 Fonctions intrinsèques
11 Pointeurs
12 Travaux pratiques