Subprograms

Generalità


Così come il fortran 77, il fortran 90 tiene conto di due tipi di subprograms: 

(1) funzioni 
      e 
(2) subroutine.
 
In generale, ci sono due forme di subprograms: interni ed esterni. 
I subprograms interni sono quelle procedure che possono comparire nell'ambito del programma
principale, in questo caso il subprogram vede tutte le variabili presenti nel programma che li contiene.
Il costrutto per l'inserimento di una routine all'interno di un altro programma è il seguente:

program prova

.............
.............
call sub(a,b,c)  !Chiamata alla subroutine
............. 

contains
  subroutine sub(a,b,c)
     .............
     .............
  end subroutine sub
end program prova

I subprograms esterni sono quelli che compaiono in
una sezione separata di programma dopo l' istruzione principale di END di programma.
Ciò è molto simile alle pratiche che già
abbiamo incontrato in fortran 77.

Inoltre, così come in fortran 77, i subprograms del tipo function in fortran 90 hanno un tipo esplicito e sono indirizzati
a restituire un valore.I subprograms del tipo subroutine, d'altra parte, non hanno tipo esplicito e restituiscono il 
multiplo o nessun valore con una chiamata di parametro CONTAINS().

Poiché metteremo a fuoco i subprograms 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.  Il numero di argomenti
    2.  il tipo di ogni argomento 
    3.  che tipo del value(s) ha restituito il subprogram

Richiameremo le varie funzioni dei subprograms attraverso alcuni esempi.

Function


Come esempio d'un programma che usa una Function, consideriamo quanto segue:

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)
!
!---------------------------------------------------------------------
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 di funzione funziona allo stesso modo del subprogram di funzione in 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.


Subroutine


Un esempio di subroutine di fortran 90 è fornito qui sotto:

               
               !TRASFORMATA DI FOURIER DISCRETA
               !________________________________
               
               
 subroutine dft (A,N,E)
 
 implicit none
 
 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.
Nella subroutine vista,le caratteristiche principali sono rappresentate dai parametri
di scambio,presenti a fianco al nome della subroutine e nella chiamata del programma 
principale.Devono essere posti nello stesso ordine ma possono essere indicati anche 
con nomi diversi;all'interno della subroutine devono essere definiti nuovamente.                               


Subprograms ricorsivi


Il fortran 90, come nel caso del fortran 77, permette l'uso dei subprograms ricorsivi. 
Come esempio di una funzione ricorsiva consideriamo la seguente:



     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