Fortran
Datatyper

Intrinsiska typer

Följande är datatyper som är inneboende för Fortran:

integer
real
character
complex
logical

integer , real och complex är numeriska typer.

character är en typ som används för att lagra teckensträngar.

logical används för att lagra binära värden .true. eller. .false. .

Alla numeriska och logiska inneboende typer parametriseras med hjälp av slag.

integer(kind=specific_kind)

eller bara

integer(specific_kind)

där specific_kind är ett heltal med namnet konstant.

Teckenvariabler, liksom att ha en slags parameter, har också en längdparameter:

character char

förklarar char att vara en teckenvariabel längd 1 av standardtyp, medan

character(len=len) name

förklarar att name är en teckenvariabel av standard typ och längd len . Typen kan också anges

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

förklarar name att vara en karaktär av snäll kind och längd len . char är en längd-1 karaktär av snäll kind .

Alternativt den föråldrade formen för karaktärdeklaration

character*len  name

kan ses i äldre kod, förklarar name till att vara av längd len och standardtecken typ.

Deklaration av en variabel av inneboende typ kan ha formen ovan, men kan också använda formen type(...) :

integer i
real x
double precision y

motsvarar (men mycket föredraget framför)

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

Deriverade datatyper

Definiera en ny typ, mytype :

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

Förklara en variabel av typen mytype :

type(mytype) :: foo

Komponenterna av en härledd typ kan nås med % -operatören ¹ :

foo%int = 4
foo%float = 3.142

En Fortran 2003-funktion (ännu inte implementerad av alla kompilatorer) gör det möjligt att definiera parametrerade datatyper:

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

Den härledda matrix har tre typparametrar som listas inom parentes efter cols (det är rows , cols och k ). I deklarationen för varje typparameter måste det anges om de är typparametrar ( kind ) eller längd ( len ).

Parametrar av typtyp, liksom de för de inre typerna, måste vara konstanta uttryck, medan längdtypsparametrar, som längden på en inneboende teckenvariabel, kan variera under exekvering.

Observera att parameter k har ett standardvärde, så det kan tillhandahållas eller utelämnas när en variabel av matrix deklareras enligt följande

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

Namnet på en härledd typ kanske inte är doubleprecision eller samma som någon av de inre typerna.

1. Många undrar varför Fortran använder % som komponentåtkomstoperatör istället för den vanligare . . Detta beror på . är upptaget av operatören syntax, dvs .not. , .and. , .my_own_operator. .

Precision av flytande punktnummer

Flyttalsnummer av typen real kan inte ha något verkligt värde. De kan representera verkliga siffror upp till viss mängd decimaler.

FORTRAN 77 garanterade två flytande punkttyper och nyare standarder garanterar minst två riktiga typer. Verkliga variabler kan deklareras som

real x
double precision y

x här är en real av standardtyp och y är en verklig typ med större decimalprecision än x . I Fortran 2008 är den decimala precisionen för y minst 10 och dess decimalexponentintervall minst 37.

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

grafik

   1.12345684    
   1.1234567890123457

i vanliga kompilatorer med standardkonfiguration.

Lägg märke till d0 i den dubbla precisionskonstanten. En riktig bokstav som innehåller d istället för e för att beteckna exponenten används för att indikera dubbel precision.

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

Fortran 90 introducerade parametriserade real typer med hjälp av slag. Typen av en verklig typ är ett heltal med namnet konstant eller bokstavskonstant:

real(kind=real_kind) :: x

eller bara

real(real_kind) :: x

Detta uttalande förklarar x att vara av typen real med en viss precision beroende på värdet på real_kind .

Flytande punktbokstäver kan deklareras med en specifik typ med hjälp av ett suffix

1.23456e78_real_kind

Det exakta värdet på real_kind är inte standardiserat och skiljer sig från kompilator till kompilator. För att fråga vilken typ av verklig variabel eller konstant som helst, kan funktionstypen kind() användas:

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

kommer vanligtvis att skriva ut

4 8

eller

1 2

beroende på kompilatorn.

Typnummer kan ställas in på flera sätt:

1. Enkel (standard) och dubbel precision:

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

2. Med hjälp av den inre funktionen selected_real_kind([p, r]) att ange önskad decimalprecision. Den returnerade typen har precision på åtminstone p siffror och tillåter exponent för åtminstone r .

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

3. Från och med Fortran 2003 finns fördefinierade konstanter tillgängliga via den inneboende modulen ISO_C_Binding att säkerställa att verkliga slag är interoperabla med typen float , double eller long_double i den medföljande C-kompilatorn:

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

