Impariamo a programmare in Fortran 77s, questo linguaggio che tanto piace agli studenti delle universita' italiane... ;)

Fondamenti di programmazione in Fortran 77s

Chapter 1
Written by phobos

Quando mi sono avvicinato per la prima volta a questo tipo di linguaggio (era il lontano 1994... azzo... sto diventando vecchio...) da subito iniziammo ad odiarci vicendevolmente... :P io non sopportavo lui e lui non sopportava il mio fido 80386 senza coprocessore matematico (m'avesse compilato un programma, quel lurido di un compilatore Micro$oft...) Fui costretto comunque a studiarlo, visto che al primo anno di universita', al primo esame, mettersi a fare la guerra contro i mulini a vento non e' bello... e mano a mano che andavo avanti nello studio, scoprivo che il f77 mi faceva proprio vomitare (ROTFL) ma che diamine... un linguaggio cosi' semplice doveva crearmi tutte queste difficolta'?

Fu cosi' che, tanto battei la testa sul libro e sui listati dei programmi realizzati, che lo imparai, feci l'esame, e tutto felice presi il floppy con il compilatore e lo riposi sotto i miei scarponcini chiodati numero 45...

Fino a quando non passai a Matematica, dove incontrai una professoressa che decise che io e il fortran saremmo ritornati ad essere ottimi amici... 

Compilatore F77s Fondamentale, a meno che' non vogliate andare a "naso" come toccava fare a me ;) (Vivamente consigliato il Salford)

Editor di vostro gusto Io utilizzo UltraEdit, comunque, e' necessario un editor testuale con cui abbiate familiarita'

Il FORTRAN (FORmula TRANslator) e' un linguaggio orientato alla programmazione di problemi tecnico-scientifici, nel quale le istruzioni di calcolo si esprimono secondo un formalismo analogo a quello algebrico tradizionale e quelle di controllo con frasi tratte dalla lingua inglese. Nel 1959 esso fu presentato dalla IBM per i calcolatori di propria produzione e si e' poi ampiamente diffuso anche presso altre case costruttrici, per cui allo stato attuale e' il linguaggio di impiego piu' comune per la programmazione scientifica. Perche'? Perche' la presenza di tonnellate di librerie specifiche ed ottimizzate per la risoluzione di problemi matematici di tipo comune, permette di riciclare il codice senza dover ogni volta impazzire dietro a routines e cose simili.

La notevole diffusione del linguaggio e la conseguente realizzazione dei relativi compilatori su sistemi calcolatori di caratteristiche diverse (quali elaboratori di tipo scientifico e anche commerciale, mini elaboratori, ecc.) favori' la nascita di numerose versioni del linguaggio che differivano per alcuni dettagli non di rilevante importanza ma che, di fatto, rendevano difficile lo scambio di programmi fra utenti di sistemi calcolatori diversi.

Per tali motivi "l'American National Standard Interchange" (ANSI) ritenne di dover definire uno standard del linguaggio. Un prima standard del linguaggio fu messo a punto nel 1964 e poi aggiornato nel 1966. Tale documento definiva due distinte versioni del FORTRAN denominate rispettivamente "FORTRAN base" e "FORTRAN 66"; di queste, la prima conteneva le figure fondamentali del linguaggio, cosi' come implementate sui mini elaboratori dell'epoca, la seconda era allineata con le versioni realizzate su calcolatori miedio-grandi.

Successivamente furono riscontrate grosse limitazioni del linguaggio. fondamentalmente per quanto attiene ai seguenti aspetti:

- Trattamento dei caratteri

- Gestione dell'Input/Output su memorie di massa

- Figure strutturate e la definizione del flusso di controllo dei programmi.

Per questo motivo l'ANSI ha elaborato un nuovo standard, approvato nel 1978, detto "American National Standard Programming Language Frotran X3.9-1978" per gli amici Fortran77s, poiche' il suo sviluppo venne completato nel 1977.

Nel periodo 1978-1990 il gruppo di standardizzazione ha continuato la propria attivita' fino ad arrivare alla pubblicazione del Fortran 90. Evoluzione naturale del Fortran 77 (d'ora innanzi f77) che pur mantenendo una completa compatibilita' con i costrutti definiti nel vecchio standard, integra nuove funzioni definite nei linguaggi di nuova concezione (costrutti strutturati while, repeat, case; programmazione orientata agli oggetti; ecc.).

