Una procedura ricorsiva, nel Fortran, rappresenta una costruzione artificiosa che ci consente di utilizzare una funzione in se stessa. Analizziamo come nel liguaggio di programmazione Fortran possa essere gestita una procedura di talke tipo; vediamo allora un semplice esempio di funzione ricorsiva alfine di mettere in evidenza appunto il fatto che la funzione richiama se stessa:

RECURSIVE FUNCTION factorial(n) RESULT(res)
INTEGER res, n
IF(n.EQ.1) THEN
   res = 1
ELSE
   res = n*factorial(n-1)
END IF
END

Analizziamo allora nel dettaglio la funzione che presenta una struttura ramificata. La condizione n == 1 è la base della ricorsione. Questo è l’unico modo che si ha per ottenere che il programma smetta di chiamare se stesso.

La parte contenuta nel costrutto else rappresenta la ricorsione. C’è da notare che la chiamata factorial(n-1) avviene all’interno della funzione che sta definendo factorial(n). La parte essenziale di tutto il procedimento di ricorsione è appunto la chiamata a un valore inferiore, n-1, e tale chiamata continuerà fino a quando non si verificherà un valore di n pari a 0.

Possiamo quindi affermare che una procedura di ricorsione che abbia successo chiamerà sempre un valore inferiore.Ci sono molti pericoli connessi all’utilizzo di un algoritmo di ricorsione. Ad esempio così come accade con i cicli while, è possibile per la funzione di chiamare se stessa all’infinito in modo da non fornire mai una risposta.

Un’altro problema che può nascere dal suo utilizzo è legato al fatto che la ricorsione può causare calcoli ridondanti che, anche se possono essere conclusi, possono richiedere molto tempo. Infine  mentre un programma ricorsivo è in esecuzione ha bisogno di spazio in più per accogliere l’overhead della ricorsione.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• Le subroutine nel Fortran
• Le funzioni nel Fortran
• Sottoprogrammi nel Fortran
• Gli array bidimensionali in Fortran
• Gli array monodimensionali nel Fortran

Una subroutine nel Fortran rappresenta un tipo di procedura, essa viene richiamata specificandone il nome attraverso l’istruzione CALL che riceve i valori di input e restituisce quelli di output attraverso una lista di argomenti.

Il costrutto nella sua forma generale per definire una subroutine è il seguente:

Nella definizione della struttura è possibile identificare il nome della subroutine, che dovrà rispettare le regole per la scelta dei nomi nel Fortran, seguito dall’elenco delle varibili di scambio tra la procedura ed il programma chiamante.

Segue la definizione e la dichiarazione delle variabile che sono utilizzate all’interno della procedura, quindi segue il corpo della procedura cioè le istruzioni che dovrà eseguire nel momento in cui verrà chiamata dal programma principale.

Quando un programma chiama una subroutine, l’esecuzione del programma viene temporaneamente sospesa per consentire l’esecuzione della subroutine. Quando viene raggiunta l’istruzione RETURN o l’istruzione END SUBROUTINE l’esecuzione dell’unità chiamante riprende dalla riga successiva a quel la che ha effettuato la chiamata.

La chiamata avviene attraverso l’istruzione CALL, la cui sintassi è:

Un esempio di soubroutine di fortran 90 è fornito di seguito:

!TRASFORMATA DI FOURIER DISCRETA
!________________________________
subroutine dft (A,N,E)
implicit none
17
integer :: N !numero di campioni
integer :: E !numero di campinature effettuate
integer :: i,j !indice di riga e di colonna della matrice
complex :: uim !unita' immaginaria
complex,dimension(0:1000,0:1000) :: A !matrice complessa

uim=(0,1)
do i=0, n-1
   do j=0, n-1
     A(i,j)=exp(-(2*3.14*uim*i*j)/n)
   end do
end do
E=N
end

Questa subroutine calcola le trasformate discrete di fourier dato un certo campione.

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

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