Fortran - Arrays
Arrays können eine sequentielle Sammlung von Elementen desselben Typs mit fester Größe speichern. Ein Array wird zum Speichern einer Sammlung von Daten verwendet. Oft ist es jedoch sinnvoller, sich ein Array als eine Sammlung von Variablen desselben Typs vorzustellen.
Alle Arrays bestehen aus zusammenhängenden Speicherstellen. Die niedrigste Adresse entspricht dem ersten Element und die höchste Adresse dem letzten Element.
Zahlen (1) | Zahlen (2) | Zahlen (3) | Zahlen (4) | … |
Arrays können eindimensional (wie Vektoren), zweidimensional (wie Matrizen) und mit Fortran können Sie bis zu 7-dimensionale Arrays erstellen.
Arrays deklarieren
Arrays werden mit dem deklariert dimension Attribut.
Um beispielsweise ein eindimensionales Array mit dem Namen number aus reellen Zahlen mit 5 Elementen zu deklarieren, schreiben Sie:
real, dimension(5) :: numbers
Auf die einzelnen Elemente von Arrays wird durch Angabe ihrer Indizes verwiesen. Das erste Element eines Arrays hat einen Index von eins. Die Array-Nummern enthalten fünf reelle Variablen - Zahlen (1), Zahlen (2), Zahlen (3), Zahlen (4) und Zahlen (5).
Um ein 5 x 5 zweidimensionales Array von Ganzzahlen mit dem Namen Matrix zu erstellen, schreiben Sie:
integer, dimension (5,5) :: matrix
Sie können auch ein Array mit einer expliziten Untergrenze deklarieren, z.
real, dimension(2:6) :: numbers
integer, dimension (-3:2,0:4) :: matrix
Werte zuweisen
Sie können entweder einzelnen Mitgliedern Werte zuweisen, z.
numbers(1) = 2.0
oder Sie können eine Schleife verwenden,
do i =1,5
numbers(i) = i * 2.0
end do
Eindimensionalen Array-Elementen können direkt Werte zugewiesen werden, indem ein kurzes Symbol verwendet wird, das als Array-Konstruktor bezeichnet wird.
numbers = (/1.5, 3.2,4.5,0.9,7.2 /)
please note that there are no spaces allowed between the brackets ‘( ‘and the back slash ‘/’
Beispiel
Das folgende Beispiel zeigt die oben diskutierten Konzepte.
program arrayProg
real :: numbers(5) !one dimensional integer array
integer :: matrix(3,3), i , j !two dimensional real array
!assigning some values to the array numbers
do i=1,5
numbers(i) = i * 2.0
end do
!display the values
do i = 1, 5
Print *, numbers(i)
end do
!assigning some values to the array matrix
do i=1,3
do j = 1, 3
matrix(i, j) = i+j
end do
end do
!display the values
do i=1,3
do j = 1, 3
Print *, matrix(i,j)
end do
end do
!short hand assignment
numbers = (/1.5, 3.2,4.5,0.9,7.2 /)
!display the values
do i = 1, 5
Print *, numbers(i)
end do
end program arrayProg
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
2.00000000
4.00000000
6.00000000
8.00000000
10.0000000
2
3
4
3
4
5
4
5
6
1.50000000
3.20000005
4.50000000
0.899999976
7.19999981
Einige Array-bezogene Begriffe
Die folgende Tabelle enthält einige Array-bezogene Begriffe -
Begriff | Bedeutung |
---|---|
Rang | Dies ist die Anzahl der Dimensionen, die ein Array hat. Beispielsweise ist für die Matrix mit dem Namen "Array" der Rang 2 und für das Array mit dem Namen "Nummern" der Rang 1. |
Umfang | Dies ist die Anzahl der Elemente entlang einer Dimension. Beispielsweise haben die Array-Nummern die Ausdehnung 5 und die Matrix mit dem Namen Array die Ausdehnung 3 in beiden Dimensionen. |
Gestalten | Die Form eines Arrays ist ein eindimensionales ganzzahliges Array, das die Anzahl der Elemente (die Ausdehnung) in jeder Dimension enthält. Beispielsweise ist für die Array-Matrix die Form (3, 3) und die Array-Nummern (5). |
Größe | Dies ist die Anzahl der Elemente, die ein Array enthält. Für die Array-Matrix ist es 9 und für die Array-Nummern ist es 5. |
Übergeben von Arrays an Prozeduren
Sie können ein Array als Argument an eine Prozedur übergeben. Das folgende Beispiel zeigt das Konzept -
program arrayToProcedure
implicit none
integer, dimension (5) :: myArray
integer :: i
call fillArray (myArray)
call printArray(myArray)
end program arrayToProcedure
subroutine fillArray (a)
implicit none
integer, dimension (5), intent (out) :: a
! local variables
integer :: i
do i = 1, 5
a(i) = i
end do
end subroutine fillArray
subroutine printArray(a)
integer, dimension (5) :: a
integer::i
do i = 1, 5
Print *, a(i)
end do
end subroutine printArray
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
1
2
3
4
5
Im obigen Beispiel können die Subroutinen fillArray und printArray nur mit Arrays mit Dimension 5 aufgerufen werden. Um jedoch Subroutinen zu schreiben, die für Arrays jeder Größe verwendet werden können, können Sie sie mit der folgenden Technik neu schreiben:
program arrayToProcedure
implicit none
integer, dimension (10) :: myArray
integer :: i
interface
subroutine fillArray (a)
integer, dimension(:), intent (out) :: a
integer :: i
end subroutine fillArray
subroutine printArray (a)
integer, dimension(:) :: a
integer :: i
end subroutine printArray
end interface
call fillArray (myArray)
call printArray(myArray)
end program arrayToProcedure
subroutine fillArray (a)
implicit none
integer,dimension (:), intent (out) :: a
! local variables
integer :: i, arraySize
arraySize = size(a)
do i = 1, arraySize
a(i) = i
end do
end subroutine fillArray
subroutine printArray(a)
implicit none
integer,dimension (:) :: a
integer::i, arraySize
arraySize = size(a)
do i = 1, arraySize
Print *, a(i)
end do
end subroutine printArray
Bitte beachten Sie, dass das Programm das verwendet size Funktion zum Abrufen der Größe des Arrays.
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
1
2
3
4
5
6
7
8
9
10
Array-Abschnitte
Bisher haben wir uns auf das gesamte Array bezogen. Fortran bietet eine einfache Möglichkeit, mehrere Elemente oder einen Abschnitt eines Arrays mit einer einzigen Anweisung zu referenzieren.
Um auf einen Array-Abschnitt zugreifen zu können, müssen Sie für alle Dimensionen die untere und die obere Grenze des Abschnitts sowie einen Schritt (Inkrement) angeben. Diese Notation heißt asubscript triplet:
array ([lower]:[upper][:stride], ...)
Wenn keine Unter- und Obergrenze angegeben wird, wird standardmäßig der von Ihnen deklarierte Umfang verwendet, und der Schrittwert wird standardmäßig auf 1 gesetzt.
Das folgende Beispiel zeigt das Konzept -
program arraySubsection
real, dimension(10) :: a, b
integer:: i, asize, bsize
a(1:7) = 5.0 ! a(1) to a(7) assigned 5.0
a(8:) = 0.0 ! rest are 0.0
b(2:10:2) = 3.9
b(1:9:2) = 2.5
!display
asize = size(a)
bsize = size(b)
do i = 1, asize
Print *, a(i)
end do
do i = 1, bsize
Print *, b(i)
end do
end program arraySubsection
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
5.00000000
5.00000000
5.00000000
5.00000000
5.00000000
5.00000000
5.00000000
0.00000000E+00
0.00000000E+00
0.00000000E+00
2.50000000
3.90000010
2.50000000
3.90000010
2.50000000
3.90000010
2.50000000
3.90000010
2.50000000
3.90000010
Array-Eigenfunktionen
Fortran 90/95 bietet mehrere intrinsische Verfahren. Sie können in 7 Kategorien unterteilt werden.
Vektor- und Matrixmultiplikation
Reduction
Inquiry
Construction
Reshape
Manipulation
Location