Fortran
Tipi di dati

Tipi intrinseci

I seguenti sono tipi di dati intrinseci a Fortran:

integer
real
character
complex
logical

integer , real e complex sono tipi numerici.

character è un tipo usato per memorizzare stringhe di caratteri.

logical è usato per memorizzare valori .true. o .false. .

Tutti i tipi numerici e logici intrinseci sono parametrizzati utilizzando i tipi.

integer(kind=specific_kind)

o semplicemente

integer(specific_kind)

dove specific_kind è un numero intero chiamato constant.

Le variabili di caratteri, oltre ad avere un parametro gentile, hanno anche un parametro di lunghezza:

character char

dichiara che char è una variabile di lunghezza 1 di tipo predefinito, mentre

character(len=len) name

dichiara che il name è una variabile di carattere di tipo predefinito e lunghezza len . Il tipo può anche essere specificato

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

dichiara che il name è un personaggio di tipo kind e lunghezza len . char è un carattere lunghezza-1 di tipo kind .

In alternativa, il modulo obsoleto per la dichiarazione dei caratteri

character*len  name

può essere visto nel vecchio codice, dichiarando che il name è di lunghezza len e tipo di carattere predefinito.

La dichiarazione di una variabile di tipo intrinseco può essere nella forma in alto, ma può anche usare il type(...) :

integer i
real x
double precision y

è equivalente a (ma molto preferito sopra)

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

Tipi di dati derivati

Definisci un nuovo tipo, mytype :

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

Dichiarare una variabile di tipo mytype :

type(mytype) :: foo

È possibile accedere ai componenti di un tipo derivato con % operator ¹ :

foo%int = 4
foo%float = 3.142

Una funzionalità di Fortran 2003 (non ancora implementata da tutti i compilatori) consente di definire tipi di dati parametrizzati:

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

Il tipo derivato matrix ha tre parametri tipo che sono elencati in parentesi dopo il nome tipo (sono rows , cols e k ). Nella dichiarazione di ogni parametro di tipo deve essere indicato se sono di tipo gentile ( kind ) o lunghezza ( len ).

I parametri tipo tipo, come quelli dei tipi intrinseci, devono essere espressioni costanti, mentre i parametri del tipo di lunghezza, come la lunghezza di una variabile di carattere intrinseco, possono variare durante l'esecuzione.

Si noti che il parametro k ha un valore predefinito, quindi può essere fornito o omesso quando viene dichiarata una variabile di tipo matrix , come segue

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

Il nome di un tipo derivato potrebbe non essere a doubleprecision o uguale a uno qualsiasi dei tipi intrinseci.

1. Molte persone si chiedono perché Fortran usi % come operatore di accesso ai componenti, anziché il più comune . . Questo perché . è già utilizzato dalla sintassi dell'operatore, ad esempio .not. , .and. , .my_own_operator. .

Precisione dei numeri in virgola mobile

I numeri in virgola mobile di tipo real non possono avere alcun valore reale. Possono rappresentare numeri reali fino a una certa quantità di cifre decimali.

FORTRAN 77 ha garantito due tipi di virgola mobile e standard più recenti garantiscono almeno due tipi reali. Le variabili reali possono essere dichiarate come

real x
double precision y

x qui è un vero tipo di default e y è un vero tipo con una precisione decimale maggiore di x . In Fortran 2008, la precisione decimale di y è almeno 10 e il suo intervallo di esponenti decimali almeno 37.

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

stampe

   1.12345684    
   1.1234567890123457

nei compilatori comuni che utilizzano la configurazione predefinita.

Notare il d0 nella costante a doppia precisione. Un vero letterale contenente d invece di e per denotare l'esponente viene usato per indicare la doppia precisione.

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

Fortran 90 ha introdotto tipi real parametrizzati usando i tipi. Il tipo di un tipo reale è un numero denominato costante costante o letterale:

real(kind=real_kind) :: x

o semplicemente

real(real_kind) :: x

Questa dichiarazione dichiara che x è di tipo real con una certa precisione a seconda del valore di real_kind .

I letterali in virgola mobile possono essere dichiarati con un tipo specifico usando un suffisso

1.23456e78_real_kind

Il valore esatto di real_kind non è standardizzato e differisce da compilatore a compilatore. Per verificare il tipo di qualsiasi variabile o costante reale, è possibile utilizzare il kind() funzione kind() :

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

tipicamente stamperà

4 8

o

1 2

a seconda del compilatore.

I numeri di tipo possono essere impostati in diversi modi:

1. Singolo (predefinito) e doppia precisione:

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

2. Usando la funzione intrinseca selected_real_kind([p, r]) per specificare la precisione decimale richiesta. Il tipo restituito ha una precisione di almeno p cifre e consente l'esponente di almeno r .

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

3. A partire da Fortran 2003, le costanti predefinite sono disponibili tramite il modulo intrinseco ISO_C_Binding per garantire che i tipi reali siano interoperabili con i tipi float , double o long_double del compilatore C associato:

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

