Fortran - Arrays

Gli array possono memorizzare una raccolta sequenziale di dimensioni fisse di elementi dello stesso tipo. Un array viene utilizzato per memorizzare una raccolta di dati, ma spesso è più utile pensare a un array come una raccolta di variabili dello stesso tipo.

Tutti gli array sono costituiti da posizioni di memoria contigue. L'indirizzo più basso corrisponde al primo elemento e l'indirizzo più alto all'ultimo elemento.

Numeri (1)	Numeri (2)	Numeri (3)	Numeri (4)	...

Gli array possono essere unidimensionali (come i vettori), bidimensionali (come le matrici) e Fortran consente di creare array fino a 7 dimensioni.

Dichiarazione di array

Gli array vengono dichiarati con l'estensione dimension attributo.

Ad esempio, per dichiarare una matrice unidimensionale denominata numero, di numeri reali contenenti 5 elementi, scrivi,

real, dimension(5) :: numbers

Si fa riferimento ai singoli elementi degli array specificandone i pedici. Il primo elemento di un array ha un pedice di uno. La serie di numeri contiene cinque variabili reali: numeri (1), numeri (2), numeri (3), numeri (4) e numeri (5).

Per creare una matrice bidimensionale di numeri interi 5 x 5 denominata matrice, scrivi:

integer, dimension (5,5) :: matrix

Puoi anche dichiarare un array con un limite inferiore esplicito, ad esempio:

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

Assegnazione di valori

Puoi assegnare valori a singoli membri, come,

numbers(1) = 2.0

oppure puoi usare un loop,

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

Agli elementi di array unidimensionali possono essere assegnati direttamente valori utilizzando un simbolo a mano breve, chiamato costruttore di array, come,

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

Esempio

L'esempio seguente mostra i concetti discussi sopra.

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Alcuni termini relativi agli array

La tabella seguente fornisce alcuni termini relativi agli array:

Termine	Senso
Rango	È il numero di dimensioni di un array. Ad esempio, per la matrice denominata matrice, il rango è 2 e per la matrice denominata numeri, il rango è 1.
Estensione	È il numero di elementi lungo una dimensione. Ad esempio, i numeri della matrice hanno estensione 5 e la matrice denominata matrice ha estensione 3 in entrambe le dimensioni.
Forma	La forma di una matrice è una matrice intera unidimensionale, contenente il numero di elementi (l'estensione) in ciascuna dimensione. Ad esempio, per la matrice dell'array, la forma è (3, 3) e i numeri dell'array è (5).
Taglia	È il numero di elementi contenuti in un array. Per la matrice di array, è 9 e per i numeri di array è 5.

Passaggio di array alle procedure

È possibile passare un array a una procedura come argomento. Il seguente esempio dimostra il concetto:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Nell'esempio precedente, le subroutine fillArray e printArray possono essere chiamate solo con array con dimensione 5. Tuttavia, per scrivere subroutine che possono essere utilizzate per array di qualsiasi dimensione, è possibile riscriverle utilizzando la seguente tecnica:

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

Tieni presente che il programma utilizza l'estensione size funzione per ottenere la dimensione dell'array.

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Sezioni array

Finora ci siamo riferiti all'intero array, Fortran fornisce un modo semplice per fare riferimento a diversi elementi, o una sezione di un array, utilizzando una singola istruzione.

Per accedere a una sezione della matrice, è necessario fornire il limite inferiore e superiore della sezione, nonché un passo (incremento), per tutte le dimensioni. Questa notazione è chiamata asubscript triplet:

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

Quando non vengono menzionati limiti inferiore e superiore, il valore predefinito è l'estensione dichiarata e il valore di stride predefinito è 1.

Il seguente esempio dimostra il concetto:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Funzioni intrinseche degli array

Fortran 90/95 fornisce diverse procedure intrinseche. Possono essere suddivisi in 7 categorie.

Moltiplicazione di vettori e matrici
Reduction
Inquiry
Construction
Reshape
Manipulation
Location