Nella scrittura di un programma, spesso si inizia erroneamente a "buttare giu' codice" affrontanto i problemi mano a mano che questi si presentano. Cio' non e' un buon metodo di programmazione, perche' seppur rapido e funzionante con programmini semplici e con poche righe di codice, diventa molto difficile scrivere grossi programmi in questo modo e gli errori di implementazione diventano frequenti, senza contare che la leggibilita' dei sorgenti diviene ostica, quindi il codice prodotto risulta difficilmente manutenibile.

Per questo motivo, i moderni programmatori utilizzano delle tecniche di analisi dei problemi che devono essere gestiti mediante un calcolatore (ovviamente nella maggior parte dei casi, non e' il programmatore ad effettuare l'analisi, ma questa e' affidata a figure professionali che prendono il nome di "analisti") prima di arrivare alla "brutale" stesura del codice.

In questo paragrafo cerchero' di illustrarvi una di queste tecniche: la Top-Down.

La tecnica Top-Down (o tecnica mediante raffinamenti successivi) e' un semplice metodo di schematizzazione del problema da risolvere, che se utilizzata bene, permette di scrivere programmi anche di dimensioni considerevoli, facendo poca fatica. Il bello di questa tecnica e' che se portata all'esasperazione, permette di programmare in qualsiasi linguaggio, senza conoscere quest'ultimo... Come? Semplice, si arriva a schematizzare le operazioni da compiere in maniera cosi' elementare, che alla fine si tratta solo di tradurre ogni singola operazione nel suo corrispettivo in un dato linguaggio.

Mediante questo metodo, il tempo "perso" durante la fase della schematizzazione del problema, viene recuperato nella scrittura del codice, la portabilita' dello stesso e' molto piu' evidente e gli errori che si possono compiere sono molto limitati.

Ma vediamo come deve essere effettuata una analisi di tipo Top-Down su un problema, magari banale, come potrebbe essere la realizzazione di un programma che calcoli l'area di un triangolo, prelevando da tastiera i dati necessari (Altezza e base).

Problema: Dato un triangolo, realizzare un programma che ne calcoli l'area.

Il problema puo' essere risolto facilmente, iniziando a scrivere subito un programma che ne calcoli l'area dopo aver fatto immettere all'utente i dati necessari, e cosi' facendo commetteremmo l'errore evidenziato all'inizio di questo paragrafo... quindi, schematizziamo ;)

Cosa dobbiamo fare? Innanzitutto scriviamo una prima schematizzazione del problema:

PROGRAMMA TRIAGOLO

Calcola l'area del triangolo dopo aver chiesto l'inserimento dei dati necessari.

FINE

Questo esempio, se dato in pasto a un compilatore, mettera' il computer in condizione di sputarci in faccia... ma e' gia' un inizio... continuiamo a raffinare...

PROGRAMMA TRIANGOLO

DATI NECESSARI: ALTEZZA, BASE

DATI DA FORNIRE: AREA

PRELEVA I DATI

CALCOLA L'AREA

FORNISCI I RISULTATI

FINE

Cosi' e' gia' piu' definito il problema... ovviamente, potremmo partire direttamente da definizioni piu' specifiche, ma non evidenzieremmo i "raffinamenti successivi" che andiamo ad operare sul problema... andiamo avanti...

PROGRAMMA TRIANGOLO

DATI DI INPUT: ALTEZZA, BASE

DATI DI OUTPUT: AREA

INSERIMENTO ALTEZZA

INSERIMENTO BASE

AREA = (BASE * ALTEZZA) / 2

COMUNICA AREA

FINE

