Array

Gli array permettono di denotare un gruppo di variabili con un solo identificatore, e la possibilità di distinguere una variabile appartenente all'insieme (componente) scrivendo accanto all'identificatore del gruppo un indice.
In pratica gli array monodimensionali sono i vettori, mentre quelli bidimensionali sono le matrici. Il FORTRAN permette di definire array fino a dimensione 7.

Array monodimensionali

Il compilatore deve essere informato all'inizio del programma che una variabile è una variabile array. Per far ciò si utilizza il seguente costrutto:
      DIMENSION identificatore1(n1),identificatore2(n2)
dove identificatore1 e identificatore2 sono gli identificatori delle variabili, e n1e n2 il numero di elementi di identificatore1 e identificatore2 rispettivamente (non è permesso definire i limiti degli array con delle variabili). identificatore1 e identificatore2 devono appartenere a uno dei tipi di dati descritti in Tipi di dati e relativi operatori, mentre n1e n2 devono essere numeri naturali. Se è necessario specificare il tipo degli elementi si usano le istruzioni dichiarative precedentemente viste (INTEGER, REAL, CHARACTER, LOGICAL).

Esempi:

      DIMENSION VET(10)                array di 10 elementi [VET(1), VET(2), VET(3)]

      INTEGER A
      CHARACTER B                          array di 3 e 5 elementi rispettivamente
      DIMENSION A(3),B(5)              [A(1), A(2), A(3)] [B(1), B(2), B(3), B(4), B(5)]

      DIMENSION X(-10:7)                array di 18 elementi X(i) i = -10, -9, ... , 6 , 7

Dall'ultimo esempio si vede che invece di dare il numero di elementi si può assegnare l'intervallo di variabilità dell'indice dell'array.
      DIMENSION(m,n)
deve essere n ≥ m. Si noti inoltre che DIMENSION N(1:100) equivale a DIMENSION N(100).
Per poter identificare un elemento di un array si utilizza l'identificatore dell'array seguito da una costante, o una variabile, o un'espressione racchiuse tra parentesi tonde, le quali devono essere (costante, variabile) o devono dare (espressione) un risultato di tipo INTEGER, a questa scrittura si dà il nome di variabile indiciata. La costante, la variabile, o l'espressione devono avere un risultato compatibile con il numero di elementi o l'intervallo di variabilità dichiarati in DIMENSION.

L'esempio seguente mostra la comodità di utilizzo degli array:

      DIMENSION X(1000)
      .........................
      DO 10 I=1,1000
      PRINT*,X(I)
10  CONTINUE
      END

È molto più compatto e facilmente modificabile di:

      .........................
      PRINT*,X(1)
      PRINT*,X(2)
      .........................
      PRINT*,X(1000)
      END

Array n-dimensionali

Per definire un array n-dimensionale si utilizza il seguente costrutto:
      DIMENSION identificatore1(n11,n12,...,n1x),identificatore2(n21,n22,...,n2y)
dove identificatore1 e identificatore2 sono gli identificatori delle variabili, e n11,n12,... e n21,n22,... il numero di elementi di identificatore1 e identificatore2 rispettivamente (non è permesso definire i limiti degli array con delle variabili). x e y (naturali) sono rispettivamente la dimensione di identificatore1 e identificatore2. Quindi per un array bidimensionale si ha ad esempio:
      DIMENSION MATRICE(r,c)
dove r è il numero di righe e c il numero di colonne. MATRICE(I,J) identifica l'elemento che si trova sulla I-esima riga e J-esima colonna.
Tutto ciò che è stato detto precedentemente per quanto riguarda gli array monodimensionali resta valido.

Esempio:

      DIMENSION M(10,10)
      .........................
      DO 10 I=1,10
      DO 10 J=1,10
      M(I,J)=I*J
10  CONTINUE
      END

Gli array, di qualunque dimensione, vengono sempre memorizzati per colonne.

Quindi la struttura assunta da un programma diviene:

      PROGRAM NomeProgramma
      INTEGER Elenco identificatori INTEGER
      REAL Elenco identificatori REAL
      CHARACTER Elenco identificatori CHARACTER
      LOGICAL Elenco identificatori LOGICAL
      DIMENSION Elenco identificatori array
      .........................
      END

DO implicito

Nelle istruzioni di I/O si può adoperare il DO implicito per acquisire/visualizzare i valori di un array. La sintassi da utilizzare è la seguente:
      READ*,(variabile-indiciata,indice=n,m)
      PRINT*,(variabile-indiciata,indice=n,m)
dove variabile-indiciata è stato detto in precedenza cosa rappresenta (vai a variabile indiciata), indice è l'indice di variabile-indiciata e n, m indicano l'intervallo di variabilità di variabile-indiciata.

Esempi:

      DIMENSION V(10)
      ........................
      READ*,(V(I),I=1,10)                        Gli elementi di V vengono letti su un'unica riga

      DIMENSION X(5)
      ........................
      PRINT 10,(X(I),I=1,5)                      Gli elementi di X vengono visualizzati su un'unica riga
10  FORMAT(2X,F6.3)

      DIMENSION V(10)
      ........................
      DO 10 I=1,10
      READ*,V(I)                                       Gli elementi di V vengono letti su 10 righe
10  CONTINUE

      DIMENSION X(5)
      ........................
      DO 20 I=1,5
      PRINT 10,X(I)                                   Gli elementi di X vengono visualizzati su 5 righe
20  CONTINUE
10  FORMAT(2X,F6.3)

      DIMENSION M(10,10)
      ........................
      DO 10 I=1,10
      PRINT*,(V(I,J),J=1,10)                      Gli elementi di M verranno visualizzati su 10 righe con 10 elementi
10  CONTINUE                                       per ogni riga

      DIMENSION A(3,4)
      ........................
      PRINT 10,((A(I,J),I=1,3),J=1,4)         Gli elementi di A vengono visualizzati su 3 righe con 4 elementi per
10  FORMAT(2X,8F6.3/)                         ogni riga [l'8 in FORMAT non è un errore]

Il DO implicito si può adoperare anche al di fuori di un array:
      PRINT*,(I,I=1,10)
da in output:
1    2    3    4    5    6    7    8    9    10