Le funzioni, nel Fortran, rappresentano un tipo di sottoprogrammi che, se necessario, possono essere richiamati più volte all’interno del programma principale per soddisfare una particolare esigenza ed effettuare degli opportuni calcoli.

Le funzioni definite dall’utente, a differenza delle funzioni standard già ingoblate nell’ambiente di programmazione, vengono scritte al fine di soddisfare uno specifico scopo che nessun altro strumento a disposizione del programmatore è in grado di soddisfare.

Le funzioni sono definite attraverso un costrutto del tipo:

FUNCTION Area_Circle(r) USE Circle, ONLY : Pi
IMPLICIT NONE
REAL :: Area_Circle
REAL, INTENT(IN) :: r
Area_Circle = Pi * r * r
END FUNCTION Area_Circle

È tramite il nome della funzione che si richiama la funzione all’interno del programma principale. Gli argomenti contenuti nelle parentesi tonde sono gli identificatori su cui la funzione opera.

Le funzioni lavorano sui valori memorizzati negli argomenti e restituiscono un risultato del tipo specificato. L’elenco degli identificatori costituisce un insieme di oggetti fittizi, ai quali, quando il sottoprogramma viene richiamato, vengono rimpiazzati i valori degli argomenti dell’istruzione chiamante.

Dopo la definizione della una funzione, csegue il blocco di istruzioni che costituiscono il sottoprogramma. Tra queste vi deve essere almeno un’istruzione di assegnazione con il nome della funzione a sinistra del segno di uguale, che assegna un valore a questa variabile e che viene quindi restituito al programma chiamante al termine della funzione, che come tutti i programmi deve terminare con END.

Vediamo come esempio un programma che richiama al suo interno una funzione:

MODULE Circle
!---------------------------------------------------------------------
! ! Modulo che contiene la definizione delle variabili necessarie
! per la computazione dell'area del cerchio di raggio r !
!---------------------------------------------------------------------
REAL, PARAMETER :: Pi = 3.1415927
REAL :: radius
END MODULE Circle
PROGRAM Area
!---------------------------------------------------------------------
! ! Questo programma computa l'area del cerchio dato il raggio !
! Uses: MODULE Circle ! FUNCTION Area_Circle (r) !
!---------------------------------------------------------------------
16
USE Circle, ONLY : radius IMPLICIT NONE
INTERFACE
FUNCTION Area_Circle (r)
REAL, INTENT(IN) :: r
END FUNCTION Area_Circle
END INTERFACE
! Prompt user per il raggio del cerchio write(*, '(A)', ADVANCE =
"NO") "Digita il raggio del cerchio: " read(*,*) radius
! Write out area of circle using function call write(*,100) "Area
del cerchio con raggio", radius, " is", &
Area_Circle(radius)
100 format (A, 2x, F6.2, A, 2x, F11.2)
END PROGRAM Area
!-----Area_Circle----------------------------------------------------
! ! Funzione che calcola l'area del cerchio di raggio r !
!---------------------------------------------------------------------
FUNCTION Area_Circle(r) USE Circle, ONLY : Pi
IMPLICIT NONE REAL :: Area_Circle REAL, INTENT(IN) :: r
Area_Circle = Pi * r * r
END FUNCTION Area_Circle

Questo programma usa la funzione Area_Circle per computare l’area d’un cerchio di raggio r. La funzione compare dopo l’istruzione di fine programma della zona principale di programma, in modo da essere classificata come subprogram esterno. Poichè è una procedura esterna, il programma principale usa un INTERFACE BLOCK per definire tutti i parametri richiesti dalla funzione Area_Circle.

La versione in fortran 90 del subprogram funzione si comporta allo stesso modo del subprogram funzione presente nel fortran 77. Si noti che l’ unica differenza sostanziale qui è la capacità di dichiarare esplicitamente gli argomenti della funzione in se.Prendere la nota speciale del descrittore INTENT(IN) del tipo.

Questo attributo della variabile r nel subprogram di funzione identifica rigorosamente la variabile r come variabile di input. Tali variabili non possono essere modificati dal subprogram in modo involontario.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Sottoprogrammi nel Fortran
• Gli array bidimensionali in Fortran
• Gli array monodimensionali nel Fortran
• Il ciclo Do implicito nel Fortran
• I cicli nel Fortran

Così come già accadeva per il fortran 77, anche il nuovo formato fortran 90 ci consente di suddividere un programma principali in una serie di sottoprogrammi. tali sottoprogrammi possono essere di due tipi:

1. funzioni
2. subroutine

In entrambi i casi è poi possibile suddividere il sottoprogrammi in ulteriori due forme:

1. sottoprogramma interno
2. sottoprogramma esterno.

I sottoprogrammi interni sono quelle procedure che possono comparire nell’ambito del programma principale. mentre i  sottoprogrammi esterni sono quelli che compaiono in una sezione separata di programma dopo l’ istruzione principale END del programma.

