Fortran
Datentypen

Intrinsische Typen

Die folgenden sind Datentypen intrinsisch Fortran:

integer
real
character
complex
logical

integer , real und complex Zahlen sind numerische Typen.

character ist ein Typ, der zum Speichern von Zeichenketten verwendet wird.

logical wird verwendet, um binäre Werte zu .true. oder .false. .

Alle numerischen und logischen intrinsischen Typen werden mithilfe von Arten parametrisiert.

integer(kind=specific_kind)

oder nur

integer(specific_kind)

Dabei ist specific_kind eine ganzzahlige Konstante.

Zeichenvariablen haben neben einem kind-Parameter auch einen Längenparameter:

character char

deklariert char als Länge-1-Zeichenvariable der Standardart, während

character(len=len) name

deklariert name als Zeichenvariable der Standardart und -länge len . Die Art kann auch angegeben werden

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

deklariert den name als Zeichen der kind und Länge len . char ist ein Zeichen der Länge-1- kind .

Alternativ das veraltete Formular für die Zeichendeklaration

character*len  name

kann in älterem Code gesehen werden, wobei der name als Länge len und als Standardzeichenart deklariert wird.

Die Deklaration einer Variablen des intrinsischen Typs kann in der obigen Form sein, sie kann jedoch auch die type(...) verwenden:

integer i
real x
double precision y

ist äquivalent zu (aber sehr bevorzugt gegenüber)

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

Abgeleitete Datentypen

Definieren Sie einen neuen Typ, mytype Typ:

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

Deklarieren Sie eine Variable vom Typ mytype :

type(mytype) :: foo

Auf die Komponenten eines abgeleiteten Typs kann mit dem Operator % ¹ zugegriffen werden:

foo%int = 4
foo%float = 3.142

Eine Fortran 2003-Funktion (noch nicht von allen Compilern implementiert) ermöglicht die Definition parametrisierter Datentypen:

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

Die abgeleitete matrix verfügt über drei Typparameter, die nach dem Typnamen in Klammern aufgeführt sind ( rows , cols und k ). In der Deklaration jedes Typparameters muss angegeben werden, ob es sich um Typparameter vom Typ Art ( kind ) oder Länge (Typ len ) handelt.

Kind-Typ-Parameter müssen ebenso wie die der intrinsischen Typen konstante Ausdrücke sein, während Längentyp-Parameter wie die Länge einer intrinsischen Zeichenvariablen während der Ausführung variieren können.

Beachten Sie, dass der Parameter k einen Standardwert hat. Er kann also angegeben oder weggelassen werden, wenn eine Variable vom Typ matrix wie folgt deklariert wird

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

Der Name eines abgeleiteten Typs darf nicht doubleprecision genau doubleprecision oder mit dem der intrinsischen Typen identisch sein.

1. Viele Leute fragen sich, warum Fortran anstelle des allgemeineren Operators % als Operator für Komponentenzugriff verwendet . . Dies ist weil . wird bereits von der Operatorsyntax übernommen, dh .not. .and. .my_own_operator. .

Genauigkeit der Fließkommazahlen

Gleitkommazahlen des Typs real können keinen reellen Wert haben. Sie können reelle Zahlen bis zu einer bestimmten Anzahl Dezimalstellen darstellen.

FORTRAN 77 garantiert zwei Gleitkommatypen und neuere Standards garantieren mindestens zwei echte Typen. Echte Variablen können als deklariert werden

real x
double precision y

x hier ein reeller Typ und y ist ein reiner Typ mit einer höheren Dezimalgenauigkeit als x . In Fortran 2008 beträgt die Dezimalgenauigkeit von y mindestens 10 und der dezimale Exponentenbereich mindestens 37.

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

druckt

   1.12345684    
   1.1234567890123457

in gängigen Compilern mit Standardkonfiguration.

Beachten Sie das d0 in der Konstante mit doppelter Genauigkeit. Ein reales Literal, das d anstelle von e um den Exponenten zu bezeichnen, wird verwendet, um die doppelte Genauigkeit anzugeben.

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

Fortran 90 führte parametrisierte real Typen ein, die Arten verwenden. Die Art eines reellen Typs ist eine Ganzzahl, die Konstante oder Literalkonstante genannt wird:

real(kind=real_kind) :: x

oder nur

real(real_kind) :: x

Diese Anweisung erklärt, dass x mit einer bestimmten Genauigkeit vom Typ real abhängig vom Wert von real_kind .

Fließkomma-Literale können mit einem Suffix für eine bestimmte Art deklariert werden

1.23456e78_real_kind

Der genaue Wert von real_kind ist nicht standardisiert und unterscheidet sich von Compiler zu Compiler. Um die Art einer realen Variablen oder Konstante abzufragen, kann die Funktion kind() verwendet werden:

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

druckt normalerweise

4 8

oder

1 2

abhängig vom Compiler.

Kindnummern können auf verschiedene Arten eingestellt werden:

1. Einfach (Standard) und doppelte Genauigkeit:

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

2. Verwenden Sie die intrinsische Funktion selected_real_kind([p, r]) , um die erforderliche Dezimalgenauigkeit anzugeben. Die zurückgegebene Art hat eine Genauigkeit von mindestens p Stellen und erlaubt einen Exponenten von mindestens r .

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

3. Ab Fortran 2003 sind vordefinierte Konstanten über das intrinsische Modul ISO_C_Binding um sicherzustellen, dass echte Arten mit den Typen float , double oder long_double des beiliegenden C-Compilers 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. Ab Fortran 2008 stehen vordefinierte Konstanten über das intrinsische Modul ISO_Fortran_env . Diese Konstanten liefern echte Arten mit einer bestimmten Speichergröße in Bits

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

