Fortran - Tableaux

Les tableaux peuvent stocker une collection séquentielle de taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une collection de données, mais il est souvent plus utile de considérer un tableau comme une collection de variables du même type.

Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus basse correspond au premier élément et l'adresse la plus élevée au dernier élément.

Numéros (1) Numéros (2) Numéros (3) Numéros (4) …

Les tableaux peuvent être unidimensionnels (comme des vecteurs), bidimensionnels (comme des matrices) et Fortran vous permet de créer jusqu'à 7 tableaux de dimensions.

Déclaration de tableaux

Les tableaux sont déclarés avec le dimension attribut.

Par exemple, pour déclarer un tableau à une dimension nommé nombre, de nombres réels contenant 5 éléments, vous écrivez,

real, dimension(5) :: numbers

Les éléments individuels des tableaux sont référencés en spécifiant leurs indices. Le premier élément d'un tableau a un indice de un. Le tableau des nombres contient cinq variables réelles: les nombres (1), les nombres (2), les nombres (3), les nombres (4) et les nombres (5).

Pour créer un tableau bidimensionnel 5 x 5 d'entiers nommé matrice, vous écrivez -

integer, dimension (5,5) :: matrix

Vous pouvez également déclarer un tableau avec une limite inférieure explicite, par exemple -

real, dimension(2:6) :: numbers
integer, dimension (-3:2,0:4) :: matrix

Attribution de valeurs

Vous pouvez attribuer des valeurs à des membres individuels, comme,

numbers(1) = 2.0

ou, vous pouvez utiliser une boucle,

do i  =1,5
   numbers(i) = i * 2.0
end do

Les éléments de tableau à une dimension peuvent être directement affectés à des valeurs à l'aide d'un symbole abrégé, appelé constructeur de tableau, comme,

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 ‘/’

Exemple

L'exemple suivant illustre les concepts décrits ci-dessus.

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Quelques termes relatifs aux baies

Le tableau suivant donne quelques termes relatifs aux tableaux -

Terme Sens
Rang C'est le nombre de dimensions d'un tableau. Par exemple, pour le tableau nommé matrice, le rang est 2 et pour le tableau nommé nombres, le rang est 1.
Le degré C'est le nombre d'éléments le long d'une dimension. Par exemple, les numéros de tableau ont une étendue 5 et le tableau nommé matrice a une étendue 3 dans les deux dimensions.
Forme La forme d'un tableau est un tableau d'entiers à une dimension, contenant le nombre d'éléments (l'étendue) dans chaque dimension. Par exemple, pour la matrice de tableau, la forme est (3, 3) et les numéros du tableau sont (5).
Taille C'est le nombre d'éléments qu'un tableau contient. Pour la matrice de tableau, c'est 9, et pour les nombres de tableau, c'est 5.

Passage de tableaux à des procédures

Vous pouvez passer un tableau à une procédure en tant qu'argument. L'exemple suivant illustre le concept -

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

1
2
3
4
5

Dans l'exemple ci-dessus, les sous-programmes fillArray et printArray ne peuvent être appelés qu'avec des tableaux de dimension 5. Cependant, pour écrire des sous-programmes pouvant être utilisés pour des tableaux de toute taille, vous pouvez le réécrire en utilisant la technique suivante -

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

Veuillez noter que le programme utilise le size fonction pour obtenir la taille du tableau.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

1
2
3
4
5
6
7
8
9
10

Sections de tableau

Jusqu'à présent, nous avons fait référence à l'ensemble du tableau, Fortran fournit un moyen facile de référencer plusieurs éléments, ou une section d'un tableau, en utilisant une seule instruction.

Pour accéder à une section de tableau, vous devez fournir la limite inférieure et supérieure de la section, ainsi qu'une foulée (incrément), pour toutes les dimensions. Cette notation s'appelle unsubscript triplet:

array ([lower]:[upper][:stride], ...)

Lorsqu'aucune limite inférieure et supérieure n'est mentionnée, la valeur par défaut est celle que vous avez déclarée et la valeur de la foulée est par défaut de 1.

L'exemple suivant illustre le concept -

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Fonctions intrinsèques du tableau

Fortran 90/95 fournit plusieurs procédures intrinsèques. Ils peuvent être divisés en 7 catégories.