Siamo ad un ottimo punto della stesura. A questo punto potremmo passare gia' alla codifica vera e propria, visto che si tratta di un problema banale, ma voglio effettuare un ulteriore raffinamento, in modo tale da poter avere poi una corrispondenza uno a uno tra le "istruzioni" del nostro "linguaggio di progetto" (come viene denominato in ambiti universitari) ed il nostro sorgente.

PROGRAMMA TRIANGOLO

DATI DI INPUT: ALTEZZA, BASE

DATI DI OUTPUT: AREA

SCRIVI A VIDEO: "IMMETTERE LA BASE"

INPUT BASE

SCRIVI A VIDEO: "IMMETTERE L'ALTEZZA"

INPUT ALTEZZA

AREA = (BASE * ALTEZZA) / 2

SCRIVI A VIDEO "L'AREA DEL TRIANGOLO E'", AREA

FINE

A questo punto, possiamo tranquillamente tradurre il nostro programma... vi affianchero' due tipi di notazioni, una definita "pascal-like" utilizzata spessissimo nella fase di analisi del problema e nella conseguente scrittura del "linguaggio di progetto" e la relativa traduzione in f77, cosi' da iniziare ad avvicinarvi a questo linguaggio:

program TRIANGOLO                               program TRIANGOLO

var altezza, base                               real altezza, base

var area                                        real area

begin

writeln 'IMMETTERE LA BASE';                    write(*,*)'IMMETTERE LA BASE'

readln base;                                    read(*,*) base 

writeln 'IMMETTERE L'ALTEZZA';                  write(*,*)'IMMETTERE L'ALTEZZA'

readln altezza;                                 read(*,*) altezza 

area = (base * altezza) / 2                     area = (base * altezza) / 2

writeln 'L'AREA DEL TRIANGOLO E'', area         write(*,*) 'L''AREA DEL TRIANGOLO E'', area

end                                             end

Una delle limitazioni, forse piu' fastidiose del fortran e' l'editing dei sorgenti. Questo tipo di linguaggio soffre di particolari limitazioni che sono imputabili alla sua vecchia "concezione"; limitazioni che comunque possono essere agilmente superate utilizzando un moderno editor di testo e configurando quest'ultimo con qualche piccolo accorgimento.

Vediamo come procedere.

La struttura, secondo lo standard, di una linea di codice in fortran e' cosi' composta:

01....67................................................................72

|   |  |                           |                                    |

|   |  |                           |                           Ultimo carattere

|   |  |                      istruzioni

|   |  Inizio istruzioni

| Label

Carattere speciale

Le istruzioni del sorgente possono essere inserite in qualsiasi posizione all'interno delle colonne da 7 a 72, le colonne da 1 a 6 sono destinate alla presenza delle "labels" che devono essere strutturate come una qualsiasi sequenza di numeri diversa da 0 (dei veri e propri numeri di riga che vengono utilizzati nella realizzazione dei costrutti iterativi e di controllo presenti nei moderni linguaggi strutturati). La colonna 0 viene utilizzata con due scopi fondamentali: una C posta in questa posizione permette di inserire i commenti al codice, difatti tutto cio' che segue la lettera C, viene ignorato dal compilatore in fase di compilazione; mentre un carattere # indica il proseguimento di una linea di codice iniziata alla riga precedente. Chiaramente, nulla deve essere inserito se la linea di codice che stiamo scrivendo non rientra in queste due casistiche.

