Il Linguaggio Fortran 90/95

130 Array
Inizializzazione attraverso l’istruzione di dichiarazione di tipo
I valori iniziali possono essere caricati nell’array già in fase di compilazione specificandoli nella
istruzione di dichiarazione di tipo. A tale scopo è necessario utilizzare un costruttore di array
che specifichi i valori iniziali degli elementi. Ad esempio, la seguente istruzione dichiara l’array
arr di cinque elementi interi e, al tempo stesso, ne imposta i valori degli elementi a 1, 2, 3, 4
e 5:
INTEGER, DIMENSION(5) :: arr=(/1,2,3,4,5/)
Chiaramente, il numero degli elementi nella costante di array deve coincidere con il numero degli
elementi dell’array da inizializzare. Se questi due numeri sono diversi si genererà un errore di
compilazione.
Il metodo testé descritto è adatto ad inizializzare array di piccole dimensioni. Viceversa, per
inizializzare array relativamente grandi è più comodo utilizzare un ciclo DO implicito, il quale
ha la seguente forma:
(arg_1, arg_2, ..., indice = inizio, fine [, incremento])
in cui arg_1, arg_2, ..., sono parametri che vengono calcolati ogni volta che il ciclo viene
eseguito; indice è una variabile contatore il cui valore parte da inizio e termina a fine
con uno step pari a incremento (con quest’ultimo pari ad uno per default). Ad esempio, la
precedente dichiarazione di array poteva essere scritta, più semplicemente, come:
INTEGER, DIMENSION(5) :: arr=(/(i, i=1,5)/)
Allo stesso modo, un array reale di mille elementi può essere inizializzato con i valori 1, 2, ...,
1000 utilizzando il seguente DO implicito:
REAL, DIMENSION(1000) :: vett1=(/(REAL(i), i=1,1000)/)
I cicli DO impliciti possono essere annidati o combinati con le costanti di array per creare
schemi di inizializzazione più complessi. Ad esempio, la seguente istruzione imposta a zero gli
elementi di vett2 se il loro indice non è divisibile per cinque, altrimenti gli elementi assumono
i valori dei loro indici:
INTEGER, DIMENSION(25) :: vett2=(/(0, i=1,4), 5*j, j=1,5)/)
In questo caso, il ciclo interno (0, i=1,4) viene eseguito completamente ad ogni passaggio del
ciclo esterno, pertanto lo schema dei valori risultante è il seguente:
0, 0, 0, 0, 5, 0, 0, 0, 0, 10, 0, 0, 0, 0, 15, ...
Analogo discorso vale per array di rango maggiore di uno. Ad esempio, volendo costruire, in
fase di dichiarazione di tipo, una matrice ”identica” di tipo reale di 10×10 elementi, si può
utilizzare la seguente istruzione:
REAL, DIMENSION(10,10) :: mat_identica= &
RESHAPE((/(1.0,(0.0,i=1,10),j=1,9),1.0),(/10,10/))