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.

 ! 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.

Comment dans la plupart 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, tenseurs etc ...).

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

Les variables contenant des nombres entiers sont de type integer

 ! i est un entier
 integer::i

Les variables contenant des nombres réels simple précision 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⁺³⁸. Leur précision est d'environ 10^-7. Un nombre réel simple précision a donc en général 7 chiffres significatifs.

 ! r est un nombre réel simple précision
 real::r   

 ! en FORTRAN77 on précise le nombre d'octets
 real*4 r

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 étendue que celle pouvant être enregistrée dans un réel simple précision. Elle s'étend environ de 10^-308 à 10⁺³⁰⁸ et donne des chiffres avec une précision d'environ 10^-15 soit 15 chiffres significatifs.

 ! 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

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

 ! 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
 character*100 mot

Une variable logique est de type logical. Elle prend deux valeurs possibles : .TRUE. ou .FALSE.

 ! test est une variable logique
 logical::test

Une variable peut être déclarée comme paramètre. On doit alors assigner sa valeur 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 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

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

 ! n est la partie entière de x
 n = int( x )

L'entier le plus proche d'un réel x est donné par la fonction nint().

 ! n est l'entier le plus proche de x
 n = nint( x )

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.

 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

Chaque variable est enregistrée dans un espace donné de la mémoire et sur un certain nombre d'octets. Il s'ensuit 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 veiller à ce qu'aucune des valeurs enregistrées dans une variable ne soit supérieure à ces limites.

Pour calculer ces valeurs il faut savoir comment sont enregistrés les nombres dans la mémoire de l'ordinateur. Les nombres entiers 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 à 2⁰, l'avant dernier à 2¹ 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 N_max = 1x2³⁰+1x2²⁹+1x2²⁸+...+1x2¹+1x2⁰

Donc N_max = 2147483647

Les nombres réels sont enregistrés sous forme scientifique 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.

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 2¹⁰²³ (et pas 10¹⁰²³). La gamme de nombres pouvant être enregistrée en réel double précision est donc entre 10^-308 et 10⁺³⁰⁸.

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⁺³⁸.

La fonction huge() permet d'afficher la valeur des nombres maximum utilisables.

 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)

En Fortran, on a le choix d'utiliser un mode de déclaration des variables explicite 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 variables.

L'instruction suivante impose que l'on déclare toutes 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.

 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 difficile la lecture d'un programme. Nous ne trancherons pas sur cette question ici, à chacun de faire son choix.

• Simplification et allègement de la déclaration des variables

• Evite les erreurs dues aux fautes de frappe des variables
• Facilite la lecture d'un programme inconnu