Ciò è del tutto simile a quanto già si faceva nel fortran 77 trattandosi pur sempre di programmazione procedurale.  Inoltre, così come in fortran 77, i sottoprogrammi del tipo function, nel fortran 90, hanno un tipo esplicito e sono indirizzati a restituire un valore.

Mentre i sottoprogrammi del tipo subroutine, non hanno tipo esplicito e restituiscono il risultato o nessun valore con una chiamata del parametro CONTAINS(). Poichè porremo l’attenzione sui sottoprogrammi esterni, è essenziale l’utilizzo di una caratteristica del fortran 90 conosciuta come INTERFACE BLOCKS.

Questo blocco è una caratteristica di sicurezza che permette che i programmi principali ed i subprograms esterni si connettano giustamente. Un INTERFACE BLOCKS si accerta che il programma chiamante ed il subprogram abbiano il numero ed il tipo corretti di argomenti.

Ciò aiuta il compilatore a rilevare l’uso errato d’un subprogram . Un INTERFACE BLOCK consiste di:

1. numero di argomenti
2. tipo di ogni argomento
3. che tipo del value(s) ha restituito il subprogram

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Gli array bidimensionali in Fortran
• Gli array monodimensionali nel Fortran
• Il ciclo Do implicito nel Fortran
• I cicli nel Fortran
• Espressioni logiche nel Fortran

Il ciclo DO nel Fortran già visto nella lezione precedente può essere realizzato anche in una forma implicita che permette di esprimere l’operazione in un modo molto più compatto; tale costrutto risulta molto comodo nelle operazioni di ingresso/uscita, vediamo allora un esempio:

WRITE(*,10) ( lista(i), i=1,7 ) 10 FORMAT (1X,’lista=’,10F9.3 )

Questa istruzione permette di visualizzare la lista di argomenti in funzione dell’indice i. Quindi saranno visualizzati gli elementi dell’array lista nel seguente ordine:

lista(1),lista(2),lista(3),lista(4),lista(5),lista(6),lista(7)

Gli argomenti di una lista di output possono essere del tipo: costante, espressione o elemento di un array. Nell’istruzione WRITE ogni argomento della lista viene stampato una volta per ogni iterazione, ne risulta che l’operazione precedente stamperà i 10 elementi del vettore lista sulla stessa riga.

E’ logico che in una operazione del genere gli argomenti possono essere più di uno infatti la forma generale di una istruzione che contiene un ciclo implicito è la seguente:

WRITE (unita,format)(val1,val2,….,i=inizio,fine,step)
READ(unita,format)(val1,val2,….,i=inizio,fine,step)

dove val1,val2,.. rappresentano i diversi argomenti oggetto dell’istruzione.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Il comando implicit none nel Fortran
• Struttura di base di un programma Fortran
• Compilazione di un programma nel fortran
• Gli array monodimensionali nel Fortran
• Il ciclo Do implicito nel Fortran
• I cicli nel Fortran
• Espressioni logiche nel Fortran
• Le dichiarazioni di variabili nel Fortran

Le forme simboliche degli operatori relazionali consentite nel Fortran sono le seguenti:

.Lt. < .GT. > .EQ. =
.LE. <= .GE. > = .NE. / =

Il costrutto IF-ELSE può essere chiamato fissando un’etichetta all’inizio del blocco:

nome : IF ( argomento logico )THEN
    istruzione
ELSE IF ( argomento logico ) THEN
   istruzione
END IF nome

Il costrutto CASE può essere usato per eseguire un insieme dei criteri di selezione di multi-alternativa:

nome : SELECT CASE (espressione di CASE)
CASE (selettore 1) nome
istruzione 1
istruzione 2
…….
CASE (selettore 2) nome
istruzione 1
istruzione 2
…….
…..
CASE DEFAULT nome
(selettore 2) nome
istruzione 1
istruzione 2
…….
END SELECT nome

Il selettore può essere un numero intero, un carattere, o un’espressione logica. Così come i blocchi di IF_ELSE, i costrutti CASE possono anche essere etichettati con un nome. L’opzione di DEFAULT in una costruzione CASE può essere omessa, ma è preferibile inserirla per migliorare lo stile del codice.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Il comando implicit none nel Fortran
• Struttura di base di un programma Fortran
• Compilazione di un programma nel fortran
• Gli array monodimensionali nel Fortran
• Il ciclo Do implicito nel Fortran
• I cicli nel Fortran
• Espressioni logiche nel Fortran
• Le dichiarazioni di variabili nel Fortran

Quando si invoca il comando IMPLICIT NONE, in ambiente FORTRAN, tutte le variabili di programma devono essere specificate esplicitamente. Le istruzione modificate di specifica del tipo possono essere usate per inizializzare le variabili o i parametri, ad esempio analizziamo le seguenti dichiarazioni:

Real :: Di = 0
integer :: Num\_Months = 12
Real,Parameter :: Pi = 3,1415927