4. A partire da Fortran 2008, le costanti predefinite sono disponibili tramite il modulo intrinseco ISO_Fortran_env . Queste costanti forniscono tipi reali con determinate dimensioni di memoria in bit

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

Se un determinato tipo non è disponibile nel compilatore, il valore restituito da selected_real_kind() o il valore della costante intera è -1 .

Parametri di tipo lunghezza presunta e differita

Le variabili di tipo carattere o di tipo derivato con parametro lunghezza possono avere il parametro lunghezza assunto o differito . Il name variabile di carattere

character(len=len) name

è di lunghezza len durante l'esecuzione. Viceversa lo specificatore della lunghezza può essere o

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

o

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

Le variabili di lunghezza ipotizzate assumono la loro lunghezza da un'altra entità.

Nella funzione

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

l'argomento fittizio dummy_name ha lunghezza quella dell'argomento effettivo.

La costante const_name con nome in

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

ha lunghezza data dall'espressione costante sul lato destro.

I parametri di tipo lunghezza differita possono variare durante l'esecuzione. Una variabile con lunghezza posticipata deve avere l'attributo allocatable o pointer

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

La lunghezza di tale variabile può essere impostata in uno dei seguenti modi

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

Per i tipi derivati ​​con parametrizzazione della lunghezza la sintassi è simile

  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  

Costanti letterali

Le unità di programma usano spesso costanti letterali. Questi coprono i casi ovvi come

print *, "Hello", 1, 1.0

Tranne che in un caso, ogni costante letterale è uno scalare che ha tipo, parametri di tipo e valore dati dalla sintassi.

Le costanti letterali intere sono della forma

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

Le vere costanti letterali sono della forma

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

Le costanti letterali complesse sono della forma

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

Se i componenti reali e immaginari sono entrambi interi, la costante letterale complessa è complessa di default e i componenti interi vengono convertiti in valori reali predefiniti. Se un componente è reale, il parametro gentile della costante letterale complessa è quello reale (e il componente intero viene convertito in quel tipo reale). Se entrambi i componenti sono reali, la costante letterale complessa è del tipo del reale con la massima precisione.

Le costanti letterali logiche sono

.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

I valori letterali dei caratteri differiscono leggermente nel concetto, in quanto l'identificatore gentile precede il valore

"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

Come suggerito sopra, le costanti letterali dei caratteri devono essere delimitate da apostrofi o virgolette e il marcatore di inizio e fine deve corrispondere. Gli apostrofi letterali possono essere inclusi tra i delimitatori delle virgolette o apparendo raddoppiati. Lo stesso per le virgolette.

Le costanti BOZ sono distinte da quelle precedenti, in quanto specificano solo un valore: non hanno alcun parametro di tipo o tipo. Una costante BOZ è un modello di bit e viene specificata come

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

Le costanti letterali BOZ sono limitate dove possono apparire: come costanti nelle dichiarazioni di data e una selezione di procedure intrinseche.

Accesso alle sottostringhe dei caratteri

Per l'entità del personaggio

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

una sottostringa può essere referenziata con la sintassi

greeting(2:4)  ! "ell"

Per accedere a una singola lettera non è sufficiente scrivere

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

ma

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

Per un array di caratteri

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

abbiamo l'accesso alla sottostringa come

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

ma non possiamo fare riferimento ai caratteri non contigui

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

Possiamo persino accedere a sottostringhe di costanti letterali

"Hello"(2:4)

Una parte di una variabile di carattere può anche essere definita utilizzando una sottostringa come variabile. Per esempio

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

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

Accesso a componenti complessi

L'entità complessa

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

ha la parte reale 1. e la parte complessa 4. .. Possiamo accedere a questi singoli componenti come

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

Il formato x%.. è nuovo per Fortran 2008 e non ampiamente supportato nei compilatori. Questo modulo, tuttavia, può essere utilizzato per impostare direttamente i singoli componenti di una variabile complessa

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

Dichiarazione e attributi

Attraverso gli argomenti e gli esempi qui vedremo molte dichiarazioni di variabili, funzioni e così via.

Oltre al loro nome, gli oggetti dati possono avere attributi . Coperti in questo argomento sono dichiarazioni dichiarazioni come

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

che dà all'oggetto single_kind l'attributo del parameter (rendendolo una costante nominata).

Ci sono molti altri attributi, come

• target
• pointer
• optional
• save

Gli attributi possono essere specificati con le cosiddette dichiarazioni di specifica degli attributi

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

Tuttavia, si ritiene generalmente che sia meglio evitare di utilizzare queste dichiarazioni di specifica degli attributi. Per chiarezza gli attributi possono essere specificati come parte di una singola dichiarazione

integer, pointer, optional :: i

Ciò riduce anche la tentazione di utilizzare la digitazione implicita.

Nella maggior parte dei casi in questa documentazione Fortran questa dichiarazione di dichiarazione singola è preferita.