Nota: I compilatori di vecchia generazione, restituiscono errori di compilazione nel caso vengano superate le 72 colonne. Questo limite viene superato dai moderni compilatori (un esempio e' il Salford) che risultano essere piu' elastici e, nel caso si "sfori" la lunghezza di 72 caratteri, restituiscono un "warning" in compilazione, ma fa girare regolarmente il programma.

Vediamo un esempio (gli spazi, o blanks, saranno evidenziati da punti):

......PROGRAM ESEMPIO

...... dichiarazioni

C questa linea e' un commento, ci scriviamo quello che ci pare.....

C segue un ciclo for...to per mostrare l'uso delle label

......DO 100 I=1,10

......  WRITE(*,*) 'Stampiamo a video questo messaggio', I, ' VOLTE'

.100..CONTINUE

......   DO WHILE ((a.GT.b).OR.(a.GT.c).OR.(a.GT.d).OR.(a.GT.e).OR.

#.....   (a.GT.f))

C La linea sopra e' il seguito del 'while'

...... altre istruzioni

......   END DO

......END

Come e' possibile vedere dall'esempio (in cui tutte le parole chiave del linguaggio sono state evidenziate in grassetto), se si dispone di un editor di testo discreto e di un po' di pazienza per configurarlo, le difficolta' iniziali a cui si potrebbe andare incontro nella scrittura dei programmi, possono essere agevolmente superate.

Iniziamo ad illustrare i vari tipi di dati presenti nel linguaggio Fortran. I tipi di variabili standard definite da questo linguaggio sono i seguenti: intero, reale, reale a doppia precisione, logico e carattere (singolo carattere). Il fortran definisce inoltre dei tipi di dati strutturati nella forma di numeri complessi, array (matrici) e di stringhe di caratteri. Sono definiti in forma implicita anche i tipi record e file, utilizzabili solo per le operazioni di input/output su files. Nello standard del linguaggio, non vengono definiti, ovviamente, le approssimazioni relative dei tipi reali e i massimi o minimi di ciascun tipo, che rimangono funzione del tipo di architettura utilizzata.

Le variabili di un programma in fortran vengono definite nella parte iniziale del listato, dopo la direttiva

PROGRAM nome_programma

che indica l'inizio del programma, mediante gli statements: INTEGER, REAL, DOUBLE PRECISION, LOGICAL e CHARACTER.

Il tipo intero e' definito secondo lo standard mediante una sequenza di numeri senza punto decimale preceduta dal segno (piu' o meno). Viene dichiarato mediante la struttura:

INTEGER name

Con INTEGER tipo e name nome della variabile.

Il tipo reale e' definito mediante una sequenza di numeri preceduta dal segno, contenente o meno un punto decimale e seguita da un esponente positivo o negativo. Si puo' utilizzare una qualsiasi forma di rappresenzazione esponenziale, noi per non fare confusione utilizzeremo la "virgola mobile normalizzata" (per definizione di virgola mobile normalizzata: prima cifra sempre 0 seguita dal punto decimale e dalle cifre significative dopo questo, lo zero puo' essere omesso. L'esponente viene rappresentato mediante un numero intero positivo o negativo preceduto da una E che indica il "dieci": .12817283E-15).

REAL name

REAL identificatore di tipo, name nome della variabile.

Il tipo DOUBLE PRECISION e' identico al reale, ma utilizza il doppio dello spazio in memoria per la memorizzazione della mantissa del numero, permettendo di avere una maggiore precisione di calcolo grazie al maggior numero di cifre significative.

DOUBLE PRECISION name

Il tipo logico definisce i due valori booleani "vero" e "falso". In fortran questi due valori sono definiti mediante le parole chiave .true. e .false. (da notare il carattere . che precede e segue la parola chiave).

LOGICAL name

stesse convenzioni di sopra

Il tipo character viene definito mediante un carattere, lo standard prevede che venga utilizzato il set dei caratteri ASCII.

CHARACTER name

Esempio:

INTEGER I                    definisce una variabile di nome I e di tipo intero

REAL A                       definisce una variabile di nome A e di tipo reale

DOUBLE PRECISION B           definisce una variabile di nome B e di tipo reale in doppia precisione

LOGICAL ANS                  definisce una variabile di nome ANS e di tipo logico (Booleana)

CHARACTER TEXT               definisce una variabile di nome TEXT e di tipo carattere

I tipi strutturati sono, come gia' premesso, i seguenti: Complessi, Array, Stringhe.

Il tipo array viene definito secondo lo schema generale:

type name (xmin:xmax,ymin:ymax,zmin:zmax,...)

dove type indica il tipo di variabili che costituiscono l'array (reali, complessi, doppia e cosi' via) name e' il nome della struttura, i parametri nmin:nmax indicano le locazioni che verranno utilizzate nella struttura. Questi parametri permettono di indicizzare un array con indici prestabiliti (ad esempio da -4 a 7, per un totale di 12 locazioni). E' possibile, chiaramente omettere il valore nmin, in tal modo, la numerazione sara' progressiva dallo zero al valore nmax specificato. Non vi sono limiti rispetto alle dimensioni degli array (ovviamente, memoria permettendo... ;))