La viaribile Di è dichiarata come tipo reale con valori iniziali 0., mentre Num\_Months rappresneta una variabile numero intero con il valore iniziale 12 e pi un parametro reale con il valore 3,1415927.

Il separatore :: (due punti) è richiesto in un’istruzione di specifica del tipo ogni volta che è usato per inizializzare una variabile o per dichiarare un attributo speciale (quale il PARAMETRO). Può essere omesso in altri casi.

Ad esempio, per dichiarare Area_circle come variabile reale, possiamo scrivere:

Area_circle Real

o, equivalentemente

Real :: Area\_circle

La seconda forma è consigliata in quanto presenta uno stile di programmazione uniforme. La precisione di un numero reale, di un numero intero, o complesso, o di una variabile logica può essere specificata usando un parametro del tipo KIND.

Ad esempio, per dichiarare una variabile A come un numero reale con almeno 10 cifre decimali di precisione con una gamma compresa tra -10^34 a 10^34, possiamo scrivere quanto segue:

REAL(KIND = SELECTED\_REAL\_KIND(10,34)) :: A

Se il processore che state usando non può sostenere una variabile con questa specifica di tipo, ne risulterà un errore compile-time. Per dichiarare una variabile reale equivalente a quella in doppia precisione presente nel fortran 77 ,dobbiamo scrivere semplicemente questo:

INTEGER, PARAMETER :: DP = SELECTED\_REAL\_KIND(14)
REAL(KIND = DP) :: A

Ciò dichiara la variabile A come reale e con almeno 14 cifre decimali. Il ;(punto e virgola) è usato come separatore in modo che diverse diverse istruzioni possano essere collocate sulla stessa riga. E’ però opportuno precisare che il posizionamento di più istruzioni su di una singola riga produce un codice poco leggibile, è quindi conveniente utilizzare tale applicazione solo per istruzioni semplici.

Ad esempio tre semplici istruzioni di assegnazione possono essere scritte come:

a=1;b=2;c=3

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Il comando implicit none nel Fortran
• Struttura di base di un programma Fortran
• Compilazione di un programma nel fortran
• Gli array monodimensionali nel Fortran
• Il ciclo Do implicito nel Fortran
• I cicli nel Fortran
• Espressioni logiche nel Fortran
• Le dichiarazioni di variabili nel Fortran

Un errore frequente che viene commesso dai programmatori è quello di utilizzare una variabile prima che questa venga dichiarata. In realtà tale rischio è tipico dei linguaggi di programmazione procedurali mentre quelli che sono stati realizzati per la programmazione ad oggetti ne sono esenti.

Il motivo di tutto questo è dovuto al fatto che il linguaggio di programmazione Fortran richiede che ogni variabile prima di essere utilizzata sia correttamente dichiarata, e non solo; prima di essere utilizzata dovrà anche essere inizializzata.

E’ questo il motivo per cui ogni programma Fortran, nella sezione dichiarativa presenta una dichiarazione dettagliata di tutte le variabili che in esso vengoo utilizzate.

Ed è proprio in tale momento che si può commettere l’errore di dimenticarsi della dichiarazione di una variabile che quindi verrà utilizzata all’interno del programma senza essere stata utilizzata e provocando quindi un errore.

Per obbligare il programmatore alla dichiarazione di tutte le variabili si utilizza appunto il comando inplicit none.

La sintassi dello statement implicit none è la seguente:

IMPLICIT NONE

Questo statement è utilizzato per evitare errori di utilizzo di variabili.Quando cioè viene utilizzato lo statement implicit none tutte le variabili devono essere dichiarate in una dichiarazione di tipo (dichiarazione specifica).

Ad esempio del tipo:

REAL :: {list of variables}

Nell’ipotesi una variabile venisse utilizzata senza essere stata dichiarata, un errore verrebbe rilevato in fase di compilazione. in questo modo riusciamo ad avere un controllo sulle variabili utilizzate nel programma.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Struttura di base di un programma Fortran
• Compilazione di un programma nel fortran
• La programmazione ad oggetti in Ruby
• Caratteristiche del linguaggio di programmazione Ruby
• I commenti in Python

Un programma in fortran 90 è caratterizzato dalla seguente struttura:

1) Sezione dichiarativa
E’ posizionata all’inizio e contiene istruzioni non eseguibili quali:

•     nome del programma preceduto dal testo program;
•     dichiarazione delle variabili.

2) Sezione esecutiva.
Rappresenta il corpo del programma e contiene le istruzioni eseguibili necessarie per effettuare le operazioni per le quali il programma stesso è stato ideato.

3) Sezione conclusiva.
Contiene le istruzioni che interrompono il programma quali:

•     stop che interrompe il programma;
•     end program che dice al compilatore che non c’`e pi`u nulla da compilare.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Compilazione di un programma nel fortran
• La programmazione ad oggetti in Ruby
• Caratteristiche del linguaggio di programmazione Ruby