Wenn eine bestimmte Art nicht im Compiler verfügbar ist, ist der von selected_real_kind() Wert oder der Wert der Ganzzahlkonstante -1 .

Angenommene und verzögerte Längenartparameter

Variablen des Zeichentypen oder von einem abgeleiteten Typ mit Längenparameter können den Längenparameter entweder angenommen oder aufgeschoben. Der name Zeichenvariablen

character(len=len) name

ist mit der Länge len im gesamten Ausführung. Umgekehrt kann der Längenbezeichner entweder sein

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

oder

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

Angenommene Längenvariablen nehmen ihre Länge von einer anderen Entität an.

In der Funktion

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

Das Dummy-Argument dummy_name hat die Länge des tatsächlichen Arguments.

Die benannte Konstante const_name in

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

hat die Länge, die durch den konstanten Ausdruck auf der rechten Seite angegeben wird.

Parameter für verzögerte Länge können während der Ausführung variieren. Eine Variable mit verzögerter Länge muss entweder das Attribut " allocatable oder " pointer

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

Die Länge einer solchen Variablen kann auf eine der folgenden Arten festgelegt werden

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

Bei abgeleiteten Typen mit Längenparametrierung ist die Syntax ähnlich

  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  

Wörtliche Konstanten

Programmeinheiten verwenden häufig Literalkonstanten. Diese decken die offensichtlichen Fälle gerne ab

print *, "Hello", 1, 1.0

Mit Ausnahme von einem Fall ist jede Literalkonstante ein Skalar, dessen Typ, Typparameter und Wert durch die Syntax angegeben sind.

Integer-Literalkonstanten haben die Form

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

Echte wörtliche Konstanten haben die Form

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

Komplexe Literalkonstanten haben die Form

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

Wenn sowohl die reelle als auch die imaginäre Komponente ganzzahlig sind, ist die komplexe Literalkonstante der Standardkomplex, und die ganzzahligen Komponenten werden in die Standardrealität konvertiert. Wenn eine Komponente reell ist, ist der art-Parameter der komplexen Literalkonstante der der reellen (und die Ganzzahlkomponente wird in diese reelle Art konvertiert). Wenn beide Komponenten real sind, ist die komplexe buchstäbliche Konstante mit der größten Genauigkeit die Art des Real.

Logische Literalkonstanten sind

.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

Zeichenliteralwerte unterscheiden sich geringfügig im Konzept, indem der Wertbezeichner vor dem Wert steht

"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

Wie oben vorgeschlagen, müssen Zeichenliteralkonstanten durch Apostrophe oder Anführungszeichen begrenzt werden, und die Start- und Endmarkierung müssen übereinstimmen. Literale Apostrophe können eingeschlossen werden, indem sie sich in Anführungszeichen befinden oder doppelt dargestellt werden. Dasselbe gilt für Anführungszeichen.

BOZ-Konstanten unterscheiden sich von den obigen Ausführungen darin, dass sie nur einen Wert angeben: Sie haben keinen Typ- oder Typparameter. Eine BOZ-Konstante ist ein Bitmuster und wird als angegeben

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

Die Konstanten von BOZ-Literalen sind begrenzt, wo sie auftreten können: als Konstanten in data und als Auswahl intrinsischer Prozeduren.

Auf Zeichen-Zeichenketten zugreifen

Für die Charakterentität

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

Ein Teilstring kann mit der Syntax referenziert werden

greeting(2:4)  ! "ell"

Für den Zugriff auf einen einzelnen Buchstaben reicht es nicht aus, zu schreiben

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

aber

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

Für ein Zeichenfeld

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

Wir haben einen Teilzugriff wie

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

Wir können jedoch nicht auf die nicht zusammenhängenden Zeichen verweisen

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

Wir können sogar auf Teilzeichenfolgen von Literalkonstanten zugreifen

"Hello"(2:4)

Ein Teil einer Zeichenvariablen kann auch definiert werden, indem eine Teilzeichenfolge als Variable verwendet wird. Zum Beispiel

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

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

Zugriff auf komplexe Komponenten

Die komplexe Einheit

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

hat Realteil 1. und komplexen Teil 4. Wir können auf diese einzelnen Komponenten als zugreifen

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

Die Form x%.. ist neu in Fortran 2008 und wird in Compilern nicht allgemein unterstützt. Dieses Formular kann jedoch verwendet werden, um die einzelnen Komponenten einer komplexen Variablen direkt festzulegen

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

Deklaration und Attribute

In den Themen und Beispielen werden wir viele Deklarationen von Variablen, Funktionen usw. sehen.

Datenobjekte können neben ihrem Namen auch Attribute haben . In diesem Thema werden Deklarationsanweisungen wie behandelt

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

single_kind erhält das Objekt single_kind das parameter (es wird eine benannte Konstante).

Es gibt viele andere Attribute wie

• target
• pointer
• optional
• save

Attribute können mit sogenannten Attributspezifikationsanweisungen angegeben werden

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

Es wird jedoch allgemein als besser angesehen, diese Attributspezifikationsanweisungen nicht zu verwenden. Zur Verdeutlichung können die Attribute als Teil einer einzelnen Deklaration angegeben werden

integer, pointer, optional :: i

Dies reduziert auch die Versuchung, die implizite Typisierung zu verwenden.

In den meisten Fällen wird in dieser Fortran-Dokumentation diese einzelne Deklaration bevorzugt.