I complessi sono identificati da una coppia di numeri reali, costituenti la parte reale e quella immaginaria del numero complesso.

Sono definiti secondi la forma:

COMPLEX name

e la coppia di valori e' identificata con la notazione (real, imag).

Le stringhe vengono identificate come tipo carattere strutturato (ovvero come un array di caratteri) secondo la definizione:

CHARACTER*n name

Dove, come al solito CHARACTER identifica il tipo, n il numero di caratteri presenti nella stringa e name e' il nome della variabile.

Vediamo alcuni esempi:

REAL VETTORE (9)              definisce un vettore di 9 elementi chiamato 'VETTORE'

REAL MATRICE (7,4)            definisce un array di numeri reali di dimensioni 7 * 4

INTEGER MATRICE (5,5)         come sopra, solo che l'array e' di interi e la dimensione e' 5 * 5

CHARACTER*7 NOME              definisce una stringa di sette caratteri chiamata 'NOME'

COMPLEX X                     definisce una variabile di tipo complesso di nome X

Le costanti con nome possono essere dichiarate all'inzio del programma assieme alle variabili, a patto che ne sia dichiarato il tipo. Questa operazione viene effettuata mediante gli statament

type name

PARAMETER (name = value)

Dove type e' il tipo di valore che verra' assunto dalla costante, name e' il suo nome e value il valore.

Esempio:

INTEGER K

PARAMETER (K = 100)

REAL X

PARAMETER (X = .0001E-12)

DOUBLE PRECISION Z

PARAMETER (Z = .00000000001D-12)

CHARACTER NAME

PARAMETER (NAME = 'phobos')

e cosi' via.

Da notare come la lettera che indica l'esponente nel tipo a doppia precisione sia distinta da quella del tipo reale (D al posto di E). Questo tipo di convenzione e' utilizzata anche nella rappresentazione delle costanti numeriche (quelle senza nome) che possono venire utilizzate nei programmi senza che siano dichiarate nella sezione iniziale degli stessi. Vediamo ora un esempio per ogni tipo di costante:

I = 123                     intera

PI = 3.141592            reale

PID = 3.14159265D0   reale a doppia precisione

STRING = 'papero'      stringa

STR = 's'                  carattere

X = (1.,-1.)              complesso

B = .true.                 booleano (o logico)

Prima di fermarci, e' necessaria una ulteriore precisazione sugli array. Il linguaggio fortran non permette la dichiarazione di array dinamici in seno ad un programma, quindi se dobbiamo lavorare con un numero sconosciuto di valori, ad esempio all'interno di una tabella, saremmo costretti a dimensionare delle matrici di dimensioni spropositate con il rischio di saturare inutilmente la memoria. Questo problema e' risolvibile mediante l'utilizzo delle subroutines (struttura ampiamente supportata dal fortran) che permette di passare come parametro globale le dimensioni dell'array e quindi ne permette l'inizializzazione secondo quelle che sono le necessita' effettive del programma. Ma questi dettagli li tratteremo in seguito.

Per oggi e' tutto, come al solito sono benvenuti i commenti e le critiche.

                                                                                                                                     phobos

Do re mi... hihihihi scherzi a parte... un ringraziamento a tutte le persone che lo meritano, non faccio nomi...

Tutti i marchi citati sono proprieta' o Copyright dei rispettivi autori o proprietari.

Questo documento puo' essere riprodotto e ridistributo sotto qualsiasi forma e con qualsiasi mezzo a condizione che non venga modificato in nessuna sua parte e che ne venga riconosciuta la paternita' dell'autore. Ogni violazione verra' perseguita mediante opportuna randellatura effettuata mediante adeguati strumenti (leggi: Crick FIAT 131 Mirafiori).

(C) Copyright by phobos for U.I.C. and P.H.R.E.W. Y2K3. All Rights Reserved.