Fortran
Types de données

Types intrinsèques

Les types de données suivants sont intrinsèques à Fortran:

integer
real
character
complex
logical

integer , real et complex sont des types numériques.

character est un type utilisé pour stocker des chaînes de caractères.

logical est utilisé pour stocker les valeurs binaires .true. ou .false. .

Tous les types intrinsèques numériques et logiques sont paramétrés à l'aide de types.

integer(kind=specific_kind)

ou juste

integer(specific_kind)

Où specific_kind est un entier nommé constant.

Les variables de caractère, tout comme le paramètre kind, ont également un paramètre de longueur:

character char

déclare char comme étant une variable de type longueur-1 de type par défaut, tandis que

character(len=len) name

déclare que le name est une variable de caractère de type par défaut et de longueur len . Le genre peut aussi être spécifié

character(len=len, kind=specific_kind) name
character(kind=specific_kind) char

déclare que le name est un personnage de genre kind et de longueur len . char est un caractère de longueur 1 de type kind .

Sinon, le formulaire obsolète pour la déclaration de caractères

character*len  name

peut être vu dans l'ancien code, déclarant que le name est de longueur len et le type de caractère par défaut.

La déclaration d'une variable de type intrinsèque peut être de la forme ci-dessus, mais peut également utiliser le type(...) :

integer i
real x
double precision y

est équivalent à (mais grandement préféré)

type(integer) i
type(real) x
type(double precision) y

Types de données dérivés

Définir un nouveau type, mytype :

type :: mytype
  integer :: int
  real    :: float
end type mytype

Déclarez une variable de type mytype :

type(mytype) :: foo

Les composants d'un type dérivé sont accessibles avec l'opérateur % ¹ :

foo%int = 4
foo%float = 3.142

Une fonctionnalité de Fortran 2003 (non encore implémentée par tous les compilateurs) permet de définir des types de données paramétrés:

type, public :: matrix(rows, cols, k)
  integer, len :: rows, cols
  integer, kind :: k = kind(0.0)
  real(kind = k), dimension(rows, cols) :: values
end type matrix

Le type dérivé matrix a trois paramètres de type qui sont énumérés ci - après entre parenthèses le nom du type (elles sont rows , cols , et k ). Dans la déclaration de chaque paramètre de type, il faut indiquer s'il s'agit de paramètres de type type ( kind ) ou de longueur ( len ).

Les paramètres de type type, comme ceux des types intrinsèques, doivent être des expressions constantes, tandis que les paramètres de type longueur, comme la longueur d'une variable de caractère intrinsèque, peuvent varier au cours de l'exécution.

Notez que le paramètre k a une valeur par défaut, il peut donc être fourni ou omis quand une variable de type matrix est déclarée, comme suit