4. Från och med Fortran 2008 är fördefinierade konstanter tillgängliga via den inneboende modulen ISO_Fortran_env . Dessa konstanter tillhandahåller verkliga slag med viss lagringsstorlek i bitar

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

Om viss typ inte är tillgänglig i kompilatorn är värdet som returneras av selected_real_kind() eller värdet på heltalskonstanten -1 .

Antagna och uppskjutna längdparametrar

Variabler av karaktärstyp eller av en härledd typ med längdparameter kan ha längdparametern antingen antagen eller uppskjuten . Teckenvariabelns name

character(len=len) name

är av längd len hela utförandet. Omvänt kan längdspecifikationen vara antingen

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

eller

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

Antagna längdvariabler antar sin längd från en annan enhet.

I funktionen

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

dummy-argumentet dummy_name har längden på det faktiska argumentet.

const_name konstant const_name i

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

har längd ges av det ständiga uttrycket på höger sida.

Parametrar för uppskjuten längd kan variera under körning. En variabel med uppskjuten längd måste ha antingen allocatable eller pointer attribut

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

En sådan variabelns längd kan ställas in på något av följande sätt

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

För härledda typer med längdparameterisering är syntaxen liknande

  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  

Bokstavliga konstanter

Programenheter använder ofta bokstavliga konstanter. Dessa täcker uppenbara fall som

print *, "Hello", 1, 1.0

Förutom i ett fall är varje bokstavskonstant en skala som har typ, typparametrar och värde som ges av syntaxen.

Heltal bokstavliga konstanter är av formen

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

Verkliga bokstavliga konstanter är av formen

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

Komplexa bokstavskonstanter är av formen

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

Om de verkliga och imaginära komponenterna båda är heltal är den komplexa bokstavskonstanten standardkomplex, och heltalskomponenterna konverteras till standardreal. Om en komponent är verklig, är typparametern för den komplexa bokstavskonstanten den för den verkliga (och heltalskomponenten konverteras till den verkliga typen). Om båda komponenterna är verkliga är den komplexa bokstavskonstanten en typ av den verkliga med största precision.

Logiska bokstavskonstanter är

.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

Karaktärens bokstavliga värden skiljer sig något i konceptet, i det att typspecifikationen föregår värdet

"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

Som föreslagits ovan måste bokstavliga konstanter avgränsas av apostrofer eller citattecken, och start- och slutmarkören måste matcha. Bokstavliga apostrofer kan inkluderas genom att vara inom citatteckenavgränsare eller genom att verka fördubblade. Samma sak för citattecken.

BOZ-konstanter skiljer sig från ovan genom att de endast anger ett värde: de har ingen typ eller typparameter. En BOZ-konstant är ett lite mönster och anges som

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

Boz bokstavkonstanter är begränsade i där de kan visas: som konstanter i data uttalanden och ett urval av inneboende förfaranden.

Åtkomst till karaktärsunderlag

För karaktärsenheten

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

en substring kan refereras med syntaxen

greeting(2:4)  ! "ell"

För att få åtkomst till en enda bokstav räcker det inte att skriva

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

men

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

För en teckenuppsättning

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

vi har substring access som

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

men vi kan inte hänvisa till de icke sammanhängande karaktärerna

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

Vi kan till och med komma åt underlag av bokstavliga konstanter

"Hello"(2:4)

En del av en teckenvariabel kan också definieras genom att använda en substring som en variabel. Till exempel

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

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

Tillgång till komplexa komponenter

Den komplexa enheten

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

har verklig del 1. och komplex del 4. .. Vi kan komma åt dessa enskilda komponenter som

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

Formen x%.. är ny för Fortran 2008 och stöds inte i kompilatorer. Denna form kan emellertid användas för att direkt ställa in de enskilda komponenterna i en komplex variabel

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

Förklaring och attribut

Under alla ämnen och exempel här kommer vi att se många deklarationer av variabler, funktioner och så vidare.

Förutom deras namn kan dataobjekt ha attribut . I detta ämne behandlas uttalanden som

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

vilket ger objektet single_kind parameter (vilket gör det till en namngiven konstant).

Det finns många andra attribut, som

• target
• pointer
• optional
• save

Attribut kan specificeras med så kallade attributspecifikationssatser

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

Men det anses i allmänhet vara bättre att undvika att använda dessa attributspecifikationssatser. För tydlighetens skull kan attributen anges som en del av en enda deklaration

integer, pointer, optional :: i

Detta minskar också frestelsen att använda implicit typning.

I de flesta fall i denna Fortran-dokumentation föredras detta enda uttalande.