Il FORTRAN è un linguaggio di programmazione standardizzato, nato in ambito scientifico, che realizza programmi compilati. Utilizzeremo la versione del Fortran 77 in quanto è la più utilizzata e leggibile anche dai fortran successivi (Fortran 90, 95, 2003, 2008).

Per scrivere il programma abbiamo bisogno di un editor di testo, ad es. 'gedit' (disponibile sia in ambiente Linux che Windows), che permette di scrivere file di testo non formattati. Posso pertanto scrivere come se avessi righe e colonne. Il programma, scritto con 'gedit', dovrà essere salvato con estensione .for (es. nomeprogramma.for).
Per compilare il programma si apre il terminale (linux) o il prompt dei comandi (windows) e, dal direttorio dove è presente il file nomeprogramma.for, si crea il file eseguibile e lo si esegue digitando nella linea dei comandi:

• Esempio per Linux:
  cd /home/utente/Desktop
gfortran nomeprogramma.for
./a.out
  
• Esempio per Windows:
  cd Desktop
gfortran nomeprogramma.for
a

Il comando di compilazione ed esecuzione del programma, uniti dal comando &&, possono essere scritti nella stessa riga del terminale. Inoltre, si possono introdurre altri due comandi: < e >. Il primo permette di inondare il programma con i valori di ingresso contenuti nel file testo, preesistente nello stesso direttorio dove è collocato il programma, chiamato, ad es., 'input'. Il secondo permette di creare un file testo che conterrà i valori di uscita, chiamato, ad es., 'output':

• Esempio per Linux:
  gfortran nomeprogramma.for && ./a.out < input > output
  

Per compilare il programma vi sono delle convenzioni da conoscere:

• Vengono utilizzati solo i primi 72 caratteri di ogni riga, ciò significa che tutti i caratteri dal 73° in poi saranno ignorati e, pertanto, non eseguiti.
• Non vengono considerati gli spazi.
• Non vi è alcuna distinzione tra lettere maiuscole e minuscole.
• Qualsiasi istruzione (riga) viene chiusa andando a capo.
• Dalla 1° alla 5° colonna abbiamo spazi riservati per l'identificazione della riga di comando. Infatti, è possibile, ma non obbligatorio, assegnare un'etichetta (label) ad una riga di comando con un massimo di cinque caratteri. Questo può risultare utile nella scrittura del programma nel caso in cui si voglia fare riferimento ad una data riga o rimandare il programma all'esecuzione della stessa.
• La 1° colonna è riservata all'informazione su quella riga ovvero il carattere della prima colonna stabilisce se la riga è una riga di comando o di commento. Nel caso in cui si voglia inserire una riga di commento, bisogna inserire la lettera c, C o il carattere * in modo che la riga stessa venga bypassata dal compilatore ovvero non eseguita.
• La 6° è riservata ad un qualsiasi carattere, ad esclusione dello spazio e dello zero, il quale indica che sulla riga c'è la continuazione dell'istruzione della riga precedente, nel caso in cui in quest'ultima si andrebbe oltre il 72° carattere. Per semplicità viene utilizzato spesso il simbolo $ oppure +.
• Dalla 7° alla 72° colonna vi è l'istruzione che il compilatore deve eseguire.

Un programma inizia sempre con la dicitura program nomeprogramma e termina con il primo end. Il programma è suddiviso in due parti: dichiarazioni e istruzioni. Dopo l’istruzione end del programma, possono seguire dei sottoprogrammi chiamati SUBROUTINE o FUNCTION. Questi possono essere richiamati nel programma tramite l’istruzione call nomesubroutine_o_nomefunction.

In Fortran 77 ci sono due metodi per dichiarare le variabili: un metodo implicito ed uno esplicito. Il metodo di default è quello implicito cioè se una variabile non viene dichiarata esplicitamente verrà allocata in modo automatico: in particolare tutte le variabili, che vengono chiamate con un nome il quale comincia con le lettere i, j, k, l, m, n, saranno allocate come variabili intere, tutte le altre come variabili reali. La dichiarazione esplicita delle variabili non è obbligatoria, ma è fortemente consigliata per evitare futuri errori nel programma. Per questo motivo, nella stesura del programma, si consiglia l'uso del comando implicit none per poter disattivare la dichiarazione implicita di default, che ci obbliga a prendere in considerazione, ogni qualvolta, la dichiarazione esplicita di una variabile.
Inoltre, il nome di una variabile può contenere al massimo 6 caratteri.

• Esempio di dichiarazioni esplicite:
  integer abcdef (variabile intera)
  real b (variabile reale)

• Esempio di dichiarazioni implicite:
  nodes=9 (variabile intera)
  fmax=10.5 (variabile reale)

Le costanti si definiscono con il comando parameter.

• Esempio:
  real pi, eps
integer c
parameter(pi=3.1415, c=200)
parameter(eps=1.e-7)
• Esempio, sfruttando la dichiarazione implicita:
  parameter(pi=3.1415, ic=200)
parameter(eps=1.e-7)
  

Un array si dichiara con il comando dimension. In questo caso, il compilatore richiede, al sistema operativo, un’allocazione di memoria per memorizzare tutte le componenti dell'array. Un array può essere monodimensionale, ed in questo caso rappresenta un vettore, oppure bidimensionale, che invece rappresenta una matrice.

• Esempio di array monodimensionale:
  dimension a(20) (vettore a formato da 20 elementi reali)
• Esempio di array bidimensionale:
  dimension J(3,5) (matrice J, formata da 15 elementi interi, di 3 righe e 5 colonne)

Le istruzioni sono dei comandi che eseguono delle operazioni definite. Un elenco dettagliato di questi comandi è visibile sul file “Tutorial Fortran 77 Stanford”.

C234567
      PROGRAM POCCIAMEMORIA
      IMPLICIT NONE
      INTEGER NCELLE,I
      PARAMETER (NCELLE=10)
      REAL VEC
      DIMENSION VEC(NCELLE)

      I = 4

      CALL CLEAR( NCELLE , 1 , VEC )

c chiedo all'utente di inserire i valori non nulli
      READ(*,*) I
  101 IF ( I .GT. 0 ) THEN
       READ(*,*) VEC(I)
       READ(*,*) I
       GOTO 101
      ELSE IF ( I .LT. 0 ) THEN
       READ(*,*) VEC(NCELLE+I+1)
       READ(*,*) I
       GOTO 101
      ELSE
       write(*,*) 'fine input'
      ENDIF

C234567
c     DO 10 I=1,NCELLE,1
C      WRITE(*,*) VEC(I)
C  10 CONTINUE  !qui avrei ENDDO
      
      WRITE(*,*) (VEC(I),I=1,NCELLE)

      STOP
      END

C======================================================================
C SOTTOPROGRAMMA PER L'AZZERAMENTO DI VETTORI E MATRICI
C======================================================================
C     SUBROUTINE CLEAR: Inizializzazione a zero degli elementi di una
C     matrice.
C
      SUBROUTINE CLEAR(  K1  ,  K2  ,  A  )
c     ARGOMENTI:
c     INPUT:  K1, numero di righe della matrice
c             K2, numero di colonne della matrice
c     OUTPUT:  A, matrice azzerata dalla subroutine
c
c     la subroutine si può utilizzare su vettori trattandoli come equivalenti
c     matrici riga o colonna

      DIMENSION A(K1,K2)

      DO 10,I10=1,K1
      DO 20,I20=1,K2
      A(I10,I20)=0.
   20 CONTINUE
   10 CONTINUE

      RETURN
      END

gfortran primipassi.for  &&  ./a.out < input > output