type (matrix (55, 65, kind=double)) :: b, c ! default parameter provided
type (matrix (rows=40, cols=50)     :: m    ! default parameter omitted

Le nom d'un type dérivé peut ne pas être doubleprecision ou identique à l'un des types intrinsèques.

1. Beaucoup de gens se demandent pourquoi Fortran utilise % comme opérateur d'accès aux composants, au lieu de le plus commun . . En effet . est déjà pris par la syntaxe de l'opérateur, c.-à-d .not. , .and. , .my_own_operator. .

Précision des nombres à virgule flottante

Les nombres à virgule flottante de type real ne peuvent avoir aucune valeur réelle. Ils peuvent représenter des nombres réels allant jusqu’à un certain nombre de chiffres décimaux.

FORTRAN 77 garanti deux types de virgule flottante et des normes plus récentes garantissent au moins deux types réels. Les variables réelles peuvent être déclarées comme

real x
double precision y

x ici est un vrai type par défaut et y est un vrai genre avec une plus grande précision décimale que x . Dans Fortran 2008, la précision décimale de y est d'au moins 10 et son exposant décimal est d'au moins 37.

 real, parameter             :: single = 1.12345678901234567890
 double precision, parameter :: double = 1.12345678901234567890d0
 
 print *, single
 print *, double

estampes

   1.12345684    
   1.1234567890123457

dans des compilateurs communs utilisant la configuration par défaut.

Remarquez le d0 dans la constante de double précision. Un littéral réel contenant d au lieu de e pour désigner l'exposant est utilisé pour indiquer une double précision.

! Default single precision constant
1.23e45
! Double precision constant
1.23d45

Fortran 90 a introduit real types real paramétrés à real aide de types. Le type d'un type réel est un entier nommé constant ou littéral constant:

real(kind=real_kind) :: x

ou juste

real(real_kind) :: x

Cette déclaration déclare x de type real avec une certaine précision en fonction de la valeur de real_kind .

Les littéraux à virgule flottante peuvent être déclarés avec un type spécifique en utilisant un suffixe

1.23456e78_real_kind

La valeur exacte de real_kind n'est pas normalisée et diffère d'un compilateur à l'autre. Pour connaître le type de toute variable ou constante réelle, la fonction kind() peut être utilisée:

print *, kind(1.0), kind(1.d0)

imprimera généralement

4 8

ou

1 2

en fonction du compilateur.

Les nombres types peuvent être définis de plusieurs manières:

1. Simple (par défaut) et double précision:

   integer, parameter :: single_kind = kind(1.)
   integer, parameter :: double_kind = kind(1.d0)
   

2. Utiliser la fonction intrinsèque selected_real_kind([p, r]) pour spécifier la précision décimale requise. Le type retourné a une précision d'au moins p chiffres et permet d'exposer au moins r .

   integer, parameter :: single_kind = selected_real_kind( p=6, r=37 )
   integer, parameter :: double_kind = selected_real_kind( p=15, r=200 )
   

3. À partir de Fortran 2003, des constantes prédéfinies sont disponibles via le module intrinsèque ISO_C_Binding pour garantir l' ISO_C_Binding des types réels avec les types float , double ou long_double du compilateur C long_double :

   use ISO_C_Binding
   
   integer, parameter :: single_kind = c_float
   integer, parameter :: double_kind = c_double
   integer, parameter :: long_kind = c_long_double
   

4. À partir de Fortran 2008, des constantes prédéfinies sont disponibles via le module intrinsèque ISO_Fortran_env . Ces constantes fournissent des types réels avec une certaine taille de stockage en bits

   use ISO_Fortran_env
   
   integer, parameter :: single_kind = real32
   integer, parameter :: double_kind = real64
   integer, parameter :: quadruple_kind = real128
   

Si certains types ne sont pas disponibles dans le compilateur, la valeur renvoyée par selected_real_kind() ou la valeur de la constante entière est -1 .

Paramètres de type de longueur supposés et différés

Les variables de type caractère ou de type dérivé avec paramètre de longueur peuvent avoir le paramètre de longueur pris ou différé . Le name variable de caractère

character(len=len) name

est de longueur len tout au long de l'exécution. Inversement, le spécificateur de longueur peut être soit

character(len=*) ...  ! Assumed length

ou

character(len=:) ...  ! Deferred length

Les variables de longueur supposées prennent leur longueur à partir d'une autre entité.

Dans la fonction

function f(dummy_name)
  character(len=*) dummy_name
end function f

l'argument factice dummy_name a la longueur de l'argument réel.

La constante nommée const_name dans

character(len=*), parameter :: const_name = 'Name from which length is assumed'

a la longueur donnée par l'expression constante du côté droit.

Les paramètres de type longueur différée peuvent varier au cours de l'exécution. Une variable avec une longueur différée doit avoir l' allocatable ou le pointer attribuable

character(len=:), allocatable :: alloc_name
character(len=:), pointer :: ptr_name

La longueur d'une telle variable peut être définie de l'une des manières suivantes:

allocate(character(len=5) :: alloc_name, ptr_name)
alloc_name = 'Name'         ! Using allocation on intrinsic assignment
ptr_name => another_name    ! For given target

Pour les types dérivés avec paramétrage de longueur, la syntaxe est similaire

  type t(len)
    integer, len :: len
    integer i(len)
  end type t

  type(t(:)), allocatable :: t1
  type(t(5)) t2

  call sub(t2)
  allocate(type(t(5)) :: t1)

contains

  subroutine sub(t2)
    type(t(*)), intent(out) :: t2
  end subroutine sub

end  

Constantes littérales

Les unités de programme utilisent souvent des constantes littérales. Celles-ci couvrent les cas évidents comme

print *, "Hello", 1, 1.0

Sauf dans un cas, chaque constante littérale est un scalaire qui a le type, les paramètres de type et la valeur donnée par la syntaxe.

Les constantes littérales entières sont de la forme

1
-1
-1_1   ! For valid kind parameter 1
1_ik   ! For the named constant ik being a valid kind paramter

Les constantes littérales réelles sont de la forme

1.0    ! Default real
1e0    ! Default real using exponent format
1._1   ! Real with kind parameter 1 (if valid)
1.0_sp ! Real with kind paramter named constant sp
1d0    ! Double precision real using exponent format
1e0_dp ! Real with kind named constant dp using exponent format

Les constantes littérales complexes sont de la forme

(1, 1.)       ! Complex with integer and real components, literal constants
(real, imag)  ! Complex with named constants as components

Si les composants réels et imaginaires sont tous deux des nombres entiers, la constante littérale complexe est complexe par défaut et les composants entiers sont convertis en réels par défaut. Si un composant est réel, le paramètre kind de la constante littérale complexe est celui du réel (et le composant entier est converti en ce type réel). Si les deux composants sont réels, la constante littérale complexe est du type réel avec la plus grande précision.

Les constantes littérales logiques sont

.TRUE.     ! Default kind, with true value
.FALSE.    ! Default kind, with false value
.TRUE._1   ! Of kind 1 (if valid), with true value
.TRUE._lk  ! Of kind named constant lk (if valid), with true value

Les valeurs littérales des caractères diffèrent légèrement dans le concept, en ce sens que le spécificateur de type précède la valeur

"Hello"       ! Character value of default kind
'Hello'       ! Character value of default kind
ck_"Hello"    ! Character value of kind ck
"'Bye"        ! Default kind character with a '
'''Bye'       ! Default kind character with a '
""            ! A zero-length character of default kind

Comme suggéré ci-dessus, les constantes littérales de caractères doivent être délimitées par des apostrophes ou des guillemets, et les marqueurs de début et de fin doivent correspondre. Les apostrophes littérales peuvent être incluses en étant dans les délimiteurs de guillemets ou en apparaissant doublées. La même chose pour les guillemets.

Les constantes BOZ sont distinctes de celles ci-dessus, car elles ne spécifient qu'une valeur: elles n'ont pas de paramètre de type ou de type. Une constante BOZ est un modèle de bit et est spécifiée comme

B'00000'    ! A binary bit pattern
B"01010001" ! A binary bit pattern
O'012517'   ! An octal bit pattern
O"1267671"  ! An octal bit pattern
Z'0A4F'     ! A hexadecimal bit pattern
Z"FFFFFF"   ! A hexadecimal bit pattern

Les constantes littérales BOZ se limitent à leur apparition: constantes dans data instructions de data et sélection de procédures intrinsèques.

Accès aux sous-chaînes de caractères

Pour l'entité de caractère

character(len=5), parameter :: greeting = "Hello"

une sous-chaîne peut être référencée avec la syntaxe

greeting(2:4)  ! "ell"

Pour accéder à une seule lettre, il ne suffit pas d’écrire

greeting(1)    ! This isn't the letter "H"

mais

greeting(1:1)  ! This is "H"

Pour un tableau de caractères

character(len=5), parameter :: greeting(2) = ["Hello", "Yo!  "]

nous avons accès à la sous-chaîne comme

greeting(1)(2:4)  ! "ell"

mais nous ne pouvons pas référencer les caractères non contigus

greeting(:)(2:4)  ! The parent string here is an array

Nous pouvons même accéder à des sous-chaînes de constantes littérales

"Hello"(2:4)

Une partie d'une variable de caractère peut également être définie en utilisant une sous-chaîne en tant que variable. Par exemple

integer :: i=1
character :: filename = 'file000.txt'

filename(9:11) = 'dat'
write(filename(5:7), '(I3.3)') i

Accéder à des composants complexes

L'entité complexe

complex, parameter :: x = (1., 4.)

a la partie réelle 1. et la partie complexe 4. .. Nous pouvons accéder à ces composants individuels comme

real(x)  ! The real component
aimag(x) ! The complex component
x%re     ! The real component
y%im     ! The complex component

La forme x%.. est nouvelle dans Fortran 2008 et n'est pas largement prise en charge dans les compilateurs. Cette forme, cependant, peut être utilisée pour définir directement les composants individuels d'une variable complexe

complex y
y%re = 0.
y%im = 1.

Déclaration et attributs

Tout au long des sujets et des exemples, nous verrons de nombreuses déclarations de variables, de fonctions, etc.

En plus de leur nom, les objets de données peuvent avoir des attributs . Couverts dans cette rubrique sont des déclarations de déclaration comme

integer, parameter :: single_kind = kind(1.)

ce qui donne à l'objet single_kind l'attribut du parameter (ce qui en fait une constante nommée).

Il y a beaucoup d'autres attributs, comme

• target
• pointer
• optional
• save

Les attributs peuvent être spécifiés avec des instructions de spécification d'attribut

integer i    ! i is an integer (of default kind)...
pointer i    ! ... with the POINTER attribute...
optional i   ! ... and the OPTIONAL attribute

Cependant, il est généralement considéré comme préférable d'éviter d'utiliser ces instructions de spécification d'attribut. Pour plus de clarté, les attributs peuvent être spécifiés dans le cadre d'une déclaration unique

integer, pointer, optional :: i

Cela réduit également la tentation d'utiliser un typage implicite.

Dans la plupart des cas, dans cette documentation Fortran, cette déclaration de déclaration unique est préférable.