Per stampare: Clicca qui oppure seleziona File » Stampa nel menù del tuo browser.

        -----------------------------------------------------------------------------------------------
        Questo intervento è stato stampato da Guide di Dada.Net
        raggiungibile a http://guide.dada.net
        -----------------------------------------------------------------------------------------------

By Fortran di Giuseppe Ciaburro
URL: http://guide.dada.net/fortran/interventi/2001/07/53268.shtml

Fortran di Giuseppe Ciaburro guida dal 04-06-2002

Innovazioni

Le innovazioni principali introdotte con il Fortran 90

Le innovazioni principali introdotte con il Fortran 90 riguardano i seguenti argomenti:

•formato libero, svincolato dal vecchio formato fisso, orientato alle colonne, che risentiva ancora dell'impostazione tipica delle schede perforate;
•costrutti per la definizione di procedure e strutture dati modulari, tesi a fornire una forma semplice e sicura per incapsulare dati e procedure;
•tipi di dati definiti da utente, derivati da uno o più dei 6 tipi di dati intrinseci del Fortran;
•operazioni globali su array e definizione di un set di funzioni intrinseche che operano su array;
•introduzione dei pointers, che consentono la creazione e la manipolazione di strutture dati dinamiche;
•miglioramento dei costrutti per la computazione numerica, inclusa la disponibilità di tipi numerici intrinseci parametrizzati;
•tipi di dati intrinseci non numerici parametrizzati, che consentono di supportare più di un set di caratteri contemporanemente.

Con il Fortran 90 è possibile definire nuovi tipi di dati, nuovi operatori e assegnare nuovi significati agli operatori esistenti. Tali possibilità consentono di creare tipi di dati astratti definendo nuovi tipi di dati e le operazioni che si possono eseguire su di essi. Ad esempio:

type studente
integer età
real altezza
character(len=300) nickname
end type giuseppe

è un tipo di dato definito da utente a tre componenti. Per definire oggetti del tipo studente è sufficiente fare una dichiarazione quale:
type(studente) Giuseppe, Marco

Nel Fortran 90 sono stati introdotti i moduli, essi rappresentano un metodo comodo per impacchettare questi nuovi tipi di dati e le operazioni su di essi. I moduli si possono utilizzare all'interno di una stessa applicazione oppure richiamare da applicazioni differenti, come si può vedere dalla figura qui sopra. Il costrutto dei moduli fornisce un supporto pratico ed efficace per la programmazione object-oriented e, al tempo stesso, consente una programmazione più efficiente ed elegante.
Un modulo può contenere dichiarazioni dati e procedure che possono essere utilizzate in parti diverse di un programma come mostra l'esempio che segue:

module total_stuff
contains
function total(n)
integer total, n, i
total = 0
do i = 1, n
total = total + i
end do
end function total
end module total_stuff

program do_total
use total_stuff
print*, total(100)
end program do_total

Il modulo e il programma possono risiedere anche su files diversi; I moduli possono essere compilati in modo del tutto analogo alle routine ma, a differenza di queste ultime, devono essere accessibili al compilatore quando compila il programma che li richiama.
Il modulo total_stuff è globale e qualsiasi programma può utilizzare il modulo, così il tipo e la definizione della function total diventa utilizzabile all'interno di quel programma (use association).

Il Fortran 90 ammette tre categorie di dati dinamici: pointers, allocatable arrays e array automatici.

Un oggetto con attributo pointer va associato con un target prima del suo utilizzo. Ciò può avvenire allocando spazio per il target oppure assegnando il pointer ad un target esistente. L'associazione del pointer con un target può cambiare dinamicamente durante l'esecuzione del programma. Se il pointer è un array la sua forma e la dimensione può cambiare dinamicamente, ma il suo rank è fissato dalla dichiarazione. L'esempio che segue riporta una dichiarazione di pointer array e della sua allocazione:

real, pointer::lengths(:)
allocate (lengths(200))

Con l'esecuzione di un'istruzione allocate, lengths punta ad un array di 200 elementi (gli elementi non hanno ancora valore).
I puntatori possono essere usati per creare strutture dati dinamiche quali liste linked ed alberi.

Un array può essere dichiarato allocatable. Lo spazio deve essere allocato per l'array prima che esso possa essere usato in qualche calcolo. L'array può essere deallocato e, successivamente, riallocato con una diversa dimensione durante l'esecuzione del programma. La dimensione e la forma può cambiare ad ogni allocazione, ma il rango è fissato dalla dichiarazione.

L'esempio che segue mostra la dichiarazione di un allocatable array e la sua conseguente allocazione:

real, allocatable::lengths(:)
allocate (lengths(200))

Mentre il target di un pointer può essere cambiato tramite riallocazione o assegnamento di pointer, l'estensione di un allocatable array può essere cambiato solo tramite deallocazione e riallocazione dell'array.
Se i valori degli elementi di un array allocatable devono essere preservati, deve essere allocato un nuovo array e i valori devono essere spostati sul nuovo array prima che venga deallocato il vecchio.

Un array automatico è un array locale ad un sottoprogramma; questa struttura viene creata quando si richiama la routine e rimossa quando termina l'esecuzione del sottoprogramma. Questi oggetti sono utili nei sottoprogrammi per gestire array temporanei o stringhe di caratteri le cui dimensioni variano nei diversi riferimenti al sottoprogramma, come mostra il codice che segue per l'array temp.

subroutine swap_arrays(a,b)
real,dimension(:)::a,b
real,dimension(size(a))::temp
temp = a
a = b
b = temp
end subroutine swap_arrays

Si noti che size è una funzione intrinseca, il cui significato è ovvio dal nome, richiamabile da uno statement dichiarativo.
Infine, in chiusura, ricordiamo che il Fortran 90 introduce tre nuovi tipi di comportamento dinamico: ricorsione, allocazione e deallocazione, assegnazione di pointer.