Fortran - Numéros

Les nombres dans Fortran sont représentés par trois types de données intrinsèques -

Type entier
Type réel
Type complexe

Type entier

Les types entiers ne peuvent contenir que des valeurs entières. L'exemple suivant extrait la plus grande valeur qui pourrait être contenue dans un entier habituel de quatre octets -

program testingInt
implicit none

   integer :: largeval
   print *, huge(largeval)
   
end program testingInt

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

2147483647

Veuillez noter que le huge()La fonction donne le plus grand nombre que peut contenir le type de données entier spécifique. Vous pouvez également spécifier le nombre d'octets à l'aide dukindprescripteur. L'exemple suivant illustre ceci -

program testingInt
implicit none

   !two byte integer
   integer(kind = 2) :: shortval
   
   !four byte integer
   integer(kind = 4) :: longval
   
   !eight byte integer
   integer(kind = 8) :: verylongval
   
   !sixteen byte integer
   integer(kind = 16) :: veryverylongval
   
   !default integer 
   integer :: defval
        
   print *, huge(shortval)
   print *, huge(longval)
   print *, huge(verylongval)
   print *, huge(veryverylongval)
   print *, huge(defval)
   
end program testingInt

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647

Type réel

Il stocke les nombres à virgule flottante, tels que 2.0, 3.1415, -100.876, etc.

Traditionnellement, il y avait deux real types: le type réel par défaut et double precision type.

Cependant, Fortran 90/95 offre plus de contrôle sur la précision des types de données réels et entiers via le kind prescripteur, que nous étudierons sous peu.

L'exemple suivant montre l'utilisation d'un type de données réel -

program division   
implicit none

   ! Define real variables   
   real :: p, q, realRes 
   
   ! Define integer variables  
   integer :: i, j, intRes  
   
   ! Assigning  values   
   p = 2.0 
   q = 3.0    
   i = 2 
   j = 3  
   
   ! floating point division
   realRes = p/q  
   intRes = i/j
   
   print *, realRes
   print *, intRes
   
end program division

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

0.666666687    
0

Type complexe

Ceci est utilisé pour stocker des nombres complexes. Un nombre complexe comprend deux parties: la partie réelle et la partie imaginaire. Deux unités de stockage numériques consécutives stockent ces deux pièces.

Par exemple, le nombre complexe (3,0, -5,0) est égal à 3,0 - 5,0i

La fonction générique cmplx()crée un nombre complexe. Il produit un résultat dont les parties réelles et imaginaires sont en simple précision, quel que soit le type des arguments d'entrée.

program createComplex
implicit none

   integer :: i = 10
   real :: x = 5.17
   print *, cmplx(i, x)
   
end program createComplex

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

(10.0000000, 5.17000008)

Le programme suivant démontre l'arithmétique des nombres complexes -

program ComplexArithmatic
implicit none

   complex, parameter :: i = (0, 1)   ! sqrt(-1)   
   complex :: x, y, z 
   
   x = (7, 8); 
   y = (5, -7)   
   write(*,*) i * x * y
   
   z = x + y
   print *, "z = x + y = ", z
   
   z = x - y
   print *, "z = x - y = ", z 
   
   z = x * y
   print *, "z = x * y = ", z 
   
   z = x / y
   print *, "z = x / y = ", z 
   
end program ComplexArithmatic

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

(9.00000000, 91.0000000)
z = x + y = (12.0000000, 1.00000000)
z = x - y = (2.00000000, 15.0000000)
z = x * y = (91.0000000, -9.00000000)
z = x / y = (-0.283783793, 1.20270276)

La gamme, la précision et la taille des nombres

La plage des nombres entiers, la précision et la taille des nombres à virgule flottante dépendent du nombre de bits alloués au type de données spécifique.

Le tableau suivant affiche le nombre de bits et la plage des nombres entiers -

Nombre de bits	Valeur maximum	Raison
64	9 223 372 036 854 774 807	(2 ** 63) –1
32	2 147 483 647	(2 ** 31) –1

Le tableau suivant affiche le nombre de bits, la valeur la plus petite et la plus grande et la précision des nombres réels.

Nombre de bits	La plus grande valeur	La plus petite valeur	Précision
64	0,8E + 308	0,5E – 308	15 à 18
32	1,7E + 38	0,3E – 38	6-9

Les exemples suivants le démontrent -

program rangePrecision
implicit none

   real:: x, y, z
   x = 1.5e+40
   y = 3.73e+40
   z = x * y 
   print *, z
   
end program rangePrecision

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

x = 1.5e+40
          1
Error : Real constant overflows its kind at (1)
main.f95:5.12:

y = 3.73e+40
           1
Error : Real constant overflows its kind at (1)

Maintenant, utilisons un nombre plus petit -

program rangePrecision
implicit none

   real:: x, y, z
   x = 1.5e+20
   y = 3.73e+20
   z = x * y 
   print *, z
   
   z = x/y
   print *, z
   
end program rangePrecision

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

Infinity
0.402144760

Maintenant regardons le sous-flux -

program rangePrecision
implicit none

   real:: x, y, z
   x = 1.5e-30
   y = 3.73e-60
   z = x * y 
   print *, z
   
   z = x/y
   print *, z

end program rangePrecision

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

y = 3.73e-60
           1
Warning : Real constant underflows its kind at (1)

Executing the program....
$demo 

0.00000000E+00
Infinity

Le spécificateur aimable

En programmation scientifique, il est souvent nécessaire de connaître l'étendue et la précision des données de la plate-forme matérielle sur laquelle le travail est effectué.

La fonction intrinsèque kind() vous permet d'interroger les détails des représentations de données du matériel avant d'exécuter un programme.

program kindCheck
implicit none
   
   integer :: i 
   real :: r 
   complex :: cp 
   print *,' Integer ', kind(i) 
   print *,' Real ', kind(r) 
   print *,' Complex ', kind(cp) 
   
end program kindCheck

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

Integer 4
Real 4
Complex 4

Vous pouvez également vérifier le type de tous les types de données -

program checkKind
implicit none

   integer :: i 
   real :: r 
   character :: c 
   logical :: lg 
   complex :: cp 
   
   print *,' Integer ', kind(i) 
   print *,' Real ', kind(r) 
   print *,' Complex ', kind(cp)
   print *,' Character ', kind(c) 
   print *,' Logical ', kind(lg)
   
end program checkKind

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant -

Integer 4
Real 4
Complex 4
Character 1
Logical 4