Fortran

Guida al FORTRAN
applicato
Lorenzo Zaninetti
zaninetti@ph.unito.it
Dipartimento di Fisica Generale
Edizione III
4 marzo 2015
ii
Introduzione
Questa guida cerca di combinare due esigenze molto sentite al secondo anno del corso di Laurea in Fisica: un corso di introduzione ad un
linguaggio di programmazione scientifica e alcuni esempi di programmi
( funzionanti ! ) per l elaborazione dei dati raccolti durante le esperienze di laboratorio. Abbiamo quindi dedicato il capitolo uno ad una
introduzione concisa al linguaggio di programmazione FORTRAN ed il
capitolo due alla descrizione dei programmi per l elaborazione dei dati
che possono essere usati dagli studenti in ambiente MS/DOS oppure
LINUX oppure UNIX. Per soddisfare le esigenze degli studenti degli
anni superiori riportiamo nel capitolo tre alcune subroutine di interesse
fisico-matematico che sono utilissime nei calcoli numerici di probabilità
e statistica scritte in FORTRAN-77 standard. In realtà questa guida
può essere anche utile agli studenti degli anni superiori e quindi dedichiamo il capitolo quattro ai programmi del frattali e il capitolo cinque
a quelli dei sistemi Monte Carlo. L appendice A riporta le funzioni
intrinseche che possono essere richiamate dai programmi, l appendice B alcune subroutines di interesse comune, l appendice C introduce
alcuni cenni del sistema operativo UNIX, l appendice D riporta i caratteri ASCII, l appendice E i comandi del compilatore FORTRAN della
MICROSOFT .
iii
CAPITOLO 0. INTRODUZIONE
iv
Indice
Introduzione
iii
1 Il Fortran-77
1.1 Alcuni libri . . . . . . . . . . .
1.2 Caratteri e linee . . . . . . . .
1.3 Lunghezza della linea . . . . .
1.4 Linea di commento . . . . . . .
1.5 Linea iniziale e di continuazione
1.6 Nomi simbolici . . . . . . . . .
1.7 Nomi locali e globali . . . . . .
1.8 Parole chiave . . . . . . . . . .
1.9 Etichette . . . . . . . . . . . .
1.10 Tipi di dati e costanti . . . . .
1.11 Unità di memoria . . . . . . .
1.12 Tipo INTEGER . . . . . . . .
1.13 Tipo REAL . . . . . . . . . . .
1.14 Tipo DOUBLE PRECISION .
1.15 Tipo COMPLEX . . . . . . . .
1.16 Tipo LOGICAL . . . . . . . . .
1.17 Tipo Character . . . . . . . . .
1.18 Vettori . . . . . . . . . . . . .
1.19 Sottostringa CHARACTER . .
1.20 Espressioni . . . . . . . . . . .
1.21 Espressioni aritmetiche . . . .
1.22 Espressioni costanti intere . . .
1.23 Espressioni CHARACTER . .
1.24 Espressioni di relazione . . . .
1.25 Espressioni logiche . . . . . . .
1.26 Struttura del programma . . .
v
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
2
2
3
3
3
5
5
5
6
6
6
6
7
7
8
8
8
8
9
9
10
11
11
12
13
14
INDICE
INDICE
1.27
1.28
1.29
1.30
1.31
1.32
1.33
1.34
1.35
1.36
1.37
1.38
1.39
1.40
1.41
1.42
1.43
1.44
1.45
1.46
1.47
1.48
1.49
1.50
1.51
1.52
1.53
1.54
1.55
1.56
1.57
1.58
1.59
1.60
1.61
1.62
1.63
1.64
1.65
Classi di istruzione . . . . . . . . .
Ordine delle istruzioni . . . . . . .
Sequenza di esecuzione . . . . . . .
Unità principale del programma .
Unità di programma FUNCTION
Funzioni di referenza . . . . . . . .
Funzioni istruzione . . . . . . . . .
Funzioni intrinseche . . . . . . . .
Sottoprogrammi SUBROUTINE .
Istruzione CALL . . . . . . . . . .
Argomenti della subroutine . . . .
Dimensione tramite PARAMETER
Dimensione tramite numeri . . . .
Dimensione tramite * . . . . . . .
Istruzione RETURN . . . . . . . .
Istruzione ENTRY . . . . . . . . .
Istruzioni di specificazione . . . . .
Istruzione IMPLICIT . . . . . . .
Istruzione PARAMETER . . . . .
Dichiarazioni dei vettori . . . . . .
Istruzioni tipologiche . . . . . . . .
Istruzione DIMENSION . . . . . .
Istruzione COMMON . . . . . . .
Istruzione EQUIVALENCE . . . .
Istruzione EXTERNAL . . . . . .
Istruzione INTRINSIC . . . . . . .
Istruzione SAVE . . . . . . . . . .
Istruzione DATA . . . . . . . . . .
Istruzioni di assegnazione . . . . .
Assegnazioni aritmetiche . . . . . .
Assegnazioni logiche . . . . . . . .
Assegnazioni CHARACTER . . . .
Istruzione ASSIGN . . . . . . . . .
Istruzioni di controllo . . . . . . .
Istruzione GO TO incondizionata .
Istruzione GO TO calcolata . . . .
Istruzione GO TO assegnata . . .
Blocco IF . . . . . . . . . . . . . .
Istruzione IF logica . . . . . . . .
vi
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
15
15
17
17
17
18
19
19
19
20
20
21
21
22
22
22
23
23
23
24
25
25
25
26
26
27
27
28
28
28
29
29
29
30
30
30
31
31
32
INDICE
1.66
1.67
1.68
1.69
1.70
1.71
1.72
1.73
1.74
1.75
1.76
1.77
1.78
1.79
1.80
1.81
1.82
1.83
1.84
1.85
1.86
1.87
INDICE
Istruzione IF aritmetica . . . .
Istruzione DO . . . . . . . . .
Istruzione DO-WHILE . . . . .
Istruzione CONTINUE . . . . .
Istruzione STOP . . . . . . . .
Istruzione PAUSE . . . . . . .
Istruzioni di INPUT/OUTPUT
Nozioni generali . . . . . . . .
Record . . . . . . . . . . . . .
File . . . . . . . . . . . . . . .
Accesso ai file . . . . . . . . . .
File interni . . . . . . . . . . .
Istruzione OPEN . . . . . . . .
Istruzione CLOSE . . . . . . . .
Istruzione INQUIRE . . . . . .
Istruzioni READ/WRITE . . .
Istruzione REWIND . . . . . .
Istruzione BACKSPACE . . . .
Istruzione ENDFILE . . . . . .
La specificazione FORMAT . .
Descrittori ripetibili . . . . . .
Descrittori non ripetibili . . . .
2 Il Laboratorio
2.1 RETTA .
2.2 PARABO
2.3 PENDO .
2.4 CAVEN .
2.5 GAUSS .
2.6 TESTT .
2.7 TESTC2 .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Probabilit`
a e statistica
3.1 Gamma . . . . . . .
3.2 Fattoriale . . . . . .
3.3 Funzione beta . . . .
3.4 Gamma incompleta .
3.5 Funzione errori . . .
3.6 Distribuzioni . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
vii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
32
32
33
34
35
35
35
36
36
37
37
38
38
39
40
40
41
42
42
43
43
45
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
47
47
50
52
60
74
79
80
.
.
.
.
.
.
85
85
86
88
88
91
92
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
INDICE
INDICE
3.6.1 Distribuzione del chiquadro . .
3.6.2 Distribuzione Beta incompleta .
3.6.3 Distribuzione di Student . . . .
3.7 Numeri random . . . . . . . . . . . . .
3.7.1 Generatori di sistema . . . . . .
3.7.2 Generatore Random - portatile
3.7.3 Generatore di interi . . . . . . .
3.7.4 Distribuzione esponenziale . . .
3.7.5 Distribuzione Gaussiana . . . .
3.8 Momenti . . . . . . . . . . . . . . . . .
3.9 Test di Student . . . . . . . . . . . . .
3.10 Fit con retta . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
92
93
95
95
95
96
97
98
99
101
103
105
4 I frattali
4.1 Henon mapping . . . . .
4.2 Feigenbaum mapping . .
4.3 Mandelbrot-set . . . . .
4.4 Implementazione dei set
4.5 Set di Julia e derivati . .
4.6 Le trasformazioni affini .
4.7 Il sistema L . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
109
. 109
. 112
. 115
. 116
. 120
. 120
. 128
5 Sistemi Monte Carlo

5.1 DLA . . . . . . . . . .
5.2 Aggregazione ballistica
5.3 Percolazione . . . . . .
5.4 Catene di Voronoi . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
A Funzioni intrinseche
135
135
144
150
158
167
B Subroutine di interesse comune

175
B.1 CLEANTOP . . . . . . . . . . . . . . . . . . . . . . . . 175
B.2 MAXMIN . . . . . . . . . . . . . . . . . . . . . . . . . . 176
C Sistema operativo UNIX
C.1 Alcuni comandi UNIX . . . .
C.2 Editor . . . . . . . . . . . . .
C.3 Compilazione+link/esecuzione
C.4 Shell Script . . . . . . . . . .
viii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
177
. 177
. 178
. 179
. 179
INDICE
INDICE
C.5 Le librerie . . . . . . . . . . . . . . . . . . . . . . . . . . 180

D I caratteri ASCII
181
ix
INDICE
INDICE
Capitolo 1
Il Fortran-77
Il linguaggio di programmazione FORTRAN, contrazione delle parole
FORmula
TRANslation, è un linguaggio per la soluzione di problemi computazionali. A causa della sua somiglianza con il familiare linguaggio
aritmetico semplifica enormemente la preparazione dei problemi da sottoporre alla macchina. Fu implementato per la prima volta nel 1956
e disponibile per gli utenti dal 1957. Negli anni tra il 1957 e il 1966
il linguaggio sub` alcuni cambiamenti e fu standardizzato dall American National Standards Institute (ANSI) nel 1966. Questa versione,
essendo la quarta dalla nascita del linguaggio, assunse il nome di FORTRAN IV. Il FORTRAN77 è l ultima implementazione ufficiale del
FORTRAN-IV: commissionato all ANSI per migliorare il linguaggio
precedente e renderlo pi`
u portabile, è stato finito nel 1977 ed è stato
pubblicato come ANSI standard X3-9-1978. Successivamente è stato
adottato dalle maggiori compagnie e adesso funziona su tutti i PC e
main frame. Infatti, in FORTRAN, sia i dati che le istruzioni sono organizzati in una sequenza di istruzioni, chiamata normalmente codice
sorgente. Un codice sorgente scritto in FORTRAN può essere eseguito
su qualunque computer possegga un compilatore, con poche o nessuna
modifica. Queste ultime dipendono dal fatto che diverse case costruttrici forniscono implementazioni al linguaggio legate alle possibilità del
tipo di computer che esse fabbricano. Occorre quindi, ad esempio, fare
attenzione nel trasferimento di codici sorgente (o file) da UNIX/LINUX
a personal computer.
1
1.1. ALCUNI LIBRI
1.1
CAPITOLO 1. IL FORTRAN-77
Alcuni libri
Prima di continuare introduciamo brevemente una lista di libri che

possono essere utili per chi volesse avventurarsi in una trattazione pi`
u
completa
1. Un introduzione ingegneristica alla programmazione stile Politecnico si trova in [Or 86]. Troverete anche una utile serie di esercizi
e l associazione fra metalinguaggio e codice FORTRAN.
2. Una trattazione completa viene invece sviluppata in [El 85]. Vengono svolti o proposti molti esercizi.
3. Una trattazione sommaria viene invece svolta in [Do 83].
4. Un riassunto di tutte le istruzioni si trova invece in [Pa 83] : un
manualetto tascabile in inglese.
1.2
Caratteri e linee
L insieme dei caratteri in FORTRAN consiste di 26 lettere dalla A alla

Z, le 10 cifre da 0 a 9 e dai seguenti 13 caratteri speciali:
piu
meno
asterisco
spazio
eguale
/
(
barra (slash)
parentesi sinistra
parentesi destra
punto decimale
,
0
virgola
due punti
apostrof o
<
>
$
1.3. LUNGHEZZA DELLA LINEA

minore
maggiore
simbolo corrente
Attualmente il simbolo corrente può avere un valore diverso a seconda

della tastiera usata: non ha però una funzione precisa in FORTRAN e
quindi si può usare come simbolo di continuazione. Il carattere spazio è
ignorato dappertutto eccetto che nelle variabili CHARACTER e quindi
può essere usato a piacere per migliorare la leggibilità dei programmi.
1.3
Lunghezza della linea
Il compilatore fa uso solamente delle prime 72 colonne in ogni linea:

dalla colonna 73 in poi si possono mettere dei simboli di identificazione. Nelle linee di istruzione, le colonne da 1 a 5 sono riservate come
etichetta, la numero 6 ai segni di continuazione e quelle dal 7 al 72 per
l istruzione stessa. Una linea di commento può essere adoperata dalla
colonna 2 in poi. Questa tipologia deriva dall impostazione originaria
tramite scheda, vedi figura 1.1.
1.4
Linea di commento
Qualsiasi linea con i caratteri C o * in prima colonna viene considerata

una linea di commento. Le linee di commento non contano nulla ai fini
della compilazione ed in esse si può inserire qualsiasi tipo di carattere:
di solito vengono usate per annotazioni nelle varie parti del programma.
La linea composta di spazi nelle sue prime 72 colonne è equivalente ad
uno spazio solo; ossia non conta ai fini della compilazione.
1.5
Linea iniziale e di continuazione
Una linea di istruzione è caratterizzata da uno spazio oppure da uno

zero nella colonna 6; dalla 1 alla 5 devono esserci degli spazi oppure
una etichetta. Qualsiasi istruzione, eccetto l END, può continuare
su linee seguenti fino ad un totale di 20 linee ( una iniziale e 19 di
continuazione ): le linee di commento possono essere frammezzate e
quindi non contano. Ogni linea di continuazione deve avere spazi dalla
3
1.5. LINEA INIZIALE E DI CONTINUAZIONE

Figura 1.1: La scheda
1.6. NOMI SIMBOLICI
colonna 1 alla colonna 5 e il simbolo di continuazione in colonna 6.

Il simbolo di continuazione può essere qualsiasi carattere FORTRAN
eccetto, chiaramente, lo spazio o lo zero.
1.6
Nomi simbolici
Si può usare un nome simbolico per identificare entità FORTRAN come costanti, variabili, vettori, funzioni e subroutines, blocchi common
e unità di programma. Un nome simbolico è formato da una a 6 lettere o numeri,con la condizione che il primo carattere sia una lettera.
In alcuni casi, come per esempio in UNIX, i nomi possono essere pi`
u
lunghi ma,di conseguenza, non sono trasportabili su tutti i sistemi. La
prima lettera determina il tipo di variabile ma questa regola può essere
ignorata usando una particolare specificazione. Normalmente abbiamo
tipi INTEGER dalla lettera I alla N e REAL negli altri casi e questa
situazione viene solitamente descritta dalla istruzione IMPLICIT.
1.7
Nomi locali e globali
I nomi di tutte le unità di programma, punti di entrata e blocchi COMMON sono nomi globali, cioè comuni a tutto il programma: per questo
motivo devono essere unici. Il nome di costanti, variabili, vettori e funzioni di istruzione sono locali, limitati all unità in uso, e quindi possono
essere adoperati per un altro scopo in un altra parte del programma.
Sovente, però, nome locale e globale devono essere differenti.
1.8
Parole chiave
Una parola chiave è una sequenza di caratteri con un significato predefinito per il compilatore (per esempio istruzioni FORTRAN). Molte
di esse ( ad esempio DATA, IF, CLOSE, ERR ) hanno la forma di un
nome simbolico valido: l interpretazione come parola chiave o come
nome simbolico dipende solo dal contesto. Nel dubbio però è meglio
evitare i nomi delle istruzioni FORTRAN come nomi di variabili per
evitare errori di compilazione o di esecuzione.
5
1.9. ETICHETTE
1.9
Etichette
Un istruzione di etichetta è un numero intero da 0 a 99999, senza segno,

scritto nelle colonne da 1 a 5 della linea di istruzione. L etichetta non
deve essere allineata a destra e caratteri (spazio) e 0 posti davanti sono
ignorati; deve essere unica nel programma e non può essere messa su una
linea di continuazione. Le etichette possono comparire non in ordine
numerico. L istruzione FORMAT deve sempre avere un etichetta;
qualsiasi altra istruzione eseguibile può avere un etichetta, compresa
l istruzione END.
1.10
Tipi di dati e costanti
Qualsiasi costante, variabile, vettore, espressione o funzione deve appartenere a uno di sei tipi di dati: INTEGER, REAL, DOUBLE PRECISION, COMPLEX, LOGICAL O CHARACTER. Il numero di tipi
può aumentare in alcune implementazioni: si ha, ad esempio, doppia
precisione sulle variabili COMPLEX ( vedi UNIX-FORTRAN). Interi,
reali, doppia precisione e complessi sono tipi aritmetici e la conversione
tra di essi è fatta automaticamente in assegnazioni aritmetiche, DATA e
PARAMETER. La conversione invece non è automatica nelle chiamate
interne tipo SUBROUTINE e FUNCTION.
1.11
Unit`
a di memoria
Ogni variabile o elemento di vettore di tipo INTEGER, REAL, DOUBLE PRECISION o LOGICAL occupa un unità di memoria numerica.
Qualsiasi variabile o elemento di vettore in DOUBLE PRECISION o
COMPLEX occupa due unità di memoria numerica. Ogni variabile
oppure elemento di vettore di tipo CHARACTER occupa un unità di
tipo CHARACTER. Il rapporto fra le due unità dipende dalla macchina
usata.
1.12
Tipo INTEGER
In una variabile INTEGER si memorizza un numero intero, che è rappresentato esattamente nella macchina. Il range coperto dipende da
6
1.13. TIPO REAL
macchina a macchina e nel UNIX-FORTRAN abbiamo:

integer 2
integer 4
da
da
32768 a 32768
2147483648 a 2147483648 .
In unità UNIX-FORTRAN una variabile integer*2 occupa 2 bytes mentre quella integer*4 ne occupa 4.
1.13
Tipo REAL
Ogni variabile REAL memorizza un numero in virgola mobile, con o

senza segno. Seppure lo zero e i numeri interi piccoli siano memorizzati
in maniera corretta, i numeri con virgola mobile sono approssimati
con una certa precisione che, seppure piccola, è finita e dipende dalla
macchina. Nel UNIX-FORTRAN i numeri con virgola mobile variano:
real 4
da 0.79E 38 a 1.78E + 38
real 8
da 0.56E 308 a 0.9E + 308
Una costante reale deve contenere un punto ( che rappresenta la

virgola ) o un esponente che specifichi la potenza di 10 applicata alla
variabile, o ambedue. Il segno è un optional da mettersi di fronte al
numero o all esponente. Esempi di costanti espresse in maniera valida:
1. 3.14159
+ 5E3 6.67E 18
Sul UNIX-FORTRAN una variabile real *4 ( precisione singola ) occupa

4 bytes.
1.14
Tipo DOUBLE PRECISION
La DOUBLE PRECISION è simile a quella REAL ma memorizza un

numero in virgola mobile con una precisione maggiore. Anche qu`la
precisione dipende dalla macchina usata. Scriviamo qualche esempio:
1D0 3.141592653589793238462643D0
+ 5D3 6.67D 18
Sul UNIX-FORTRAN una variabile real*8 (o doppia precisione) occupa

8 bytes. Notiamo che l esponente viene preceduto dalla lettera D e deve
sempre essere indicato, anche se nullo.
7
1.15. TIPO COMPLEX
1.15
Tipo COMPLEX
Una variabile COMPLEX consiste in un paio ordinato di numeri reali,

rappresentanti della parte reale e immaginaria di un numero complesso
ed è scritta con due costanti reali o intere separate da una virgola
e contenute tra parentesi, la seconda delle quali rappresenta la parte
immaginaria:
(1, 50) (3.14, 2E3) (.123, +4567)
1.16
Tipo LOGICAL
Una variabile LOGICAL memorizza solo due valori, .true. oppure .f alse.,
ed occupa un byte: è quindi indicata per operazioni che richiedono molti
bytes di memoria.
1.17
Tipo Character
I dati di tipo CHARACTER sono stati introdotti per la memorizzazione e la manipolazione di testi. Ogni variabile CHARACTER può
memorizzare una stringa completa di caratteri, ma la sua occupazione deve essere dichiarata all inizio del programma. In particolare in
UNIX-FORTRAN bisogna specificare il numero di caratteri e quindi di
bytes, per esempio
character 6
character 15
ERRORE 0
T ROP P I ELEM EN T I 0
Le stringhe sono definite da apostrofi () o virgolette (). La costante di

Hollerith del FORTRAN-IV è stata completamente sostituita da questo
tipo di variabili ( per fortuna ! ).
1.18
Vettori
Un vettore è un set ordinato di dati (tutti dello stesso tipo) riferito ad

un singolo nome simbolico. Il numero di dimensioni di un vettore può
arrivare ad un massimo di sette. Nel FORTRAN77 qualsiasi dimensione
può avere un limite inferiore diverso da uno e gli intervalli di variabilità
8
1.19. SOTTOSTRINGA CHARACTER
devono essere dichiarati nelle istruzioni COMMON o DIMENSION.

L elemento individuale viene chiamato specificando il nome simbolico
e un insieme di indici, uno per ogni dimensione.
Qualsiasi indice di un vettore deve avere un valore compreso fra i
due limiti dichiarati in quella dimensione. L indice può essere un intero
complesso quanto si vuole, può includere la chiamata di un altro vettore
oppure chiamate a funzioni intrinseche od esterne. Riportiamo alcuni
esempi:
matrice(0, 12)
hyper(i, j, l, m, n)
dlist(mod(npts, 4))
D(k(N (index)))
1.19
Sottostringa CHARACTER
Una sottostringa specifica un set di caratteri adiacenti dislocati in una

variabile CHARACTER. Una sottostringa consiste nella specificazione dell elemento seguito da due interi separati da : e rinchiusi fra
parentesi. Facciamo un esempio concreto:
CHARACT ER 8 regioni(1 : 23)
regioni(55) =0 P IEM ON T E 0
regioni(55)(2 : 5) =0 IEM O0
1.20
Espressioni
Essendo un linguaggio essenzialmente computazionale, un gran numero di istruzioni FORTRAN impiega espressioni. La valutazione di una
espressione dà come risultato un singolo valore che può essere usato
per definire una variabile, può entrare in una decisione logica, può essere scritto in un file, etc. La forma pi`
u semplice di una espressione
è un valore scalare: una costante o una variabile singola. Espressioni
pi`
u complesse vengono spesso formate con operazioni che coinvolgono
uno o pi`
u operandi. Ci sono quattro tipi di espressioni disponibili in
FORTRAN 77: aritmetiche, CHARACTER, di relazione e logiche.
9
1.21. ESPRESSIONI ARITMETICHE
1.21
Espressioni aritmetiche
Un espressione aritmetica è usata per specificare un calcolo numerico

che deve essere svolto dal calcolatore. Consiste di uno o pi`
u operandi ( interi, reali, doppia precisione oppure complessi ) combinati con
operatori aritmetici. Un espressione può anche contenere una sottoespressione in parentesi e referenze a funzioni standard. Il risultato di
un espressione aritmetica è un valore numerico del tipo specificato.
Elenchiamo le possibili operazioni:
somma(identit`
a)
sottrazione(negazione)
moltiplicazione
divisione
elevazione a potenza
L ordine di valutazione di un espressione è:

1. sottoespressioni in parentesi,
2. funzioni standard,
3. esponente,
4. moltiplicazione o divisioni,
5. addizioni, sottrazioni o negazioni.
In ogni gruppo la valutazione procede da sinistra verso destra eccetto che per gli esponenti che sono valutati da destra a sinistra. Cosicchè
A/B/C è equivalente ad (A/B)/C mentre A**B**C è equivalente ad
A** (B**C). Si possono mescolare tutte le combinazioni dei quattro tipi fondamentali tra di loro eccetto che quelle COMPLEX con quelle di
DOUBLE PRECISION. Se gli operandi di una espressione aritmetica
sono dello stesso tipo il risultato sarà anch esso dello stesso tipo. Se i
tipi sono diversi, viene applicata ad uno di essi un tipo di conversione
implicita. La direzione adoperata sarà:
IN T EGER REAL COM P LEX o DOU BLE P RECISION
10
CAPITOLO 1. IL FORTRAN-77 1.22. ESPRESSIONI COSTANTI INTERE

La sola eccezione a queste regole di conversione è l elevazione a potenza
con esponente intero. Se la potenza è negativa, si valuta l inverso della
potenza positiva:
2 (3)
1/(2.0 3)
1/8.0
0.125
Altrimenti la potenza è calcolata con i logaritmi cosicchè A**B sarà

calcolato con la formula EXP(B * LOG (A)) dove EXP e LOG sono
funzioni standard del compilatore. La divisione fra interi produce un
troncamento della parte frazionale. Esempi:
8/3
1.22
2 ,
2 (3)
1/(2 3)
1/8
Espressioni costanti intere
Le espressioni aritmetiche in cui tutti gli operandi siano costanti o nomi

simbolici, vengono chiamate espressioni aritmetiche costanti. Un espressione costante intera può essere usata per dichiarare i limiti di un vettore
o la lunghezza di una variabile CHARACTER o usata per fissare i valori
di una costante attraverso l istruzione PARAMETER. Per esempio:
P ARAM ET ER (N P T = 50, N T OT AL = N P T 2)
COM P LEX COEF F S (N P T S (N P T S 1))
ARRAY (N T OT AL(2))
1.23
Espressioni CHARACTER
Una espressione CHARACTER produce un risultato di tipo CHARACTER ed è ottenuta usando operatori e operandi di tipo CHARACTER.
Gli operandi di tipo CHARACTER possono essere: un valore scalare,
un elemento di vettore, una sottostringa, una espressione CHARACTER chiusa tra parentesi, il risultato di una funzione CHARACTER.
Esiste un unico operando CHARACTER denotato con // che permette
di concatenare due stringhe. Esempio:
A
ESEM P IO DI
P ROGRAM M A0
11
1.24. ESPRESSIONI DI RELAZIONE

C
0
SU BROU T IN E 0
A//B
ESEM P IO DI P ROGRAM M A0
A//C
ESEM P IO DI SU BROU T IN E 0
Ambedue gli apostrofi sono richiesti .

Il valore della variabile CHARACTER è la stringa di caratteri fra
gli apostrofi. Il suddetto valore non include gli apostrofi, include invece
tutti gli spazi ed eventuali tabs inseriti fra i due apostrofi . Nella
variable CHARACTER il carattere apostrofo è rappresentato da due
apostrofi consecutivi con nessun spazio o carattere fra di loro () . La
lunghezza della variabile CHARACTER è il numero di caratteri fra
gli apostrofi, eccetto che due apostrofi consecutivi rappresentano un
singolo apostrofo . La lunghezza di una variabile CHARACTER deve
essere nel range da 1 a 2000 .
Esempi
I seguenti esempi rappresentano delle variabili CHARACTER valide
ed invalide .
Valide
Cosa hai detto ?
Labbiamo trovato
La risposta media è stata 12:00
Invalide
La formula
1.24
Spiegazione
manca l apostrofo finale
la variabile CHARACTER deve
contenere almeno un carattere
Espressioni di relazione
Un espressione di relazione dà un risultato di tipo logico (vero o falso)

ed è formata da espressioni aritmetiche o CHARACTER e operatori di
relazione. Abbiamo sei tipi di operatori di relazione:
.LT.
.LE.
minore di
minore di o uguale a
12
.EQ.
1.25. ESPRESSIONI LOGICHE

uguale a
.GT.
.GE.
maggiore di
maggiore di o uguale a
.N E.
non uguale a
Le variabili confrontate devono essere omogenee e ovviamente in campo

complesso potremo solamente usare lespressione .eq. o.ne..
Inoltre nei test di uguaglianza su variabili REAL o DOUBLE PRECISION, bisogna tenere conto della precisione adoperata. Il confronto
tra variabili CHARACTER avviene carattere per carattere secondo la
sequenza ASCII. Dato che la lettera A precede la lettera B nel codice
ASCII, A è minore di B. Inoltre le lettere maiuscole hanno valori minori
delle minuscole.
1.25
Espressioni logiche
Un espressione logica consiste di operandi e operatori logici e ritorna

un valore . true./.false .. Essa può essere usata nell espressione IF
o blocco IF. Dato il termine logico lterm possiamo avere le seguenti
espressioni logiche:
(lterm)
(.not. lterm)
(lexp lop lterm)
dove LTERM è la costante logica, variabile oppure elemento di vettore, LEXP un espressione logica e LOP uno degli operatori logici.AND.,.OR.,.EQV., o.NEQV.. Riportiamo l ordine di valutazione
di un espressione di tipo logico:
1. Espressione aritmetica
2. Espressioni di relazione
3. operatore.NOT.
4. operatore.AND.
5. operatore.OR.
13
1.26. STRUTTURA DEL PROGRAMMA
Tabella 1.1: Tabella sugli operatori OR e AND

L1 ed L2 sono espressioni logiche
.OR. e.AND. sono operatori logici
L1
L2
L1.OR.L2 L1.AN D.L2
.true. .true.
.true. .f alse.
.f alse. .true.
.f alse. .f alse.
.true.
.true.
.true.
.f alse.
.true.
.f alse.
.f alse.
.f alse.
6. operatori.EQV. e.NEQV.
L effetto degli operatori.OR. dà come risultato .true. se è vero uno

dei due operandi mentre.AND. dà come risultato.true. se sono verificati
tutti e due, vedi per esempio la seguente tabella:
L operatore.EQV. dà come risultato.true. se entrambi gli operandi hanno lo stesso valore ( cioè entrambi veri oppure entrambi falsi )
mentre il secondo.NEQV. dà il risultato.true. se hanno valore opposto,
come indicato nella tabella che segue:
Attenzione che l operatore.EQV. (che esprime equivalenza ) logica
e.NEQV. (non - equivalenza) non possono essere adoperati nella stessa espressione. Le parentesi vanno sempre utilizzate per semplificare
l ordine di espressioni complicate.
1.26
Struttura del programma
Un programma deve contenere un corpo principale, detto main. Può

poi contenere diverse sottounità che possono essere di tre tipi: SUBROUTINE, FUNCTION e blocco DATA (procedura non eseguibile).
14
1.27. CLASSI DI ISTRUZIONE
Tabella 1.2: Tabella sugli operatori EQV e NEQV

L1 ed L2 sono espressioni logiche
EQV. e.NEQV. sono operatori logici
L1
L2
.true. .true.
.true. .f alse.
.f alse. .true.
.f alse. .f alse.
1.27
L1.EQV.L2 L1.N EQV.L2

.true.
.f alse.
.f alse.
.true.
.f alse.
.true.
.true.
.f alse.
Classi di istruzione
Possiamo chiamare istruzioni tipologiche INTEGER, REAL, DOUBLE

PRECISION,
COMPLEX, LOGICAL e CHARACTER mentre IMPLICIT, PARAMETER, DIMENSION, COMMON, EQUIVALENCE, EXTERNAL,
SAVE sono classificate come istruzioni di specificazione. PROGRAM,
SUBROUTINE, FUNCTION, blocco DATA, FORMAT sono invece
istruzioni di funzione e non sono eseguibili. Le istruzioni di assegnazione ( incluso ASSIGN ), tutte le forme di IF e GO TO, e inoltre ELSE,
ELSEIF, END IF,DO, CONTINUE, CALL, RETURN, READ, WRITE, PRINT, OPEN, CLOSE, INQUIRE, REWIND, BACKSPACE,
END FILE, STOP, PAUSE ed END sono classificate come istruzioni
eseguibili.
1.28
Ordine delle istruzioni
Nella scrittura del codice sorgente devono essere rispettate alcune regole
di priorità con un certo ordine, vedi figura 1.2 .
PROGRAM NOME
Istruzioni di specificazione
........................
Istruzioni eseguibili
.......................
15
1.28. ORDINE DELLE ISTRUZIONI
+-------+--------------------------------------------------------+
|
|
Istruzione OPTIONS
|
|
|--------------------------------------------------------|
|
| Istruzione PROGRAM, FUNCTION, SUBROUTINE,o BLOCCO DATA |
|
|--------+-----------------------------------------------|
|COMMENT|
| Istruzione IMPLICIT NONE
|
| Linee,|
|-------------------------------+--------------|
|INCLUDE|NAMELIST,| Istruzione IMPLICIT
|
|
| Istru-| FORMAT, |------+------------------------|
|
| zioni,|
&
|
| Altre Istruzioni
| ISTRUZIONE |
|& Gen- | ENTRY
| DATA |
di specificazione | PARAMETER
|
| erali | Istru- |Istru-| Istruzione DICTIONARY |
|
|Diret- | zioni | zioni|------------------------+--------------|
| tive |
|
|
Istruzioni Function Definizioni
|
|
|
|
|---------------------------------------|
|
|
|
|
Istruzioni Eseguibili
|
|-------+---------+------+---------------------------------------|
|
Istruzione
END
|
+----------------------------------------------------------------+
Figura 1.2: Le priorità nelle istruzioni
STOP
END
Questo significa, per esempio, che se si usa una istruzione di tipo

IMPLICIT,questa deve precedere tutte le altre eccetto che PARAMETER, inseribile ovunque. Le linee di commento possono essere inserite in ogni punto eccetto che dopo l istruzione END, che deve essere
sempre l ultima del programma. Nella figura che precede le linee verticali separano le istruzioni che possono essere mescolate. Per esempio
l istruzione DATA può essere mescolata con istruzioni eseguibili. Le
linee orizzontali invece separano istruzioni che non possono essere mescolate; per esempio le istruzioni di dichiarazione non possono essere
mescolate con istruzioni eseguibili.
16
1.29
1.29. SEQUENZA DI ESECUZIONE
Sequenza di esecuzione
L esecuzione parte con la prima istruzione eseguibile del programma

main e continua sequenzialmente, soggetta però alle istruzioni di controllo come GO TO, IF, CALL, etc.. L esecuzione finisce con l istruzione END del programma principale o con uno STOP in qualsiasi parte
del programma. Certi errori tipo OVERFLOW possono creare una fine
prematura ma segnalata mentre altri, tipo superamento della memoria
disponibile, provocano una fine non segnalata.
1.30
Unit`
a principale del programma
Il main incomincia con l istruzione PROGRAM e può contenere qualsiasi

altra
istruzione eccetto che: SUBROUTINE, FUNCTION oppure RETURN.
La forma dell istruzione è:
PROGRAM pnome
dove pnome è un nome simbolico. Questa istruzione non è adoperata
in altre parti del programma e quindi ha un significato principalmente
di documentazione.
1.31
Unit`
a di programma FUNCTION
Una funzione ritorna un valore al punto, nell ambito di una espressione, in cui è stata chiamata. Quest unità comincia con l istruzione FUNCTION e può contenere qualsiasi altra istruzione eccetto che
PROGRAM, SUBROUTINE o blocco DATA. Abbiamo due possibiltà
di definizione:
FUNCTION fnome ( a1, a2,.... an )

oppure
tipo FUNCTION fnome (a1, a2,... an )

dove tipo va scelto fra INTEGER, REAL, DOUBLE PRECISION,
COMPLEX, LOGICAL, CHARACTER o CHARACTER * len; fnome
è il nome simbolico della funzione e a1, a2,.... an sono gli argomenti
trasmessi. Si può anche non trasferire alcun argomento ma le parentesi
` meglio evitare che nella FUNCTION
devono ancora essere presenti. E
ci siano operazioni di PRINT/WRITE perchè non funzionerebbero ed
17
1.32. FUNZIONI DI REFERENZA
inoltre bisogna essere estremamente prudenti nel modificare gli argomenti indicati nell istruzione COMMON. Come esempio riportiamo la
funzione MYSIN che calcola il seno del primo argomento con lo sviluppo in serie di Taylor e ritorna il numero dei termini dello sviluppo
necessari ad avere una precisione di 107 .
REAL FUNCTION MYSIN(P1,P2)
REAL P1
DOUBLE PRECISION FACTRL
INTEGER P2
MYSIN = P1
DO 10 P2 = 1,100
DELTA = (-1)**P2 * P1**(2*P2+1) / FACTRL(2*P2+1)
IF (ABS(DELTA).LT. 1E-7) RETURN

10
MYSIN = MYSIN + DELTA
RETURN
END
Bisogna fare attenzione a dichiarare la funzione chiamata nel programma principale; nel nostro caso dovremo mettere
REAL MYSIN
se poi la funzione è inserita in qualche libreria dovremo mettere

EXTERNAL MYSIN
1.32
Funzioni di referenza
Una funzione di referenza può occorrere come operando in qualsiasi

espressione appropriata ed ha la forma del tipo:
fnome ( a1,....., an)

dove fnome è il nome della funzione. Quella pi`
u usate sono le funzioni matematiche che variano fortemente da macchina a macchina. Riportiamo l esempio dei numeri random fra 0 ed 1 in UNIX-FORTRAN:
X = RAN (IGEN)
dove IGEN deve essere un intero grande meglio se dispari. Le funzioni intrinsiche non vanno dichiarate perchè sono inserite nel compilatore.
Per maggiori dettagli vedere l appendice A sulle funzioni intrinsiche.
18
1.33
1.33. FUNZIONI ISTRUZIONE
Funzioni istruzione
Una istruzione di funzione può essere usata per specificare una relazione
semplice ed è usata in una sola unità. Ovviamente essa deve precedere
` definita tramite una via simile alle
qualsiasi istruzione di esecuzione. E
istruzioni di assegnazione:
fnome (a1,...,an) = exp

dove fnome è il nome simbolico della funzione ed è seguito dagli
argomenti fittizi, exp è una espressione che viene valutata utilizzando
gli argomenti fittizi. Questi ultimi sono locali e possono essere usati
indipendentemente nel resto del programma. Esempi:
LOGICAL DIGIT
CHARACTER CHAR
DIGIT (CHAR ) = CHAR.GE.0.AND.CHAR.LE.9
VAB (X,Y,Z) = SQRT (XX**2 +Y**2 +Z**2)
1.34
Funzioni intrinseche
Il FORTRAN contiene una quantità considerevole di funzioni incorporate, note come funzioni intrinseche, che vengono automaticamente
messe a disposizione in qualsiasi parte del programma esse vengano
chiamate. La maggior parte di queste funzioni ha un nome generico
che elimina la necessità di cambiare nome in base al tipo di parametro
usato. Su varie macchine troviamo poi funzioni intrinseche diverse a
seconda del tipo di variabile utilizzata. Visto il loro numero notevole
rimandiamo il lettore all appendice A per una lista aggiornata.
1.35
Sottoprogrammi SUBROUTINE
Una subroutine è una procedura separata, definita come esterna rispetto all unità di programma che la chiama ed è specificata in una unità
sottoprogramma. L istruzione SUBROUTINE seguita o meno dagli
argomenti è l istruzione iniziale e in seguito si possono inserire tutte
le istruzioni eccetto che PROGRAM, FUNCTION o blocco DATA. La
forma può essere:
SUBROUTINE snome (a1,....,an)

oppure
SUBROUTINE snome
19
1.36. ISTRUZIONE CALL
dove snome è il nome simbolico della subroutine e a1,....., an sono

gli argomenti di entrata / uscita. La SUBROUTINE viene chiamata
con l istruzione CALL e ovviamente al suo interno non può chiamare
sè stessa direttamente o indirettamente. Le informazioni si possono
trasferire al di fuori della subroutine mediante i suoi argomenti, i blocchi
COMMON oppure file esterni. Si ritorna al main mediante l istruzione
END oppure RETURN.
1.36
Istruzione CALL
Questa istruzione è usata per eseguire una procedura specificata da una

subroutine. Le forme sono del tipo:
CALL SUBROUTINE snome (a1,....,an)

oppure
CALL SUBROUTINE snome
1.37
Argomenti della subroutine
Normalmente l istruzione iniziale SUBROUTINE contiene una lista

di parametri formali chiusi fra parentesi. La chiamata CALL ad una
subroutine contiene una lista di parametri attuali che devono concordare esattamente in numero e tipo con i parametri formali. Durante
l esecuzione di un istruzione CALL, le locazioni di memoria dei parametri attuali vengono passate alla subroutine in modo tale da permettere ai parametri formali di riferirsi alle stesse locazioni di memoria dei
parametri attuali. Questi ultimi possono essere costituiti da:
1. una costante
2. un nome di variabile
3. il nome di un elemento di un vettore o del vettore stesso
4. una sottostringa di caratteri
5. un espressione
6. il nome una funzione intrinseca
7. il nome di una procedura esterna ( subroutine o funzione )
20
1.38. DIMENSIONE TRAMITE PARAMETER
8. il nome di una procedura formale
9. uno specificatore di ritorno alternativo ( vedi sotto )
I parametri formali possono essere invece costituiti da:
a) il nome di una variabile ( per i tipi 1 - 5 )
b) il nome di un vettore ( per il tipo 3 )
c) il nome di una procedura formale ( per i tipi 7 e 9 )
d) un asterisco ( per il tipo 10 )
Se il parametro formale è una variabile di tipo CHARACTER, deve
essere naturalmente dichiarato come tale e gli deve essere attribuita
una certa lunghezza che deve essere inferiore o uguale alla lunghezza
del parametro attuale; se è inferiore, verranno trattati come parametro
formale solo i lun ( lun = lunghezza dichiarata nella SUBROUTINE
) caratteri pi`
u a sinistra del parametro attuale. Particolare attenzione
va posta alle dimensioni dei vettori e possiamo avere tre tipi diversi di
configurazioni:
1.38
Dimensione tramite PARAMETER
SUBROUTINE LAVORO (VEC,N)
DIMENSION VEC (1:N)

dove VEC è il vettore di dimensione da uno ad N e N è definito nel
main tramite l istruzione PARAMETER.
1.39
Dimensione tramite numeri
SUBROUTINE LAVORO (VEC)
DIMENSION VEC (1:1000)

dove VEC è il vettore di dimensione da uno ad a 1000 e nel MAIN è
definito nella stessa maniera.
21
1.40. DIMENSIONE TRAMITE *
1.40
Dimensione tramite *
SUBROUTINE LAVORO (A,B,C)
DIMENSION A (1:*),B(0:*),C(-4:*)
Questo tipo di dichiarazione è detto dichiarazione di vettore a dimensioni presunte, in quanto si suppone che il vettore sia abbastanza grande
per tutti i riferimenti ad esso fatti nel corso del programma e non ha
dimensioni definite. Se invece abbiamo l istruzione in blocchi COMMON abbiamo un associazione fra elementi corrispondenti; si abbia ad
esempio
SUBROUTINE SUB ( X,Y,Z)
COMMON C
e nell unità principale si abbiano le istruzioni seguenti:
COMMON S
CALL SUB (X1,Y1,Z1 )

Cosicchè sia X,Y,Z sono associati con X1, Y1, Z1 mentre C è associata con S.
1.41
Istruzione RETURN
Questa istruzione fa terminare l esecuzione di una SUBROUTINE o

di una FUNCTION e restituisce il controllo all unità di chiamata. La
forma normale è:
RETURN
Può anche essere chiamata all interno di un if /end if.
1.42
Istruzione ENTRY
Qualche volta può essere utile combinare due o pi`

u subroutines o funzioni in una sola per potere trarre vantaggio da una grossa porzione di
codice in comune. Essa assume la forma del tipo:
ENTRY enome (a1,....,an)

dove enome è il nome di entrata seguito dai relativi argomenti, il
cui numero deve essere uguale al numero di argomenti nella subroutine
o funzione corrispondente. L uso di punti alternativi di ingresso è in
conflitto con i principi di programmazione modulare ma può risultare
conveniente in alcuni casi particolari. Bisogna evitare comunque che
l istruzione ENTRY compaia in una qualsiasi struttura a blocchi
22
1.43
1.43. ISTRUZIONI DI SPECIFICAZIONE
Istruzioni di specificazione
Le istruzioni di specificazione sono usate per definire le proprietà di

entità simboliche, costanti, variabili, vettori, etc., usate in una unità di
programma. Per questo motivo vengono anche chiamate istruzioni di
dichiarazione e sono raggruppate nella sezione iniziale del codice sorgente, dopo l istruzione PROGRAM e prima di tutte le altre. Ricordiamo
che non sono istruzioni eseguibili. In questo capitolo si esamineranno anche le istruzioni DATA, utilizzate per stabilire i valori iniziali di
variabili e vettori presenti in un programma FORTRAN.
1.44
Istruzione IMPLICIT
Il tipo di dati delle variabili o vettori usati nel programma può essere
stabilito tramite un istruzione tipologica. La regola standard è che
i nomi simbolici con la lettera iniziale da I ad N specificano variabili
intere mentre gli altri sono reali. Con l istruzione IMPLICIT si può
modificare questa situazione. Questo può essere utile per poter utilizzare allo stesso tempo variabili in precisione semplice e in doppia nelle
stesse unità. Se usiamo il tipo CHARACTER deve essere specificata
anche la lunghezza con un *len. Esempi:
IMPLICIT REAL *4 (A-H,O-Z)
oppure
oppure
IMPLICIT REAL *4 (C-H,O-Z)
IMPLICIT REAL *8 (A)
IMPLICIT CHARACTER * 80 ( B)
In questo ultimo esempio tutte le variabili saranno in semplice precisione eccetto che quelle inizianti con A ( precisione doppia ) e B (
variabile CHARACTER di lunghezza 80 ).
1.45
Istruzione PARAMETER
Con questa istruzione si assegna un nome logico ad una costante, che

può essere un numero oppure un espressione contenente altre costanti. Si possono trasportare le variabili cos` definite in altre unità senza
23
1.46. DICHIARAZIONI DEI VETTORI
modificarle: il compilatore segnalerebbe in questo caso qualcosa di anomalo. Il tipo di costante o espressione deve chiaramente essere lo stesso
del nome simbolico. Se il nome di un parametro CHARACTER ha
la lunghezza specificata con un *(*), vale la lunghezza dichiarata in
PARAMETER. Esempio:
PARAMETER (LOGN=8, NPT = 2** LOGN)
DIMENSION INDEX (1:LOGN), X(0:NPT)
CHARACTER *(*) TITLE
PARAMETER ( TITLE =Tabella dei risultati)
PARAMETER ( PI = 3.14159,PI2 = 2*PI )

Esse risultano molto utili per dimensionare i vettori.
1.46
Dichiarazioni dei vettori
Il nome di un vettore può comparire in pi`

u di una istruzione di specificazione ma la sua dimensione deve essere dichiarata solo una volta.
Questo può essere fatto in una istruzione tipologica, in un COMMON
oppure in un DIMENSION. I vettori possono avere fino a sette dimensioni, per ognuna delle quali si deve specificare un limite inferiore e
superiore. Se non è specificato diversamente, il limite inferiore è uno.
Esempi:
PARAMETER (NPUNTI = 1000 )
REAL 8 4 (NPUNTI),Y(-5:5,0:NPUNTI -1),DUE(2,2,2,2)
LOGICAL * 1 CUBO
DIMENSION CUBO (1:NPUNTI,1:NPUNTI,1:NPUNTI)

Se invece il vettore si trova in una subroutine abbiamo due possibilità: dimensione regolabile oppure fissa. Nel primo caso le dimensioni
sono regolate dalla lista degli argomenti della subroutine oppure tramite
il blocco COMMON:
SUBROUTINE CALCOLA (X,NX,Y,NY, R,F)
COMMON NR,NF
DIMENSION X (1:NX),Y(1:NY),F(0:NF),R(0:NR)
Se invece vogliamo usare un vettore di dimensione fissa possiamo
introdurre un * che rappresenta una dimensione indefinita. Esempio:
FUNCTION ESPANDE (XX,YY)
IMPLICIT REAL *8 XX, YY
DIMENSION XX (*),YY(0:*)
24
1.47
1.47. ISTRUZIONI TIPOLOGICHE
Istruzioni tipologiche
Queste sono usate per alterare ( o confermare ) il tipo di dati associati

con un nome simbolico. Possono anche essere usate per specificare le
dimensioni dei vettori. Una volta associato un tipo ad un nome simbolico, questo rimane invariato all interno dell unità di programma
in cui è stato definito. Possiamo avere tipi LOGICAL, CHARACTER
e aritmetici. Usando l istruzione CHARACTER bisogna ovviamente sempre specificare la lunghezza. Nel caso dell argomento fittizio
di una SUBROUTINE possiamo mettere un *(*) che rappresenta una
lunghezza e dimensione variabili. Esempio:
DOUBLE PRECISION X, FUNZ, Z(100)
CHARACTER * 30 NOME, INDIRIZZI (5)*20
LOGICAL * 1 CUBO (1:100,1:100)
1.48
Istruzione DIMENSION
` usata per dare un nome simbolico e specificare la dimensione di un

E
vettore. Il tipo di dati è implicito nel nome usato. La forma è del tipo:
DIMENSION A1(D1),A2(D2).....
dove ogni An è un vettore e Dn specifica la dimensione; a sua volta
Dn può essere scomposto in limite superiore e inferiore.
1.49
Istruzione COMMON
Le istruzioni COMMON sono usate per dichiarare blocchi di variabili

in comune con due o pi`
u unità del programma, secondo un ordine di
memorizzazione consistente. Questo è possibile attraverso una struttura di dati FORTRAN chiamata blocco COMMON, che costituisce un
blocco di memoria contiguo e assume la forma:
COMMON /NOME/ nlist

dove nome è il nome globale del blocco e nlist è la lista dei nomi
delle variabili, dei vettori e dei dichiaratori di vettori locali. Si nota
che un blocco COMMON non possiede un tipo. Una volta stabilito
l ordine di memorizzazione in un blocco COMMON, qualsiasi unità di
programma che dichiari lo stesso blocco COMMON, può riferirsi ai dati
ivi memorizzati senza dover passare nomi simbolici attraverso liste di
argomenti. L istruzione COMMON è un istruzione di specificazione e
25
1.50. ISTRUZIONE EQUIVALENCE
deve venire quindi dopo tutte le istruzioni IMPLICIT e precedere tutte

quelle DATA. Esempio:
INTEGER *2 ETA (1:50)
REAL *4 LIVELLO (1:50,1:6)
COMMON /ESAM/NUM,LIVELLO,ETA
In questo caso nel blocco COMMON /ESAM/ abbiamo 1 + 300 +
50 = 351 unità.
1.50
Istruzione EQUIVALENCE
L istruzione EQUIVALENCE fornisce un mezzo affinchè due o pi`

u
variabili possano occupare la stessa dislocazione in memoria. Assume
la forma:
EQUIVALENCE (nlista1),(nlista2)
Questo significa che la memorizzazione per tutti gli elementi della lista avviene con la stessa locazione di partenza. Gli elementi in
questione possono essere di tipo e lunghezza differente. Facciamo un
esempio:
REAL *4 R(2), RL,IM
COMPLEX *8 C
EQUIVALENCE ( R,RL,C),(R(2),IM)
Questo significa che R(1) e RL occupano la stessa dislocazione della
parte reale di C mentre R(2) ed IM occupano la parte immaginaria di
C. Le istruzioni COMMON ed EQUIVALENCE sono di difficile comprensione e diventano veramente utili in sistemi composti da molte
subroutines tipo pacchetti grafici o matematici.
1.51
Istruzione EXTERNAL
L istruzione EXTERNAL permette che nomi simbolici possano essere

usati come argomenti in istruzioni CALL e in chiamate a funzioni, senza
che il compilatore crei automaticamente una variabile nel momento
della referenza. In pratica specifica che un nome è un simbolo globale
definito fuori dell unità del programma. Si presentano due casi:
a) identificare sottoprogrammi o punti ENTRY passati come argomenti,
26
1.52. ISTRUZIONE INTRINSIC
b) identificare un blocco DATA nel momento del link del programma.
1.52
Istruzione INTRINSIC
Questa istruzione indica che un certo nome simbolico è una funzione

intrinseca e può essere passata come argomento in istruzioni CALL
e chiamate a funzioni. Il nome della funzione intrinseca specificato
mantiene il tipo di variabile associato. Riportiamo un esempio sull uso
di INTRINSIC/EXTERNAL:
INTRINSIC SINH,COSH
nna7 EXTERNAL MYFUNC
CALL GRAPH (SINH)
CALL GRAPH (MYFUNC)
END
SUBROUTINE GRAPH (FUNC)
EXTERNAL FUNC
CALL PLOT (FUNC,0.0, 3.14)
END
1.53
Istruzione SAVE
Il FORTRAN permette l allocazione in memoria sia dinamica che statica. Le variabili, i vettori e i blocchi COMMON dichiarati nell unità
MAIN, sono allocati staticamente e mantengono sempre la loro definizione. Le variabili, i vettori e i blocchi COMMON dichiarati solo in
sottoprogrammi vengono allocati dinamicamente al momento dell esecuzione del sottoprogramma. Quando questo esegue l istruzione RETURN o END, sono deallocati e perdono la loro definizione(e chiaramente il loro valore!). L istruzione SAVE permette di mantenere la definizione di queste variabili e di salvare il loro contenuto, specificandole
in due diversi modi:
SAVE nome1,nome2
SAVE
Nel primo sono salvati nome1 e nome2, mentre nel secondo tutti
gli argomenti della sottunità. IN UNIX-FORTRAN questo avviene già
anche senza l istruzione SAVE.
27
1.54. ISTRUZIONE DATA
1.54
Istruzione DATA
Questa istruzione è adoperata per definire i valori iniziali delle variabili

e dei vettori. Strettamente parlando non è un istruzione di specificazione, segue tutte le istruzioni di dichiarazione e prende effetto solamente
quando il programma è inserito nella memoria. La forma è del tipo:
DATA nlista/clista/nlista/clista/
dove ogni nlista è una lista di variabili, vettori, elementi di vettori,
sottostringhe oppure liste di DO implicite; ogni clista è una lista di
costanti che forniscono il valore iniziale. Le virgole separanti il simbolo
/ e nlista sono degli optional.
I nomi di argomenti fittizi o funzioni non possono essere adoperati
in codesta istruzione. Riportiamo alcuni esempi:
PARAMETER (NX=64,NY=80,NTOTAL=NX*NY)
REAL*4 ALLSET (NX,NY)
DATA ALLSET /NTOTAL * 0.0 /
CHARACTER * 8 A,B
DATA A,B,C/VOGLIAMO/TRONCARE/
1.55
Istruzioni di assegnazione
Le istruzioni di assegnazione sono usate per assegnare un valore, usualmente quello di un espressione, ad una variabile o ad un elemento di
vettore. Possono anche essere utilizzate per modificare i contenuti di
locazioni di memoria assoluta.
1.56
Assegnazioni aritmetiche
Le istruzioni di assegnazione aritmetica sono usate per assegnare un

valore a variabili aritmetiche. Assumono la forma:
v = espr
dove v è una variabile o elemento di vettore di un certo tipo aritmetico
ed espr è un espressione aritmetica. Se il tipo di espr è diverso da
quello di v, allora il valore di espr viene convertito al tipo di v prima
della memorizzazione: questo potrebbe causare dei troncamenti.
28
1.57
1.57. ASSEGNAZIONI LOGICHE
Assegnazioni logiche
Le istruzioni di assegnazione logica assegnano un valore ad una variabile

logica ed operano nello stesso modo delle assegnazioni aritmetiche:
v = espr
dove v è una variabile o elemento di vettore di tipo logico ed espr è
un espressione logica o anche di tipo aritmetico. Questa ultima può
contenere espressioni relazionali o espressioni di tipo CHARACTER.
Se il tipo di espr non è logico, il valore assegnato a v è. false., se il
valore di espr è zero, mentre è. true. se il valore di espr è diverso da
zero. Esempio:
LOGICAL LIMITE (1:10)
REAL*4 R(1:100)
LIMITE(J)=R(J).GE.RMIN.AND.R(J).LE.RMAX
1.58
Assegnazioni CHARACTER
Ha la forma del tipo:

v = espr
dove v è una variabile o elemento di vettore o ancora sottostringa di
tipo CHARACTER ed espr è un espressione CHARACTER. Se la
lunghezza di v è maggiore di espr vengono aggiunti degli spazi alla
destra di espr fino a raggiungere la lunghezza di v; se v è minore di espr
i caratteri in eccesso sulla destra sono rimossi.
1.59
Istruzione ASSIGN
Questa istruzione è usata per assegnare l indirizzo di un istruzione

etichettata ad una variabile intera. La forma è del tipo:
ASSIGN S TO V
dove S è un etichetta di un istruzione eseguibile o un istruzione
FORMAT presente nella stessa unità e V è una variabile intera. La
variabile V può essere poi adoperata nello stesso programma sia in
un istruzione GO TO sia come identificatore di FORMAT in un istruzione READ/ WRITE /PRINT. La variabile non può ovviamente essere richiamata in altre espressioni aritmetiche a meno che non sia
riassegnata con un valore intero. Esempio:
29
1.60. ISTRUZIONI DI CONTROLLO
DIMENSION ARRAY (1:10)

101 FORMAT (10F10.4)
ASSIGN 101 TO MYFORM
WRITE ( LP, MYFORM) ARRAY
1.60
Istruzioni di controllo
Le istruzioni di controllo vengono utilizzate, in FORTRAN, per dirigere il flusso dell elaborazione: sono inclusi in questo tipo di istruzione
costrutti per il loop, diramazioni condizionate e incondizionate, strutture decisionali a scelta multipla e possibilità di pausa o interruzione
dell esecuzione di un programma. I trasferimenti di controllo in una
unità del programma si effettuano principalmente con l uso di istruzioni GO TO e IF e, inoltre, con l uso sporadico di END ed ERR in
istruzioni di input/output.
1.61
Istruzione GO TO incondizionata
Questa istruzione produce un trasferimento incondizionato del flusso su

un altra istruzione etichettata:
GO TO S
dove S è un etichetta di un istruzione eseguibile presente nella stessa
unità.
1.62
Istruzione GO TO calcolata
Questa istruzione trasferisce il controllo ad una istruzione scelta da una

lista secondo una condizione specifica. La forma è del tipo:
GO TO(s1,s2,....sn) espr
dove ogni sn è un etichetta di un istruzione eseguibile presente nella
stessa unità ed espr è un istruzione di tipo intero utilizzata per selezionare,tra le sn, l istruzione cui trasferire il controllo. La virgola prima
di espr è un optional. La scelta viene effettuata nel modo seguente: se
il valore di espr è 1, il controllo viene trasferito ad s1, se espr ha valore
2, il controllo viene trasferito ad s2, e cos` via. Se il valore di espr è
minore di 1 o maggiore del numero di etichette nella lista, non viene
30
CAPITOLO 1. IL FORTRAN-77 1.63. ISTRUZIONE GO TO ASSEGNATA

effettuato alcun trasferimento. La stessa etichetta può comparire pi`
u
di una volta nella stessa lista. Esempio:
GO TO(100,200,300,...100) MOD(KCONTA,5)+1
1.63
Istruzione GO TO assegnata
` un istruzione obsoleta ma mantenuta per compatibilità con il FORE

TRAN IV. Trasferisce il controllo ad una istruzione che ha un etichetta
assegnata ad un intero tramite un ASSIGN. Ha la forma:
GO TO V
dove V è la variabile intera cui è stato assegnato l indirizzo di una
istruzione eseguibile etichettata.
1.64
Blocco IF
Un blocco IF permette di eseguire le istruzioni in maniera condizionale.

La forma è del tipo:
IF (LEXP1) THEN
BLOCCO1
ELSEIF (LEXP2) THEN
BLOCCO2
ELSE
BLOCCO3
END IF
dove ogni LEXP è un espressione logica e ogni blocco contiene istruzioni eseguibili (eccetto l END), compresi altri blocchi IF. Ogni blocco
di istruzioni che segue un IF / ELSEIF è eseguito solo se la corrispondente espressione logica ha il valore .true.; il blocco ELSE è eseguito
solo se tutte le precedenti espressioni logiche sono risultate false. Dopo
l esecuzione delle istruzioni contenute in un blocco, il controllo viene
trasferito all istruzione immediatamente seguente l ENDIF. Le istruzioni ELSE ed ELSE IF possono essere omesse: l ultima in particolare
può essere ripetuta quante volte si vuole.
Per ogni istruzione IF-THEN deve essere sempre presente l END
IF. Ricordiamo che non è possibile passare dal blocco in un altra parte
dell unità.
31
1.65. ISTRUZIONE IF LOGICA
1.65
Istruzione IF logica
L istruzione logica IF permette che una singola istruzione sia eseguibile

in maniera condizionale. L istruzione assume la forma:
IF (LEXP) ISTRUZ
dove LEXP è un espressione logica ed ISTRUZ è un istruzione
eseguibile,escluso DO, IF-THEN, ELSE IF, ELSE, END IF, END o un
altro IF logico. L istruzione ISTRUZ è eseguita solo se l espressione
logica LEXP ha il valore.TRUE.. Esempio:
IF (X.GT.0.5 ) CALL MODIFICA (X)
1.66
Istruzione IF aritmetica
Quest istruzione è obsoleta e viene mantenuta solo per compatibilità

con
il
FORTRAN-IV. La sua forma è del tipo:
IF (ESPR)s1,s2,s3
dove ESPR è un espressione INTEGER, REAL o DOUBLE PRECISION, e ogni s è un etichetta relativa ad una istruzione eseguibile.
Il flusso è trasferito ad s1, s2, s3 a seconda che il valore di ESPR sia
negativo, zero o positivo.
1.67
Istruzione DO
L istruzione DO è usata per definire un DO-LOOP. Questo loop può

contenere un numero a piacere di istruzioni eseguibili ( eccetto l END )
che vengono eseguite ripetutamente con una sequenza regolare di valori
di una variabile chiamata variabile del do. La forma dell istruzione è
del tipo:
DO s, v=e1,e2,e3
oppure
DO s, v=e1,e2, e
dove s è l etichetta di un istruzione eseguibile, v è la variabile
del DO di tipo INTEGER, REAL o DOUBLE PRECISION e ogni e
è un espressione di tipo intero, reale o doppia precisione, indicanti,
rispettivamente, il valore iniziale, il valore finale e l incremento di v.
La virgola dopo l etichetta è un optional ma è raccomandato contro
gli errori. Esempio:
32
1.68. ISTRUZIONE DO-WHILE
DO 55, N= -100, MAX (LIMIT, 100),2
blocco istruzioni
55
continue
Il DO-LOOP consiste nel blocco di istruzioni eseguibili dall istruzione DO a quella con etichetta s inclusa. Il LOOP può contenere
istruzioni CALL, funzioni di referenza e blocchi IF/ END IF come al` necessario però che ogni struttura, sia blocco IF che
tri blocchi DO. E
DO-LOOP, venga interamente contenuta nel range del DO-LOOP pi`
u
esterno. In alcune implementazioni, tipo UNIX-FORTRAN o MICROSOFT, è stata soppressa l etichetta del DO e abbiamo semplicemente:
DO v=e1, e2, e3
blocco istruzioni
END DO
L esecuzione di un DO-LOOP procede nel modo seguente:
1. viene valutato e1 (valore iniziale) ed assegnato alla variabile v del
loop, con appropriata conversione di tipo, se necessaria.
2. vengono valutate le espressioni e2 ed e3 ( rispettivamente valore limite ed incremento o passo ). Se e3 è stato omesso, viene
considerato il valore di default 1.
3. Viene calcolato il numero di iterazioni con la seguente espressione:
MAX ( INT (( e2 - e1 + e3 )/e3 ), 0 ). Si ottiene quindi il numero
di volte che il blocco di istruzioni nel loop verrà eseguito.
4. se questo numero di istruzioni è nullo, il controllo dell esecuzione viene trasferito alla prima istruzione che segue l END DO o
l etichetta del loop.
5. se il numero di iterazioni è maggiore di zero, vengono eseguite le
istruzioni del blocco.
6. la variabile del loop viene incrementata di e3, il numero di iterazioni è decrementato di uno e si riprende dal passo 4.
1.68
Istruzione DO-WHILE
Questa è un istruzione che esiste solo sul UNIX-FORTRAN o MICROSOFT e fornisce un metodo per il loop non necessariamente controllato
33
1.69. ISTRUZIONE CONTINUE
da un conto di iterazioni. In pratica si esegue un blocco di istruzioni

fino a che il valore dell espressione logica è falsa. In ogni passo del
LOOP viene controllata la variabile logica; se è vera (.true. ) vengono
eseguite le espressioni del LOOP, se è falsa (.false. ) il controllo viene
trasferito all istruzione dopo il LOOP. La forma dell istruzione è la
seguente:
[ DO s ] WHILE expr
dove s è l istruzione etichettata eseguibile che definisce il range del loop: può essere anche una istruzione REPEAT o END DO.
L espressione expr è un test di tipo logico. Il seguente esempio è tratto
dalla teoria dei frattali e costituisce il loop principale dell insieme di
Mandelbrot:
IM = 0
DO I= 0,NPIX1
CY=YMIN + I*DELTA/NPIX
DO J=0,NPIX1
CX=XMIN+J*DELTA/NPIX
COMPLEX = CX + IMM*CY
C DIMENSIONE NUMERO COMPLESSO
Z=0
NDIM = 0
DO WHILE (CABS(Z).LE. 2.0.AND. NDIM .LT.ITER)
Z=Z*Z+COMPLEX
NDIM=NDIM+1
END DO
IM = IM +1
MATRIX (IM) = NDIM
END DO
END DO
1.69
Istruzione CONTINUE
L istruzione CONTINUE fornisce un punto di riferimento e, pratica` usato princimente, traferisce il controllo all istruzione seguente. E
palmente come fine del vecchio DO LOOP, ma può comparire ovunque
nell unità di programma. Esempi:
GO TO 400
...........
34
1.70. ISTRUZIONE STOP
400 CONTINUE
DO 600 J=1,300
..................
600 CONTINUE
1.70
Istruzione STOP
Questa istruzione termina l esecuzione del programma e produce un

ritorno al sistema operativo usato. Si presentano due casi:
STOP
oppure
STOP [disp]
dove [disp] rappresenta una variabile CHARACTER oppure un numero non pi`
u grande di 5 cifre. Questa variabile può essere un messaggio
da visualizzare o un numero di riferimento per errori di esecuzione del
programma. Esempio:
STOP Ci sono troppi elementi
1.71
Istruzione PAUSE
L istruzione PAUSE è simile all istruzione dello STOP con la differenza

che la sospensione dell esecuzione è solo temporanea. L esecuzione
riprende con una istruzione del sistema operativo che nel caso del VMS
è $ CONTINUE. Si sconsiglia l uso di questa istruzione quando i sistemi
devono essere trasportabili. La forma è del tipo
PAUSE [s]
dove s è una stringa di caratteri o un numero fino a 5 cifre, inviata
su uno schermo come messaggio per l utente.
1.72
Istruzioni di INPUT/OUTPUT
Le istruzioni di Input/Output forniscono un canale di comunicazione

tra il programma FORTRAN e il mondo esterno. Ci sono tre gruppi
di istruzioni di input/output. Nel primo gruppo si trovano le istruzioni
READ, WRITE, PRINT che attuano il trasferimento dei dati fra unità;
fanno parte del secondo gruppo BACKSPACE, ENDFILE e REWIND
35
1.73. NOZIONI GENERALI
che compiono operazioni ausiliarie. Tutte queste istruzioni fanno riferimento ad unità logiche intere che si riferiscono a file ed apparati esterni
( lettori di nastri / stampanti / dischetti / terminali ). Nel terzo gruppo
troviamo OPEN, CLOSE e INQUIRE che correlano le unità logiche di
uscita o ingresso con il nome dei file.
1.73
Nozioni generali
In questo paragrafo verranno spiegati in generale i concetti che riguardano record e file per una migliore comprensione delle istruzioni di
Input / Output.
1.74
Record
Tutti gli I/O del FORTRAN hanno luogo tramite una struttura chiamata RECORD. Un record può essere un singolo carattere, una sequenza
di caratteri o di valori; può essere una linea di testo, le coordinate per
il pennino di un plotter, i dati letti da uno scanner o ( fino a circa 10
anni fa ) una scheda perforata.
Il FORTRAN usa tre tipi di record: formattato, non formattato
e di fine file ( endfile ). Un record formattato è costituito da una
sequenza di caratteri ASCII, terminata o meno con un carriage return
, un avanzamento di linea o entrambi. Ogni singola riga di testo di
questo manuale, per esempio, è un record formattato. La lunghezza
minima per un record formattato è zero e la massima è 1024. Un
record non formattato è una sequenza di valori e la sua interpretazione
dipende dal tipo di dati. Per esempio il binario 01010111 può essere
interpretato come valore intero 87 o valore carattere W a seconda del
tipo di dato. La lunghezza minima di un record non formattato è zero
e la massima è 1024, eccetto per i record ad accesso sequenziale ( vedi
oltre ) non contenenti informazioni sulla lunghezza del record, che può
quindi essere illimitata. Il record di endfile è l ultimo record di un file
e non ha lunghezza.
36
1.75
1.75. FILE
File
Un file è composto da record, può essere creato ed è accessibile anche

con mezzi diversi dai programmi in linguaggio FORTRAN. Per esempio
si può creare e modificare un file di testo con un editor e manipolarne
le informazioni con un programma in FORTRAN. I file contenuti in
nastri e dischi sono generalmenti detti esterni; i file memorizzati nella
memoria principale sono chiamati file interni. La posizione all interno
di un file si riferisce al prossimo record che sarà letto o scritto. Quando
si accede ad un file ( lo si apre ) si è posizionati prima del primo record
e la fine del file è subito dopo il record di endfile. Alcune istruzioni di
I/O permettono di cambiare la posizione corrente in un file.
1.76
Accesso ai file
Il metodo usato per trasferire record a o da file è chiamato modalità di

accesso. L accesso ai file avviene attraverso il loro nome. I file esterni
possono contenere sia record formattati che non formattati. Quando un
record in un file può essere letto o scritto in modo arbitrario, casuale,
la modalità di accesso è detta DIRETTA. Si accede ai singoli record
attraverso un numero di record, che è un intero positivo. Tutti i record
in un file ad accesso diretto hanno la stessa lunghezza e contengono solo
i dati attualmente scritti su di essi; non ci sono caratteri di fine record.
I record possono essere riscritti ma non cancellati. Generalmente solo
i file su disco possono usare la modalità di accesso diretto per il trasferimento dei record. Quando i record vengono trasferiti in ordine, uno
dopo l altro, la modalità di accesso è detto SEQUENZIALE. I record
in un file ad accesso sequenziale possono essere di diversa lunghezza.
Alcuni file, come terminali, stampanti e lettori di nastri, possono usare
solo questa modalità di accesso. I file ad accesso sequenziale formattato
contengono solitamente informazioni di tipo testo e ogni record ha un
carattere di fine record. L accesso sequenziale non formattato è generalmente utilizzato per due motivi che possono sembrare contrastanti:
1) per il controllo di plotters, terminali grafici, stampanti, etc. e per
procedere su informazioni binarie non codificate come i file.OBJ. In
questo caso è importante che i dati trasferiti da e al mezzo esterno siano un flusso di bytes senza informazioni sulla lunghezza del record. 2)
per la comprensione dei dati e la velocità di accesso che caratterizzano
37
1.77. FILE INTERNI
questa modalità. In questo caso deve poter essere possibile determinare

la lunghezza del record per letture parziali.
1.77
File interni
I file interni possono contenere variabili CHARACTER, elementi di

vettore di tipo CHARACTER e sottostringhe CHARACTER. Un file interno che contenga una variabile, un elemento di vettore o una
sottostringa, tutti di tipo CHARACTER, ha un solo record, la cui lunghezza è quella dell entità CHARACTER considerata. Un file interno
che contenga un vettore di tipo CHARACTER, ha tanti record quanti
sono gli elementi del vettore, la cui lunghezza è uguale a quella degli
elementi stessi. I dati di questi file possono essere trasferiti solo con
la modalità di accesso sequenziale formattato. Solitamente questi file
vengono utilizzati per la conversione del tipo di variabili da numerico
a CHARACTER.
1.78
Istruzione OPEN
Questa istruzione è adoperata per connettere un unità logica ad un file

e specificare le sue caratteristiche. Può aprire un file esistente oppure
crearne uno nuovo. Assume la forma del tipo
OPEN ( olista )
dove OLISTA è una lista di argomenti ognuno separato da una
virgola:
UNIT= u Specifica il numero dell unità. I numeri 5, 6, (*)
indicano lo standard input ( tastiera ) e lo standard output (schermo ).
STATUS = cexpr Dove cexpr è un espressione CHARACTER
che assume il valore OLD se il file è già esistente, NEW se vogliamo crearne uno nuovo, SCRATCH per inserire un file nella memoria
dinamica.
FILE = cexpr dove cexpr è una espressione CHARACTER che
riporta il nome del file; non deve essere usata insieme a SCRATCH.
ACCESS = cexpr dove cexpr è un espressione CHARACTER
che assume il valore SEQUENTIAL o ( per default ) DIRECT.
FORM = cexpr dove cexpr è un espressione CHARACTER con
il valore FORMATTED oppure UNFORMATTED
38
1.79. ISTRUZIONE CLOSE
RECL = iexp dove iexp è un espressione intera che specifica la

lunghezza del record; deve essere data per i file ad accesso DIRECT.
Le unità sono CHARACTERS per i file FORMATTED.
BLANK = cexpr , dove cexpr è un espressione CHARACTER
che specifica il trattamento standard degli spazi: può essere un NULL (
gli spazi vengono ignorati ) oppure uno ZERO ( gli spazi sono sostituiti
da zeri ).
ERR = s dove s è una etichetta che si riferisce ad una istruzione
cui viene passato il controllo dell esecuzione in caso di errore.
IOSTAT=ios dove ios è il nome simbolico di una variabile INTEGER*4 o di un elemento di vettore. Nel caso di errori, ios assume
un valore positivo; se si verifica la condizione di endfile, ios assume il
valore -1 ed infine in caso di operazione conclusa senza errori ios assume
il valore zero. Esempi:
OPEN (unit=8, file=espe.dat, status=NEW)
OPEN (unit=N+5, file=dev//dati, status=OLD,
$ ERR = 99 )
OPEN (unit= 1,file=fnome, status=OLD,
$ FORM=UNFORMATTED, IOSTAT= KODE )
1.79
Istruzione CLOSE
Tutti i file e le unità sono chiuse automaticamente alla fine del programma. Una istruzione CLOSE esplicita può servire per riassegnare
successivamente un file o una unità;
CLOSE ( lista )
dove lista è una serie di argomenti scelti da:
UNIT = u specifica l unità
STATUS = cexp è un espressione CHARACTER del tipo KEEP
per conservare i file oppure DELETE per cancellarli.
IOSTAT = iv ritorna il tipo di errore.
ERR = s se si verifica un errore di chiusura, ritorna all unità s.
Esempio:
CLOSE (UNIT=15, STATUS=DELETE,ERR=999)

39
1.80. ISTRUZIONE INQUIRE
1.80
Istruzione INQUIRE
L istruzione INQUIRE è usata per ottenere informazioni sulle proprietà

di unità logiche o di file. Ci sono due forme:
INQUIRE (unit = u, ilist )
INQUIRE (file= cexp, ilist )

dove ilist è una lista contenente uno o pi`
u dei seguenti argomenti:
ERR = s specifica un label per errore di uscita NUMBER= iv ritorna il numero dell unità logica RECL = iv ritorna la lunghezza del
record se il file è ad accesso diretto IOSTAT= iv ritorna lo stato del
codice NEXTREC =iv ritorna il numero del prossimo record da leggere o da scrivere EXIST = lv ritorna.true. oppure.false., se l unità
o file esiste o meno OPENED = lv ritorna.true. oppure.false., se
l unità o file è connesso o meno NAMED = lv ritorna.true. se il
file ha un nome, oppure.false. NAME = variabile CHARACTER
definisce il nome del file ACCESS = cv ritorna SEQUENTIAL oppure DIRECT secondo il tipo di accesso definito in OPEN FORM
= cv ritorna FORMATTED oppure UNFORMATTED secondo il
tipo di file connesso BLANK = cv ritorna un NULL oppure un
BLANK SEQUENTIAL =cv ritorna YES oppure NOoppure
indefinito secondo il tipo di accesso al file DIRECT =cv ritorna
YES oppure NOoppure indefinito FORMATTED =cv ritorna
YES oppure NO oppure indefinito secondo il tipo di FORM indicato UNFORMATTED =cv ritorna YES oppure NO oppure
indefinito
1.81
Istruzioni READ/WRITE
L istruzione READ trasferisce i dati da un file interno od esterno ad

una lista di espressioni o elementi di vettori. L istruzione WRITE
valuta una lista di espressioni o elementi di vettori e trasferisce i valori
su file interni od esterni. Le istruzioni hanno la forma seguente:
READ (unit= 1,FMT = fmt, REC=iexpp,
$ ERR =s,END = s,IOSTAT =iv)rlista
WRITE (unit= 1,FMT = fmt,REC=iexpp,
$ ERR =s,END = s,IOSTAT =iv)wlista

dove unit = u indica l unità cui è connesso il file. FMT =
fmt specifica il formato in cui leggere o scrivere i dati. REC = rec
40
1.82. ISTRUZIONE REWIND
specifica il record in caso di connessioni con accesso diretto. ERR

= s per ridirigere l esecuzione in caso di errore nell operazione di
trasferimento dati. END = s per ridirigere l esecuzione in caso si
verifichi la condizione di endfile durante l operazione di trasferimento
dati. IOSTAT = ios per monitorare gli errori o lo stato di fine file.
Ricordiamo che:
1. il trasferimento di dati unformatted è permesso solo con file
esterni.
2. viene trasferito un record per ogni istruzione di I/O.
3. il trasferimento di dati formatted richiede la specifica del formato
in cui sono stati scritti o devono essere scritti i dati.
4. per ogni istruzione di I/O possono essere trasferiti uno o pi`
u
record.
L istruzione PRINT trasferisce i dati dalla dislocazione interna al
terminale in modo interattivo oppure al batch log in modo batch (ossia
il comando viene posto in coda ). Prende la forma:
Print fmt,list
L istruzione TYPE è praticamente uguale al PRINT ma funziona solo per alcune implementazioni tipo UNIX-FORTRAN. Assume la
forma:
TYPE *,list
L istruzione ACCEPT trasferisce i dati dal terminale alla memoria interna; l accesso è di tipo sequenziale. Anche questa istruzione
funziona solo in UNIX-FORTRAN. Riportiamo la forma pi`
u semplice:
ACCEPT *,list
Esempi:
WRITE (91,101)jx,jy,index(1),index(2)
WRITE (5,(A))TEXT
1.82
Istruzione REWIND
Quest istruzione è usata per posizionare un file sequenziale all inizio

del primo record. Non ha effetto se il file è già riavvolto. Assume la
forma:
REWIND ( UNIT = u, ERR =s,IOSTAT =iv)

41
1.83. ISTRUZIONE BACKSPACE
Esempio:
REWIND ( UNIT = 3,ERR =120 )
1.83
Istruzione BACKSPACE
L istruzione può essere usata su un file sequenziale per muovere la

posizione del file indietro di un record. Assume la forma del tipo:
BACKSPACE u
dove u è una variabile intera che specifica l unità logica interessata,
ad esempio un file su disco.
1.84
Istruzione ENDFILE
L istruzione ENDFILE è usata per scrivere un record di end alla fine

di un file. Questo record in UNIX-FORTRAN corrisponde ad un byte
con il valore ASCII 26 ( CTRL/Z). Prende la forma:
ENDFILE u
dove u è una variabile intera che specifica l unità logica interessata.
Supponiamo adesso di volere aggiungere alcuni dati su un file già esistente. Dovremo prima arrivare alla fine del file tramite un istruzione
di READ, ritornare indietro di una posizione tramite BACKSPACE,
inserire tramite WRITE i dati interessati, richiudere il file tramite ENDFILE e finalmente chiudere il file. Come esempio pratico riportiamo
la SUBROUTINE SCRIVIDATI:
100
101
120
SUBROUTINE
scrividati
(ave,sdev )
implicit real *4 (a-h,o-z)
LOGICAL EXST
iunit = 12
iunit2 = 13
OPEN (iunit2,file=spessore.dat ,type=old)
read (iunit2 , 101) spessore_par,icasi
format (f10.4,f10.4,f10.4)
format (f10.4,i2)
INQUIRE(FILE=risultati.dat,EXIST=EXST )
IF (EXST) THEN
OPEN(iunit ,file=risultati.dat,type=old)
read
(iunit , 100,end=130 )zz, xx ,yy
42
130
1.85
1.85. LA SPECIFICAZIONE FORMAT
go to 120
continue
backspace iunit
write
(iunit , 100 )spessore_par,ave,sdev
endfile
iunit
close (iunit )
close (iunit2)
ELSE
OPEN(iunit,file=risultati.dat,type=new)
write (iunit , 100)spessore_par, ave, sdev
close (iunit )
close (iunit2)
END IF
return
END
La specificazione FORMAT
La specificazione del formato dei dati è richiesta dalle istruzioni READ/

WRITE oppure PRINT per controllarne la traduzione fra forma interna
ed esterna. Un FORMAT può essere inserito in qualsiasi parte del
programma ed è caratterizzato da una etichetta relativa posta nelle
prime cinque colonne. Assume la forma:
100
FORMAT (ed1,ed2.....)
dove ed1, ed2...edn sono i cosidetti descrittori di formato che si
dividono come segue.
1.86
Descrittori ripetibili
Ogni descrittore di questo tipo corrisponde ad una operazione di input

/output. Riportiamo i pi`
u usati:
IW In input, trasferisce w caratteri dal campo esterno ai valori di
lista e assegna ad essi un valore intero. Il dato esterno deve essere un
intero. In output trasferisce il corrispondente valore ad un carattere
esterno che è lungo w elementi. Fw.d In input trasferisce w caratteri
dal campo esterno e assegna ad essi, come valore reale, i corrispondenti
elementi di lista ( che devono essere reali ). Se il primo carattere non
43
1.86. DESCRITTORI RIPETIBILI
Tabella 1.3: Tabella sul format Gw.d

M agnitudine del dato
Conversione ef f ettiva
m < 0.1
Ew.d[Ee]
0.1 m < 1.0
F (w 4).d, n(0 0 )
1.0 m < 10.0
F (w 4).(d 1), n( 0 0 )
.
.
.
.
.
.
10 d 2 m < 10 d 1
F (w 4).1, n( 0 0 )
10 d 1 m < 10 d
F (w 4).0, n( 0 0 )
m 10 d
Ew.d[Ee]
nullo è un segno -, il campo è trattato come negativo. Se invece il

campo non contiene nè un numero decimale nè un esponente viene
trattato come un numero reale di w cifre in cui le d cifre sono a destra
rappresentate da degli zeri. In output, trasferisce la corrispondente
lista arrotondata alla d posizione decimale. Il termine w deve essere
grande abbastanza per includere il segno ( se necessario ), almeno una
cifra alla sinistra del punto decimale e d cifre alla destra del decimale.
Ew.d In input, funziona come il formato F. In output, E trasferisce il
valore della corrispondente lista, arrotondata a d cifre decimali con E
che specifica il valore dell esponente. Il termine w deve essere grande
abbastanza per includere: segno,uno zero,un punto decimale, d cifre e
un esponente. Quindi per tenere conto di queste esigenze il termine w
deve essere maggiore o uguale a d+ 7.
Dw.d Vale per i reali in doppia precisione. In output si comporta
come il formato E, eccetto che la lettera D rimpiazza la lettera E precedente l esponente e abbiamo due cifre come esponente. Gw.d In input,
funziona come il formato F. In output trasferisce la lista corrispondente in funzione della magnitudine, vedi tabella seguente. Tenendo conto
delle varie possibilità w deve essere pi`
u grande o uguale a d+8.
nHc1..cn In input trasferisce n caratteri dal campo esterno al descrittore medesimo.Il primo carattere appare subito dopo la H. Prende
il nome di variabile di Hollerith. Lw In input trasferisce w caratteri
dal campo esterno e assegna un valore logico al corrispondente elemen44
1.87. DESCRITTORI NON RIPETIBILI
to di lista. Se il primo carattere non nullo è T,t,.T,.t viene assegnato

il valore.TRUE. al corrispondente elemento se invece i primo carattere
non nullo vale F, f,.F, or.f, viene assegnato il valore.FALSE.. In output
trasferisce la lettera T ( se la variabile è vera ) o la lettera F ( se la
variabile è falsa ). La lettera T o F viene messa nella posizione pi`
u
a destra preceduta da w-1 spazi. Aw Se il corrispondente elemento
di I/O e di tipo CHARACTER viene trasmesso un dato character. Il
valore di w deve essere minore od uguale a 32767. Il w può essere omesso e per default viene assegnato un numero di caratteri uguali a quelli
dichiarati nella variabile numerica.
1.87
Descrittori non ripetibili
I seguenti descrittori servono a controllare la posizione in un record o in

un file, ma non corrispondono ad una operazione di I/O: stringa dove
la stringa viene mandata in uscita Tn si posiziona tramite il TAB alla
colonna n Trn si posiziona tramite il TAB a n colonne a destra Tln si
posiziona tramite il TAB a n colonne a sinistra nX lascia n spazi SP
produce un segno prima di tutti i numeri seguenti positivi SS sopprime
il segno prima di tutti i numeri seguenti positivi BN tratta i blanks
seguenti in input come nulli BZ tratta i blanks seguenti in input come
zeri KP setta il fattore di scala per i susseguenti I/O / comincia un
nuovo record
Facciamo alcuni esempi:
A=5
B = - 10
C = 2224
WRITE ( 5, 20 ) A, B, C
20
FORMAT(3I4)
WRITE ( 5, 21 ) A, B, C
21
FORMAT(3(1X,I4))
WRITE ( 5, 22 ) A, B, C
22
FORMAT(1X,A = ,I2 ,1X,B = ,I3,1X,C = ,I5,/)
A = 12
B = 25.4
C = -1.23
WRITE ( 5, 20 ) A, B, C
20
FORMAT(F3.0,F4.1,F5.2)
45
1.87. DESCRITTORI NON RIPETIBILI
21
22
22
22
22
WRITE ( 5, 21 ) A, B, C
FORMAT(F3.0,1X,2(E12.4,1X))
WRITE ( 5, 22 ) A, B, C
FORMAT(F3.0,1X,E12.4,1X,D12.4)
A = 1.
B = 10.
C = 100.
D = 1000.
WRITE ( 5, 22 ) A, B, C, D
FORMAT(5G10.4)
WRITE ( 5, 22 ).TRUE.,.FALSE.
FORMAT(2L2)
WRITE ( 5, 22 ) BUONGIORNO
FORMAT(A6)
46
Capitolo 2
Il Laboratorio
Nei prossimi capitoli verranno illustrati alcuni programmi per l elaborazione dei dati ricavati dalle esperienze di laboratorio. Questi programmi sono stati sviluppati in ambiente MS-DOS usando il compilatore Microsoft-FORTRAN versione 5.0. Le esercitazioni sono state
concepite ed implementate in modo tale da risultare accessibili sin dalla
prima volta anche agli utenti sprovvisti di ogni nozione di informatica.
L utente è infatti guidato attraverso tutte le fasi dell esercitazione,
dall immissione corretta dei dati all elaborazione dei parametri statistici di interesse ed infine alla presentazione finale dei risultati da
istruzioni che appaiono di volta in volta sullo schermo video o grafico. Per alcuni programmi viene dapprima illustrato l argomento o gli
argomenti a cui esso si riferisce e le formule utilizzate. Viene inoltre
inserito il listato del programma in linguaggio FORTRAN,commentato
nelle varie fasi, per l utente che desidera apportare modifiche particolari. I programmi sono quasi tutti scritti in ambiente MS-DOS in
FORTRAN-77 e fanno uso di subroutines contenute nel libro [REC 92]
e per semplicicità non contengono uscite grafiche.
2.1
RETTA
Questo programma illustra come, date due serie di datix ey e l errore relativo alla variabile y in interattivo,al fine di stabilire eventuali
relazioni di tipo lineare tra di esse, vengono calcolati:
47
2.1. RETTA
CAPITOLO 2. IL LABORATORIO
1. valor medio:
x =
N
1 X
xi
N i=1
(2.1)
y =
N
1 X
yi
N i=1
(2.2)
2. deviazione standard:
sx =
v
u
u
t
N
1 X
(xi x)2
N 1 i=1
(2.3)
sy =
v
u
u
t
N
1 X
(yi y)2
N 1 i=1
(2.4)
3. coefficienti della retta di regressione (coef. angolare b e intercetta

a):
PN
(xi x)(yi y)
(2.5)
b = i=1
PN
)2
i=1 (xi x
a = y b
x
(2.6)
4. errore sui coefficienti

error(b) =
error(a) =
v
u PN
2
u
i=1 (yi a bxi )
t
PN
2
(N 2)
i=1 (xi
x)
v
u PN
u
t i=1 (yi
a bxi )2 1
x2
[ + PN
]
(N 2)
N
)2
i=1 (xi x
(2.7)
(2.8)
5. coefficiente di correlazione r di Pearson

r=
PN
(xi
qP i=1
N
i=1 (xi
x)(yi y)
x)2
PN
i=1 (yi
(2.9)
y)2
6. Valore di 2
2
(a, b) =
N
X
i=1
48
(yi a bxi ) 2
)
i
(2.10)
2.1. RETTA
Segue il listato del programma che usa le subroutine FIT e PEARSN

estratte dal libro [REC 92]:
program retta
C definizione delle variabili e dei vettori utilizzati nel programma
implicit real (a-h,o-z)
character
ris
parameter
( max =100)
dimension xreal (1:max)
dimension yreal (1:max)
dimension sigma (1:max)
print *,Programma per il calcolo statistico
print *,Media,Deviazione standard e correlazione lineare

print *,Calcolo del chiquadro e del coefficiente
print *,di correlazione lineare
call attesa
print *,riportiamo anche il parametro q che indica la bonta
print *,del fit , vedi Numerical Recipes I/II
print *,Q = gammq ( (N-2)/2 , chi**2 /2 )
print *,N
==> numero di dati
print *,dove gammq e la funzione gamma incompleta
print *, Q > 0.1

==> fit accettabile
print *, Q > 0.001 ==> fit accettabile solo se gli
print *,
errori sono non-normali oppure
print *,
sottostimati ( vedi modulo Youg
print *,Q
< 0.001 ==> il modello non funziona !!!
call attesa
100
format (a)
print *,Hai messo i dati nel file retta.dat a
print *,triplette x,y errore sulle y

?
print *,rispondere Y/N
?
read 100,ris
if ((ris.eq.Y).or.(ris.eq.y)) then
go to 150
elseif ((ris.eq.N).or.(ris.eq.n)) then
stop Metti i dati nel file retta.dat a triplette x,y,sy !!
else
stop SCEMO , risposta non valida !!!!!
end if
49
2.2. PARABO
150
continue
call attesa
open (unit=90,file=retta.dat, status=old)
C
input dati
n = 0
199
continue
read (90,*,end = 200)xx,yy ,sy
n = n + 1
xreal ( n ) = xx
yreal ( n ) = yy
sigma ( n ) = sy
go to 199
200 continue
close ( unit = 90 )
mwt = 1
call fit (xreal,yreal,n,sigma,mwt,a,b,errora,errorb,chi2,q)
call pearsn (xreal,yreal,n,r,prob,z)
print *,fit della retta y = a + b * x
print *,a =,a

print *,b =,b
print *,errore su a = ,errora
print *,errore su b = ,errorb
print *,valore del chiquadro =,chi2
print *,valore del coefficiente lineare r =,r
print *,valore di bonta del fit
Q =,q
stop
end
2.2
PARABO
Questo programma viene utilizzato per l analisi dei dati dell esercitazione sulla bilancia di Cavendish (determinazione della costante di gravitazione mediante il metodo della parabola) oppure per l esercitazione
sulla rotaia ad aria (determinazione della accelerazione di gravità). Si
devono immettere il numero n di dati e, successivamente le n triplette
di valori x,y e errore su y. Tramite la subroutine LFIT, ricavata dal
libro [REC 92] , si calcolano i coefficienti a,b,c della curva parabolica di
50
2.2. PARABO
regressione y = a + b x + c x2 e i relativi errori con il metodo dei

minimi quadrati. Viene anche visualizzato il valore sperimentale della
variabile 2 . Segue il listato del programma.
program
parabo
C
C definizione delle variabili e dei vettori
C utilizzati nel programma
C
parameter
( max =50 )
parameter
( nterm = 3 )
dimension x (1:max)
dimension y (1:max)
dimension sig (1:max)
dimension a (1:nterm)
dimension covar (1:nterm,1:nterm)
dimension lista (1:nterm)
external funcs
C
print *,Fit con un polinomio di secondo grado
99 continue
C
C input dei dati da tastiera
C
call attesa
print *,Avete messo i dati nel file parabo.dat ?
print *,In sequenza , x , y , errore sulle y .....
call attesa
open (unit=11,file=parabo.dat,status=old)
n = 0
199
continue
read (11,*,end = 200)xx,yy,errory
n = n + 1
x
( n ) = xx
y
( n ) = yy
sig ( n ) = errory
go to 199
51
2.3. PENDO
200 continue
close ( unit = 11)
do 201 jj = 1, nterm
lista ( jj ) = jj
201
continue
call lfit (x,y,sig,n,a,lista,nterm,covar,nterm,chisq,funcs)
errora = sqrt ( covar (1,1))
errorb = sqrt ( covar (2,2))
errorc = sqrt ( covar (3,3))
print *,fit del polinomio
y = a + b * x + c * x**2
print *,a =,a(1)
print *,b =,a(2)
print *,c =,a(3)
print *,errore su c = ,errorc
print *,Valore del chiquadro =,chisq
stop
end
2.3
PENDO
Questo programma è utile nell analisi dei dati dell esercitazione con il
pendolo composto. Vengono richiesti gli errori sulle misure della variabile y (tempo) per la prima e la seconda serie di dati. Successivamenti
si immettono il numero di dati e le coppie di valori x (distanza),y (tempo) per la prima serie di dati. Il programma valuta immediatamente
i coefficienti della curva parabolica y = a + b x + c x2 , mediante chiamata alla subroutine LFIT estratta dal libro [REC 92] che usa
il metodo dei minimi quadrati quando il polinomio interpolante è di
secondo grado.
Analogo procedimento viene seguito per la seconda serie di dati. Il
programma calcola poi lintersezione delle parabole, l errore sullintersezione e finalmente il valore di g ed il suo errore. Alleghiamo il listato
del programma.
program pendo
parameter
( max
=50
52
99
100
2.3. PENDO
parameter
( nterm = 3 )
parameter
( inc
= 3 )
parameter
( reg
= 980.5343)
character * 1 prova,video,rispo
character * 40
messag
dimension x (1:max)
dimension y (1:max)
dimension sig (1:max)
dimension x2 (1:max)
dimension y2 (1:max)
dimension sig2 (1:max)
dimension result(1:20)
dimension a (1:nterm)
dimension covar (1:nterm,1:nterm)
dimension para (1: inc )
dimension epara (1: inc )
dimension messag (1: inc )
external funcs
prova =y
el
= 99.3
errl
=
0.1
teta
=
5.0
eteta
=
1.0
nosci = 30
if
(( prova.eq.Y).or.(prova.eq.y)) then
print *,Programma per il calcolo di g in CGS tramite
print *,intersezione di due parabole
print *,ovviamente deve essere presente landamento parabolico

print *,nei dati .....
print *,i dati x rappresentano le distanze della massa mobile

print *,dal coltello e sono espresse in cm
print *,i dati y rappresentano i tempi impiegati a compiere

print *,n oscillazioni a vanno espressi in secondi
print *,gli errori sulle y (errori tempi) pure vanno espressi

print *,in secondi !
continue
format (a1)
print *,Hai messo i dati nel file pendo1.dat
53
2.3. PENDO
150
151
199
print *,a triplette x [cm],y [sec] errore sulle y [sec] ?
?
read 100, rispo
if ((rispo.eq.Y).or.(rispo.eq.y)) then
go to 150
elseif ((rispo.eq.N).or.(rispo.eq.n)) then
stop Metti i dati nel file pendo1.dat a triplette x,y,sy !!
else
end if
continue
print *,Hai messo i dati nel file pendo2.dat
print *,a triplette x [cm],y [sec] errore sulle y [sec] ?

!
read 100, rispo

go to 151
stop Metti i dati nel file pendo2.dat a triplette x,y,sy !!
else
end if
continue
print*,Inserire l(distanza fra i coltelli)in [cm] tipo 99.3
read *,el
print*,Inserire errore l in [cm] tipo 0.1
read *,errl
print*,Inserire il numero di oscillazioni tipo 30
read *,nosci
print*,Inserire ampiezza iniziale [gradi] tipo 5
read *,teta
print*,Inserire errore ampiezza iniziale [gradi] tipo 1
read *,eteta
call attesa
end if
open (unit=90,file=pendo1.dat, status=old)
open (unit=91,file=pendo2.dat, status=old)
n = 0
continue
54
200
299
300
333
2.3. PENDO

n = n + 1
x
( n ) = xx
y
( n ) = yy
sig ( n ) = sy
go to 199
continue
n2 = 0
continue
n2 = n2 + 1
x2
( n2 ) = xx
y2
( n2 ) = yy
sig2 ( n2 ) = sy
go to 299
continue
errort
=
sig2 (1)
close ( unit
= 90 )
close ( unit
= 91 )
mfit = nterm
do 333 j=1,mfit
lista(j)= j
continue
call lfit (x,y,sig,n,a,lista,nterm,covar,nterm,chisq,funcs)
print *,Risultati prima parabola .......................
print *,Minimi quadrati con
y = a + b * x + c * x**2
print *,numero dati =,n
print *,a
=,a(1)
print *,b
=,a(2)
print *,c
=,a(3)
if
call
attesa
55
2.3. PENDO
334
end if
result (1) = a(1)
result (2) = a(2)
result (3) = errora
result (4) = errorb
result (5) = chisq
result (6) = a(3)
result (7) = errorc
mfit = nterm
do 334 j=1,mfit
lista(j)= j
continue
call lfit (x2,y2,sig2,n2,a,lista,nterm,covar,nterm,chisq,funcs)
print *,Risultati seconda parabola .......................
print *,Minimi quadrati con
y = a + b * x + c * x**2
print *,numero dati =,n
print *,a =,a(1)
print *,b =,a(2)
print *,c =,a(3)
if
call attesa
end if
result (11) = a(1)
result (12) = a(2)
result (13) = errora
result (14) = errorb
result (15) = chisq
result (16) = a(3)
result (17) = errorc
a1 =
result (1)
b1 =
result (2)
c1 =
result (6)
56
2.3. PENDO
a2 =
result (11)
b2 =
result (12)
c2 =
result (16)
call radici (a1,b1,c1,a2,b2,c2,val,err,errort)
val = val / nosci
err = err / nosci
para (1) =
val
para (2) =
el
para (3) =
teta
epara (1) =
err
epara (2) =
errl
epara (3) =
eteta
messag (1)= peso-errore
periodo
=
lunghezza =
ampiezza =
print *,Dati di input per il calcolo di g
print *,periodo come da intersezione [sec]=,para(1)
print *,errore periodo
[sec]=,epara(1)
print *,distanza fra i coltelli
[cm ]=,para(2)
print *,errore distanza fra i coltelli[cm ]=,epara(2)
print *,ampiezza iniziale
[gradi ]=,para(3)
print *,errore ampiezza iniziale
[gradi ]=,epara(3)
print *,**************************************
print *,Dati di output
print*,g=4*(pigrec**2)*(l/T**2)(1+(0.5*sen(0.5*teta))**2)**2
call value (valore,para,inc)
error
= 100 * abs ((reg - valore)/reg)
vero
= valore
print *,g [cm/sec**2]
=,valore
print *,g vero a TORINO [cm/sec**2]=,reg
video=N
call errori (valore,evalo,para,inc,epara,messag,video)
ippm
= nint ( evalo /vero * 1.0E+6 )
print * ,errore su g [cm/sec**2]
=,evalo
print * ,errore su g in ppm
=,ippm
print * ,errore g sul valore vero =,error, %
teta=0.
para (3) = teta
call value (valoresenza,para,inc)
57
2.3. PENDO
ippmteta=nint(((valoresenza-vero)/vero)* 10E+6)
print *,g senza teta
=,valoresenza
print *,influenza di teta su g in ppm =,ippmteta
video=Y
valore = vero
call errori (valore,evalo,para,inc,epara,messag,video)
stop
end
subroutine radici (a1,b1,c1,a2,b2,c2,val,err,errort)
implicit real
( a-h,o-z)
c
= a1 - a2
b
= b1 - b2
a
= c1 - c2
disc = b**2 - 4 *a*c
if ( disc.lt.0.0) then
stopradici immaginarie
end if
x1
= - ( b/(2*a)) + sqrt ( disc)/(2*a)
x2
= - ( b/(2*a)) - sqrt ( disc)/(2*a)
y1
= a1 + b1 * x1 + c1 *x1**2
y2
= a1 + b1 * x2 + c1 *x2**2
if ((y1.gt.0).and.(y2.gt.0)) then
print *,caso
di due radici positive
val
= ( y1 + y2 )/2.0
err
= abs ( y1-y2)
if ( err.lt.errort) then
err
= errort
end if
end if
if ((y1.lt.0).and.(y2.gt.0)) then
print *,caso
di una radice positiva e una negativa
val
= y2
err
= errort
end if
if ((y2.lt.0).and.(y1.gt.0)) then
print *,caso
di una radice positiva e una negativa
val
= y1
err
= errort
end if
58
2.3. PENDO
return
end
subroutine value (valore,para,inc)
implicit real
(a-h,o-z )
parameter
( pigrec
= 3.1415927 )
dimension para
( 1 : inc )
t
=
para (1)
el
=
para (2)
teta
=
para (3)
tetar
= 2 * pigrec * teta / 360.
cor
= ( 1.0 + (0.5 * sin (tetar/2.0))**2.0)**2.0
valore
= (4 * pigrec**2 * el /( t **2))*cor
return
end
100
190
subroutine errori (valore,evalo,para,inc,epara,messag,video)

implicit real
(a-h,o-z)
character * 40 messag
character * 1 video
parameter ( int = 10 )
parameter ( norma=10000 )
dimension para (1:inc )
dimension epara (1:inc )
dimension work (1:int )
dimension square (1:int )
dimension inter (1:int )
dimension messag (1:inc )
if (int.lt.inc)stop cambiare int
vero = valore
evalo = 0.0
do 100 j = 1 ,inc
work (j) = para (j)
continue
quadro = 0.0
do 200 j = 1 ,inc
do 190 i = 1 , inc
para (i) = work(i)
continue
59
2.4. CAVEN
200
205
206
207
210
2.4
para (j) = para(j) + epara(j)
call value (valore,para,inc)
delta = valore - vero
d2
=
delta *delta
quadro
= quadro + d2
square (j) = d2
continue
sq2 = 0.0
do 205 j= 1,inc
sq2 = sq2 + square ( j)
continue
do 206 j= 1,inc
inter (j) = nint ( square ( j) * (norma*1.0)/sq2)
continue
if (( video.eq.Y).or.( video.eq.y)) then
print*,************************************
print *,Peso normalizzato a,norma, delerrore delle variabili
do 207 j= 1, inc
print *,messag(j),inter(j)
continue
end if
evalo = sqrt ( quadro)
do 210 i = 1 , inc
para (i) = work(i)
continue
return
end
CAVEN
Questo programma valuta i parametri caratteristici dell oscillatore

smorzato, con il quale vengono interpolati i dati delle ampiezze di oscillazione [cm] in funzione del tempo [sec] ricavati dalla esperienza con
la bilancia di Cavendish. Le coppie di dati (tempi ed ampiezze) vanno
memorizzate nel file CAV.DAT, mentre in fase di esecuzione viene richiesto l errore [cm] sulla misura delle ampiezze e la distanza [cm] fra
asse della bilancia e riga per la rilevazione dati. Tramite la subroutine MRQMIN (estratta dal libro [REC 92]) vengono calcolati i cinque
60
2.4. CAVEN
parametri A,T,, ,Cost che caratterizzano la seguente equazione:

y = A seno(2 t/T + ) e
+ Cost
(2.11)
In seguito si ricava la costante di Cavendish utilizzando i seguenti valori

caratteristici della bilancia:
m = (15.0 0.12) 103 Kg
(2.12)
M = (1.503 0.001) Kg
(2.13)
r = (4.5 0.1) 102 m
(2.14)
d = (5.0 0.1) 102 m
(2.15)
l 5.0m (misurato durante l0 esercitazione)
(2.16)
Riportiamo la formula utilizzata per il calcolo;

G=ABC D
dove
A=
B = 2 + 2
(2.17)
d r2
2M
dove =
(2.18)
2
T
(2.19)
C = |2 1 |
(2.20)
con
1 =
E1
l
E1 = posizione iniziale sull0 asta graduata
(2.21)
2 =
E2
l
E2 = posizione f inale sull0 asta graduata
(2.22)
D=
1
(2.23)
r3
3
[(2d)2 + r2 ] 2
Viene inoltre calcolato l errore percentuale sul valore esatto della costante dato da
Errore = 100
|Gricavato Gvero |
Gvero
61
(2.24)
2.4. CAVEN
Viene calcolato poi l errore sulla costante G usando la legge di propagazione degli errori di Gauss: in questo caso le derivate parziali
vengolo calcolate tramite algoritmo numerico. Il programma calcola
poi G tramite il metodo dell escursione finale e quello della parabola.
Per confronto viene poi riportato Riportiamo il listato del programma
CAVEN:
1000
100
program caven
implicit real (a-h,o-z )
character * 1 prova,video,rispo
parameter(max=250,ma =5,inc=7 )
parameter(nterm = 2 )
dimension x
(1:max )
dimension y
(1:max )
dimension sig
(1:max )
dimension a
(1:ma )
dimension ia
(1:ma )
dimension covar(1:ma,1:ma)
dimension alpha(1:ma,1:ma)
dimension erroa (1:ma )
dimension ovar (1:nterm,1:nterm)
external fun2c
external fosci
prova =N
format (A2)
format (a1)
print *,Interpolazione di una sinusoide smorzata
print *,*************************************************
if ((prova.eq.N).or.(prova.eq.n)) then
print *,Avete messo i dati nel file caven.dat ?
print *,in sequenza t [sec] , ampiezze [cm] ?
print *, inserire
(Y/N )
!
read 100, rispo

go to 150
62
150
199
200
2.4. CAVEN

stop Metti i dati nel file caven.dat a coppie
!!
else
stop SCEMO , rispo non valida !!!!!
end if
continue
end if
print *,Attenzione il programma non funziona sempre e quindi
print *,osservate le seguenti regole !!!!!!!!!!!
print *,1)il primo dato rappresenta inizio della sinusoide

print *,2)il dato ultimo deve essere quello di equilibrio finale
print *,3)i dati anomali vanno eliminati
call attesa
if ((prova.eq.Y).or.(prova.eq.y)) then
el = 544.0
eel = 1.0
eey =
0.2
else
print *,Scrivere il valore della distanza [cm] ( circa 544)
read *,el
print *,Scrivere errore della distanza
[cm] ( circa 1 )
read *,eel
print *,Scrivere errore lettura scala
[cm] ( circa 0.2)
read *,eey
end if
open (unit=90,file=caven.dat, status=old)
npt = 0
continue
read (90,*,end = 200)xx,yy
npt = npt + 1
if ( npt.gt.max) stop Aumentare max !
x
( npt ) = xx
y
( npt ) = yy
sig ( npt ) = eey
go to 199
continue
close ( unit = 90 )
a (1) = abs (
y (npt) - y (1))
a (2) = 500
63
2.4. CAVEN
210
a (3) = asin (( y (1)- y (npt))/a(1))

a (4) = 500
a (5) = y (npt)
do 210 j= 1 , ma
ia (j) = 1
continue
alamda=-1
call mrqmin(x,y,sig,NPT,a,ia,MA,covar,alpha,
MA,chisq,fosci,alamda)
k=1
itst=0
continue
k=k+1
ochisq=chisq
if (chisq.gt.ochisq) then
itst=0
else if (abs(ochisq-chisq).lt.0.1) then
itst=itst+1
endif
if (itst.lt.4) then
goto 1
endif
alamda=0
erroa ( 1 ) = sqrt(covar (1,1))
print *,Fittiamo i dati con la seguente funzione nonlineare
print *,y=a(5)+a(1)*(sin(2*pigrec*x/a(2)+a(3)))*exp(-x/a(4))
print *,a(1) =,a(1), err a(1)=,erroa(1)
64
2.4. CAVEN
print *,chisq =,chisq

call attesa
recav = 6.67259 E-11
egran
= 1.500
er
= 4.652
E-02
eb
= 4.500
E-02
ed
= 5.0
E-02
eegran
= 1.0
E-3
eer
= 0.1
E-02
eed
= 0.1
E-02
para(1)
= egran
para(2)
= el
para(3)
= er
para(4)
= ed
para(5)
= a(1)
para(6)
= a(2)
para(7)
= a(4)
epara(1)
= eegran
epara(2)
= eel
epara(3)
= eer
epara(4)
= eed
epara(5)
= erroa(1)
epara(6)
= erroa(2)
epara(7)
= erroa(4)
print *,Sinopsi dei dati fisici adoperati
print *,M [kg] =,egran,+-,eegran
print *,r [cm] =,er,+-,eer
print *,b [cm] =,eb,+-,eer
print *,d [cm] =,ed,+-,eed
print *,l [cm] =,el,+-,eel
call attesa
call gtutto (cav,para,inc)
ver
= cav
valore = cav
video =N
cav
= ver
call calco (ecav,cav,para,inc,epara,video)
cav
= ver
error
= 100 * abs ((recav - cav)/recav)
65
2.4. CAVEN
ippm
= nint ( ecav/cav * 1.0E+6 )
print *,Metodo
delle oscillazioni smorzate completo
print *,Formule come in Guida alla Elaborazione dei dati
print *, oppure
Guida alla Fisica del Laboratorio
print * ,costante di Cavendish
=,valore
print * ,errore costante di Cavendish
=,ecav
print * ,errore costante di Cavendish in ppm=,ippm
print * ,errore percentuale sul valore vero=,error,%
video =Y
cav
= ver
call calco (ecav,cav,para,inc,epara,video)
call
attesa
para ( 3 ) = eb
call gescur (cave,caves,para,inc)
valore = cave
video =N
cave = valore
call calcos (ecave,cave,para,inc,epara,video)
cave = valore
ippm
= nint ( ecave/cave * 1.0E+6 )
error2
= 100 * abs ((recav - cave )/recav)
print *,Metodo escursione finale ( come da manuale Leybold )
print *,
pigrec **2 b**2
d
S
print *, G = -----------------------------
print *,
M1
T**2
L
print *,
print *,
b** 3
print *, beta = -------------------------------------

print *,
(b**2 + 4 d**2 ) sqrt (b**2 + 4 d**2 )
print *,Costante di Cavendish senza correzione = ,caves

print *,Costante di Cavendish con
correzione = ,valore
print *,Errore Costante con correzione
= ,ecave
print *,Errore costante con correzione in ppm =,ippm
print * ,errore percentuale sul valore vero=,error2,%
video =Y
cave = valore
call calcos (ecave,cave,para,inc,epara,video)
call
attesa
tquar = a (2) / 2.5
66
500
501
do 500 j= 1, npt
if (x( j ).gt.tquar)
jvec = j -1
go to 501
end if
continue
continue
do 600 jj = 1 , nterm
lista ( jj ) = jj
continue
2.4. CAVEN
then
600
C LAVORO
print *,Metodo
dell accelerazione
print *,Formule come in Guida alla Fisica del Laboratorio

call lfit (x,y,sig,jvec,a,lista,nterm,ovar,nterm,chisq,fun2c)
errora = sqrt ( ovar (1,1))
errorc = sqrt ( ovar (2,2))
print *,fit della parabola
y = a + c * x**2
print *,tempo massimo
=,tquar
print *,elementi selezionati
=,jvec
print *,a
=,a(1)
print *,c
=,a(2)
print *,errore su a
=,errora
print *,errore su c
=,errorc
print *,Valore del chiquadro
=,chisq
aa
= 2 * a (2)
print *,accelerazione=>2*c[cm/sec**2]=,aa
call
attesa
para (1)
= egran
para (2)
= el
para (3)
= er
para (4)
= ed
para (5)
= aa
epara(1)
= eegran
epara(2)
= eel
epara(3)
= eer
epara(4)
= eed
epara(5)
= errorc * 2.0
inc2
= 5
call gpara (cav,para,inc2)
67
2.4. CAVEN
error
= 100 * abs ((recav - cav)/recav)
ippm
= nint ( ecav/cav * 1.0E+6 )
vcav = cav
video =N
cav
= vcav
call capa2 (ecav,cav,para,inc2,epara,video)
cav
= vcav
error
= 100 * abs ((recav - vcav)/recav)
ippm
= nint ( ecav/vcav * 1.0E+6 )
print *,Metodo della parabola
print *,formule come su Guida alla Fisica del laboratorio
print *,
b**2 d a
print *, G = -------------print *,
2 M L
print *,
print *,Costante di Cavendish
=,vcav
print *,errore costante di Cavendish =,ecav
print *,errore costante di Cavendish in ppm=,ippm
print *,errore percentuale sul valore vero=,error,%
video =Y
cav
= vcav
call capa2 (ecav,cav,para,inc2,epara,video)
stop
end
SUBROUTINE fosci(x,a,y,dyda,na)
parameter ( pigrec = 3.1415927)
dimension a
(1:na)
dimension dyda(1:na)
y=a(5)+a(1)*(sin(2*pigrec*x/a(2)+a(3 )))* exp(-x/a(4))
dyda(1) = (sin(2*pigrec*x/a(2)+a(3 )))* exp(-x/a(4))
ccc
= 2*pigrec*x/(a(2)**2.0)
bbb
= (cos(2*pigrec*x/a(2)+a(3 )))* exp(-x/a(4))
aaa
= - a(1)
dyda(2) = aaa * bbb * ccc
dyda(3) = a(1)*(cos(2*pigrec*x/a(2)+a(3 )))* exp(-x/a(4))
bbb
= a(1)*(sin(2*pigrec*x/a(2)+a(3 )))* exp(-x/a(4))
aaa
= x /(a(4)**2.0)
dyda(4) = aaa * bbb
68
100
2.4. CAVEN
dyda(5) = 1.0
return
END
subroutine gtutto (cav,para,inc)
implicit real
(a-h,o-z)
pigrec
= 3.1415927
egran
= para(1)
el
= para(2)
er
= para(3)
ed
= para(4)
a1
= (ed * er**2)/(2.0* egran )
a2
= (2 * pigrec / para(6))**2 + ( 1/para(7))**2
diff
= abs ( atan ( para(5) /el ))
aldif
= diff/2.0
a3
= aldif
elle
= sqrt ( (2* ed)**2 + er **2 )
a4
= 1.0/(1.0 - (er/elle)**3 )
cav
= a1 * a2 * a3 * a4
return
end
subroutine calco (ecav,cav,para,inc,epara,video)
implicit real
(a-h,o-z)
character * 1 video
dimension para
(1:inc )
dimension epara
(1:inc )
dimension work
(1:int )
dimension inter
(1:int )
vero = cav
do 100 j = 1 ,inc
work (j) = para (j)
continue
quadro = 0.0
do 200 j = 1 ,inc
do 190 i = 1 , inc
para (i) = work(i)
69
2.4. CAVEN
190
200
205
206
210
C
C
C
continue
para (j)
= para(j) + epara(j)
call gtutto (cavmod,para,inc)
delta
= cavmod - vero
quadro
= quadro + delta *delta
square ( j )= delta * delta
continue
sq2 = 0.0
do 205 j= 1,inc
continue
do 206 j= 1,inc
inter (j) = nint ( square ( j) * 1000./sq2)
continue
print *,Peso normalizzato a 1000 dellerrore delle variabili
print *,sullerrore del valore di G-metodo completo
print *,errore su M ( massa grande)

=,inter(1)
print *,errore su L ( distanza indice)
=,inter(2)
print *,errore su r ( distanza masse )
=,inter(3)
print *,errore su d ( manubrio/2
)
=,inter(4)
print *,errore su a(1)(ampiezza oscillazioni)
=,inter(5)
print *,errore su a(2)(periodo oscillazioni)
=,inter(6)
print *,errore su a(4)(smorzamento oscillazioni)=,inter(7)
end if
ecav = sqrt ( quadro)
do 210 i = 1 , inc
para (i) = work(i)
continue
return
end
subroutine gescur (cave,caves,para,inc)
implicit real
(a-h,o-z)
pigrec
= 3.1415927
egran
= para(1)
el
= para(2)
er
= para(3)
70
C
C
C
C
ed
a(1)
a(2)
a(4)
egran
el
er
ed
aa1
aa2
aa3
aa4
dd1
dd2
dd3
ages
d1
d2
beta
piu
cave
caves
return
end
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
2.4. CAVEN
para(4)
para(5)
para(6)
para(7)
para(1)
para(2)
para(3)
para(4)
pigrec **2
er
**2
ed
para(5) * 0.01
egran
para(6)
** 2
el
/ 100.
aa1 * aa2 * aa3 *aa4 /( dd1 * dd2 * dd3 )
1 + 4 * ( ed / er )**2
sqrt ( 1 + 4 * ( ed / er )**2 )
1 /( d1 * d2 )
beta * ages
ages + piu
ages
subroutine calcos (ecave,cave,para,inc,epara,video)

implicit real
(a-h,o-z)
character
* 1 video
dimension work (1:int )
dimension inter (1:int )
vero = cave
do 100 j = 1 ,inc
work (j) = para (j)
71
2.4. CAVEN
100
190
200
205
206
210
continue
quadro = 0.0
do 200 j = 1 ,inc
do 190 i = 1 , inc
para (i) = work(i)
continue
para (j) = para(j) + epara(j)
call gescur (cmod,caves,para,inc)
delta = cmod - vero
quadro
square (j) = delta * delta
continue
sq2 = 0.0
do 205 j= 1,inc
continue
do 206 j= 1,inc
continue
print *,sullerrore del valore di G-escursione finale
=,inter(1)
=,inter(2)
=,inter(3)
)
=,inter(4)
print *,errore su a(1)(ampiezza oscillazioni)
=,inter(5)
print *,errore su a(2)(periodo oscillazioni)
=,inter(6)
print *,errore su a(4)(smorzamento oscillazioni)=,inter(7)
end if
ecave = sqrt ( quadro)
do 210 i = 1 , inc
para (i) = work(i)
continue
return
end
SUBROUTINE fun2c(X,AFUNC,MA)
DIMENSION AFUNC(MA)
AFUNC(1)= 1.0
72
AFUNC(2)=
END
2.4. CAVEN
X**2.0
subroutine gpara (cav,para,inc)

implicit real
(a-h,o-z)
egran
= para(1)
el
= para(2)
er
= para(3)
ed
= para(4)
aa
= para(5)
cav
= ( aa* ed * er**2 )/(2.0 * egran * el )
return
end
subroutine capa2 (ecav,cav,para,inc,epara,video)
C lavoro
implicit real
(a-h,o-z)
character * 1 video
dimension para
(1:inc )
dimension epara
(1:inc )
dimension work
(1:int )
dimension inter
(1:int )
vero = cav
do 100 j = 1 ,inc
work (j) = para (j)
100
continue
quadro = 0.0
do 200 j = 1 ,inc
do 190 i = 1 , inc
para (i) = work(i)
190
continue
para (j)
= para(j) + epara(j)
call gpara(cavmod,para,inc)
delta
= cavmod - vero
quadro
73
2.5. GAUSS
200
205
206
210
2.5
square ( j )= delta * delta

continue
sq2 = 0.0
do 205 j= 1,inc
continue
do 206 j= 1,inc
continue
print *,sullerrore del valore di G-metodo parabola

=,inter(1)
=,inter(2)
=,inter(3)
)
=,inter(4)
print *,errore su a ( accelerazione )
=,inter(5)
end if
ecav = sqrt ( quadro)
do 210 i = 1 , inc
para (i) = work(i)
continue
return
end
GAUSS
Questo programma riguarda l esercitazione sul viscosimetro ma puo

essere usato per altri scopi. Si parte con una serie di dati inserita
nel file GAUSS.DAT che vengono lette dal programma e inserite nel
vettore DATI. La subroutine ISTOTUTTO provvede poi a calcolare il
massimo e il minimo e, dato in modo interattivo il numero di classi,
la distribuzione in frequenza. Si ottengono poi i seguenti parametri
statistici caratterizzanti la distribuzione sperimentale:
1. valor medio dell istogramma
1
1 NX
(xi )(yi )
x =
N i=1
74
(2.25)
2.5. GAUSS
2. deviazione standard dell istogramma

s2 =
v
u
u
t
1
1 NX
yi (xi x)2
N 1 i=1
(2.26)
3. momento di terzo ordine e asimmetria

PN 1
s3 =
yi (xi x)3
(N 1) s23
i=1
(2.27)
4. momento di quarto ordine e curtosi

PN 1
s4 =
yi (xi x)4
3
(N 1) s24
i=1
(2.28)
5. 2 :
2 =
N
1
X
i=1
(yi fi )2
fi
(2.29)
Riportiamo il listato del programma GAUSS:

program
gauss
C
C definizione delle variabili e dei vettori utilizzati dal programma
C
parameter
( max
= 1000)
parameter
( pigrec = 3.141592653)
character * 2 risp
character * 1 pausa
dimension xreal
(1:max)
dimension iyreal
(1:max)
dimension dati
(1:max)
open (unit=90,file=gauss.dat, status=old)
C
C input dei dati da tastiera
C
75
2.5. GAUSS
print *,Analisi di dati con distribuzione Gaussiana
print *,Avete messo i dati nel file gaussiana.dat ?
print *, se no uscite !!!!!!!!!!!!!!!
print *,<CR> per continuare !

read 1000,pausa
ndati = 0
199
continue
read (90,*,end = 200)dato
ndati = ndati + 1
dati ( ndati ) = dato
go to 199
200 continue
250 continue
print *,Scrivere il numero di
intervalli desiderato
read *,ndiv
print *,va bene questo numero di intervalli
?
<CR>/NO
read 1000,risp
if ((risp.eq.NO).or.(risp.eq.no)) then
go to 200
end if
jvec = 0
999 format (A1)
1000 format (A2)
ndiv1 = ndiv + 1
call isto
(dati,ndati,max,ndiv1,xreal,iyreal,delta)
call mom
(ndiv1,xreal,iyreal,xmedio,s2,s3,s4,nsumy)
C calcolo del chi-quadro
chi2
= 0.
do 100 j= 1,ndiv
xmezzo = (xreal(j) + xreal (j+1))/ 2.0
yteo
= 1./(sqrt (2.0 * pigrec) *s2 )
yteo
= yteo * exp (-((( xmezzo - xmedio)/s2 )**2)/2.0 )
yteo
= yteo * nsumy * delta
chi2
= chi2 + (( iyreal (j) - yteo)**2) / yteo
100
continue
print *,xmedio =,xmedio
print *,s2
=,s2
print *,s3
=,s3
print *,s4
=,s4
76
101
102
104
103
2.5. GAUSS
print *,nsumy =,nsumy

print *,chi2
=,chi2
print *,Vuoi cambiare il numero di intervalli ?
Y/N
read 999,pausa
if ((pausa.eq.Y).or.(pausa.eq.y)) then
go to 250
end if
stop
end
subroutine isto (dati,ndati,max,ndiv1,xreal,iyreal,delta)
dimension dati (1:max)
dimension xreal (1:max)
dimension iyreal(1:max)
azzeramento variabili
do 101 j= 1 ,ndiv1
xreal (j) = 0
iyreal (j) = 0
continue
call maxmin
(dati,ndati,xmax,xmin )
xmax = xmax + xmax/1000
ndiv = ndiv1 - 1
delta = ( xmax - xmin )/ndiv
do 102 j = 1 , ndiv1
xreal (j) = xmin + ( j-1 ) * delta
continue
do 103 j = 1 , ndati
do 104 i= 1 , ndiv
xl = xreal ( i
)
xu = xreal ( i + 1 )
if ( (dati (j).ge.xl).and.(dati(j).lt.xu) ) then
iyreal ( i) = iyreal(i) +1
end if
continue
continue
return
end
subroutine mom
(k,x,ifreq,xmean,s2,s3,s4,n)
implicit real
(a-h,o-z)
77
2.5. GAUSS
100
C
101
C
102
C
103
C
104
C
105
dimension x
(1:k)
dimension ifreq (1:k)
dimension y
(1:1000)
azzeramento variabili
xmean = 0.
s2
= 0.
s3
= 0.
s4
= 0.
n
= 0
calcolo della frequenza totale
do 100 i=1,k-1
n = n + ifreq (i)
continue
calcolo dei punti centrali
do 101 j=1,k-1
y(j) = ( x(j+1) + x (j) )/2.0
continue
calcolo del valor medio
do 102 j=1,k-1
xmean = xmean + y (j) * ifreq (j)
continue
xmean = xmean/ n
calcolo della deviazione standard
do 103 j=1,k-1
s2 = s2 + ((y(j) - xmean )**2) * ifreq (j)
continue
s2 = sqrt (s2/(n-1))
calcolo della asimmetria
do 104 j =1,k-1
continue
s3 = s3 /((n-1)*( s2**3))
calcolo della curtosi
do 105 j=1,k-1
continue
s4 = ( s4 /((n-1)*( s2**4))) - 3.
return
end
78
2.6
2.6. TESTT
TESTT
Questo programma sostituisce le tabelle relative al test di Student. Si

inseriscono in maniera interattiva il numero di gradi di libertà n e la
probabilità considerata. Mediante la subroutine BETAI appartenente
al libro [REC 92] viene poi calcolato il valore critico, xp , associato con
il taglio inferiore corrispondente alla probabilità della distribuzione di
Student con n gradi di libertà. Riportiamo il listato del programma
TESTT:
program
testt
implicit real
(a-h,o-z)
logical
condiz
character * 1 pausa
parameter ( tmax = 1000 ,ndiv = tmax * 100)
external betai
print *,Programma per il calcolo del valore critico nella
print *,distribuzione della variabile casuale t di Student
print *,con nu gradi di liberta , dato alfa
print *,<CR> per continuare !

read 1000,pausa
999 format (A1)
1000 format (A2)
50 continue
print *,inserire i gradi di liberta
read *, n
100 continue
print *,immettere alfa, livello di confidenza (0.01,0.05,0.1...)
read *, alfa
condiz = .false.
delta = tmax / ndiv
do 200 jj= 1, ndiv
t
= jj * delta
prob= 1 - betai(0.5*n,0.5,n/(n+t**2))
q
= ( 1 + prob ) / 2
qmeno
= ( 1 - prob ) / 2
if (.not.condiz) then
79
2.7. TESTC2
if
200
950
2.7
( qmeno.lt. (alfa) ) then

tuno
= ( jj-1) * delta
condiz =. true.
end if
endif
if ( qmeno.lt. (alfa/2.0)) then
tdue
= ( jj-1) * delta
go to 950
end if
continue
stop aumentare tmax !!!
continue
print *,gradi di liberta
=,n
print *,livello di significativita =,alfa
print *,t critico ad una banda
=,tuno
print *,t critico a due bande
=,tdue
print *,Vuoi cambiare le variabili ?
Y/N
read 999,pausa
go to 50
end if
stop
end
TESTC2
Questo programma sostituisce le tabelle della variabile 2 e usa la subroutine GAMMQ estratta dal libro [REC 92]. Riportiamo il listato del
programma TESTC2:
13
program
testc2
character
pausa
parameter ( c2max = 200 ,ndiv = c2max * 100 )
external gammq
continue
print
*,Abbiamo
due opzioni ....................
print
*,fissiamo chi2
e troviamo la probabilita (1)
80
2.7. TESTC2
print
*,fissiamo alfa
e troviamo chi2
(2)
read
*,numero
if
( numero.eq.1 ) then
go to 11
elseif( numero.eq.2 ) then
go to 12
else
go to 13
end if
11
continue
print *,Parte per il calcolo di un integrale
print *,fra chi2 e infinito
print *,della della densita di probabilita CHI-QUADRATO

print *,con nu gradi di liberta
call
attesa
50 continue
read *, n
100 continue
print *,immettere il chi2
trovato (0.6,0.9,1.5 ,4...)
read *,chi2
prob = gammq ( 0.5 * n , 0.5 * chi2 )
print *,gradi di liberta
=,n
print *,chi2-impostato
=,chi2
print *,integrale fra chi2 e infinito =,prob
print *,

Y/N
read 999,pausa
999
format (a1)
go to 50
else
stop
end if
12
continue
print *,Parte per il calcolo del chi2 corrispondente
print *,ad un livello di significativita

alfa
print *,della della densita di probabilita CHI-QUADRATO

print *,con nu gradi di liberta
81
2.7. TESTC2
call
attesa
51 continue
read *, n
print *,immettere il livello di significativa (0.01,0.05,0.1)
read *,alfa
delta
= c2max / ndiv
if ( n .eq.1 ) then
delta = 0.00001
end if
do 995 jj = 1 , ndiv
chi2 = jj * delta
prob = gammq ( 0.5 * n , 0.5 * chi2 )
alfat = 1 - prob
if ( alfat.gt.alfa ) then
c2sin = chi2p
go to 52
end if
chi2p = chi2
995
continue
52
continue
delta
= c2max / ndiv
do 996 jj = 1 , ndiv
chi2 = jj * delta
prob = gammq ( 0.5 * n , 0.5 * chi2 )
if ( prob.lt.alfa ) then
chi2d = chi2p
go to 54
end if
chi2p = chi2
996
continue
54
continue
print *,chi2 a destra
=,chi2d
print *,chi2 a sinistra
=,c2sin
print *,gradi di liberta =,n
print *,alfa
=,alfa
Y/N
read 999,pausa
82
2.7. TESTC2
go to 51
else
stop
end if
end
83
2.7. TESTC2
84
Capitolo 3
Probabilit`
a e statistica
Adesso cerchiamo di capire come sono scritte le varie subroutine che
abbiamo usato in maniera nascosta perchè inserite nel link con le librerie
del libro [REC 92] che sono scritte in FORTRAN-77 standard.
3.1
Gamma
La funzione gamma è definita dall integrale

(z) =
tz1 et dt .
(3.1)
Quando l argomento z è un intero, la funzione gamma diventa il fattoriale dell argomento meno uno:
n! = (n + 1) .
(3.2)
Esistono vari metodi per calcolare la funzione gamma e sembra che

quello migliore sia quello derivato da Lanczos. Riportiamo adesso la
FUNCTION GAMMLN che dato l argomento xx ritorna ln ( (xx)):
FUNCTION gammln(xx)
REAL gammln,xx
INTEGER j
DOUBLE PRECISION ser,stp,tmp,x,y,cof(6)
SAVE cof,stp
DATA cof,stp/76.18009172947146d0,-86.50532032941677d0,
*24.01409824083091d0,-1.231739572450155d0,.1208650973866179d-2,
85
3.2. FATTORIALE
11
3.2
` E STATISTICA
CAPITOLO 3. PROBABILITA
*-.5395239384953d-5,2.5066282746310005d0/
x=xx
y=x
tmp=x+5.5d0
tmp=(x+0.5d0)*log(tmp)-tmp
ser=1.000000000190015d0
do 11 j=1,6
y=y+1.d0
ser=ser+cof(j)/y
continue
gammln=tmp+log(stp*ser/x)
return
END
Fattoriale
Riportiamo la FUNCTION che calcola il fattoriale di n distinguendo

fra i vari valori e alla fine chiamando la funzione gamma:
CU
11
FUNCTION factrl(n)
INTEGER n
REAL factrl
USES gammln
INTEGER j,ntop
REAL a(33),gammln
SAVE ntop,a
DATA ntop,a(1)/0,1./
if (n.lt.0) then
pause negative factorial in factrl
else if (n.le.ntop) then
factrl=a(n+1)
else if (n.le.32) then
do 11 j=ntop+1,n
a(j+1)=j*a(j)
continue
ntop=n
factrl=a(n+1)
else
86
` E STATISTICA
3.2. FATTORIALE
factrl=exp(gammln(n+1.))
endif
return
END
Un punto interessante è notare che che il fattoriale è giusto per
valori piccoli di n ma è approssimato se passiamo come vedremo adesso
al logaritmo del fattoriale. Per quanto riguarda il coefficiente binomiale
dobbiamo invece dobbiamo passare ai logaritmi per evitare gli overflow.
Ricordiamo che il coefficiente binomiale vale:
!
n
n!
=
k!(n k)!
k
0kn ,
(3.3)
e possiamo introdurre la FUNCTION BICO che calcola il suddetto

coefficiente:
CU
FUNCTION bico(n,k)
INTEGER k,n
REAL bico
USES factln
REAL factln
bico=nint(exp(factln(n)-factln(k)-factln(n-k)))
return
END
la quale adopera il logaritmo del fattoriale:
CU
FUNCTION factln(n)
INTEGER n
REAL factln
USES gammln
REAL a(100),gammln
SAVE a
DATA a/100*-1./
if (n.lt.0) pause negative factorial in factln
if (n.le.99) then
if (a(n+1).lt.0.) a(n+1)=gammln(n+1.)
factln=a(n+1)
else
87
` E STATISTICA
3.3. FUNZIONE BETA
factln=gammln(n+1.)
endif
return
END
3.3
Funzione beta
Passando dagli interi al continuo arriviamo alla funzione beta che cos`
definiamo
B(z, w) = B(w, z) =
Z 1
tz1 (1 t)w1 dt ,
(3.4)
questa è collegata alla funzione gamma dalla relazione

B(z, w) =
(z)(w)
(z + w)
(3.5)
che è facilmente implementata tramite la FUNCTION beta
CU
3.4
FUNCTION beta(z,w)
REAL beta,w,z
USES gammln
REAL gammln
beta=exp(gammln(z)+gammln(w)-gammln(z+w))
return
END
Gamma incompleta
La funzione gamma incompleta è definita come

P (a, x)
(a, x)
1 Z x a1 t
t e dt (a > 0) .
(a)
(a) 0
(3.6)
Essa ha come limiti

P (a, 0) = 0 e P (a, ) = 1 .
88
(3.7)
` E STATISTICA3.4. GAMMA INCOMPLETA

Il complemento di P (a,x) è anche chiamata in maniera confusa funzione
gamma incompleta
1 Z a1 t
(a, x)
t e dt (a > 0) ,
Q(a, x) 1 P (a, x)
(a)
(a) x
(3.8)
ed ha i seguenti valori limiti
Q(a, 0) = 1 e Q(a, ) = 0 .
(3.9)
La notazione P(a,x),(a, x) e (a, x) sono standard; la notazione Q

(a,x) la useremo solo in questo contesto. A questo punto riportiamo le
FUNCTION
che
ritornano
P(a,x)
e
Q (a,x ) usando la extra lettera p e q dopo gamm:
CU
CU
FUNCTION gammp(a,x)
REAL a,gammp,x
USES gcf,gser
REAL gammcf,gamser,gln
if(x.lt.0..or.a.le.0.)pause bad arguments in gammp
if(x.lt.a+1.)then
call gser(gamser,a,x,gln)
gammp=gamser
else
call gcf(gammcf,a,x,gln)
gammp=1.-gammcf
endif
return
END
FUNCTION gammq(a,x)
REAL a,gammq,x
USES gcf,gser
REAL gammcf,gamser,gln
if(x.lt.0..or.a.le.0.)pause bad arguments in gammq
if(x.lt.a+1.)then
call gser(gamser,a,x,gln)
gammq=1.-gamser
else
call gcf(gammcf,a,x,gln)
89
` E STATISTICA
3.4. GAMMA INCOMPLETACAPITOLO 3. PROBABILITA
gammq=gammcf
endif
return
END
L argomento gln è dato tramite serie e procedura delle frazioni
continue:
CU
11
1
SUBROUTINE gser(gamser,a,x,gln)
INTEGER ITMAX
REAL a,gamser,gln,x,EPS
PARAMETER (ITMAX=100,EPS=3.e-7)
USES gammln
INTEGER n
REAL ap,del,sum,gammln
gln=gammln(a)
if(x.le.0.)then
if(x.lt.0.)pause x < 0 in gser
gamser=0.
return
endif
ap=a
sum=1./a
del=sum
do 11 n=1,ITMAX
ap=ap+1.
del=del*x/ap
sum=sum+del
if(abs(del).lt.abs(sum)*EPS)goto 1
continue
pause a too large, ITMAX too small in gser
gamser=sum*exp(-x+a*log(x)-gln)
return
END
SUBROUTINE gcf(gammcf,a,x,gln)
INTEGER ITMAX
REAL a,gammcf,gln,x,EPS,FPMIN
PARAMETER (ITMAX=100,EPS=3.e-7,FPMIN=1.e-30)
90
` E STATISTICA
CU
11
1
3.5
3.5. FUNZIONE ERRORI
USES gammln
INTEGER i
REAL an,b,c,d,del,h,gammln
gln=gammln(a)
b=x+1.-a
c=1./FPMIN
d=1./b
h=d
do 11 i=1,ITMAX
an=-i*(i-a)
b=b+2.
d=an*d+b
if(abs(d).lt.FPMIN)d=FPMIN
c=b+an/c
if(abs(c).lt.FPMIN)c=FPMIN
d=1./d
del=d*c
h=h*del
if(abs(del-1.).lt.EPS)goto 1
continue
pause a too large, ITMAX too small in gcf
gammcf=exp(-x+a*log(x)-gln)*h
return
END
Funzione errori
La funzione degli errori e la funzione degli errori complementari sono

casi speciali della funzione gamma incompleta e sono quindi ottenute
dalle procedure summenzionate. Sono cos` definite
2 Z x t2
e
dt ,
erf (x) =
0
(3.10)
2 Z t2
erf c(x) 1 erf (x) =
e
dt .
(3.11)
x
Esse sono legate alle funzioni gamma incomplete dalle relazioni:
1
erf (x) = P ( , x2 ) (x 0) ,
2
91
(3.12)
3.6. DISTRIBUZIONI
` E STATISTICA
1
erf c(x) = Q( , x2 ) (x 0) .
2
Quindi otteniamo facilmente le FUNCTION ERF e ERFC
CU
CU
3.6
(3.13)
FUNCTION erf(x)
REAL erf,x
USES gammp
REAL gammp
if(x.lt.0.)then
erf=-gammp(.5,x**2)
else
erf=gammp(.5,x**2)
endif
return
END
FUNCTION erfc(x)
REAL erfc,x
USES gammp,gammq
REAL gammp,gammq
if(x.lt.0.)then
erfc=1.+gammp(.5,x**2)
else
erfc=gammq(.5,x**2)
endif
return
END
Distribuzioni
Analizziamo ora alcune delle distribuzioni di probabilità pi`

u note.
3.6.1
Distribuzione del chiquadro
P (2 |) è definita come la probabilità che il il chi-quadro osservato in

un modello corretto sia minore di un certo valore 2 . Il suo complemento Q (2 |) è la probabilità che il chi-quadro osservato ecceda il
valore 2 tramite chance anche per un modello corretto. In ambedue
92
` E STATISTICA
3.6. DISTRIBUZIONI
i casi è un intero, il numero di gradi di libertà del sistema. Queste

funzioni sono cos` collegate alle funzioni gamma incomplete:
P (2 |) =
Q(2 |) =
3.6.2
2
=
2 2
2
=
2 2
2
gammp ( ,
2 2
2

gammq ( ,
.
2 2
(3.14)
(3.15)
Distribuzione Beta incompleta
La funzione beta incompleta è definita come

Ix (a, b)
Bx (a, b)
1 Z x a1
t (1 t)b1 dt (a, b > 0) . (3.16)

B(a, b)
B(a, b) 0
Questa funzione ha come valori limite:

I0 (a, b) = 0 I1 (a, b) = 1 ,
(3.17)
e vale la relazione di simmetria

Ix (a, b) = 1 I1x (b, a) .
(3.18)
La funzione beta incompleta viene implementata attraverso la FUNCTION BETAI:
CU
FUNCTION betai(a,b,x)
REAL betai,a,b,x
USES betacf,gammln
REAL bt,betacf,gammln
if(x.lt.0..or.x.gt.1.)pause bad argument x in betai
if(x.eq.0..or.x.eq.1.)then
bt=0.
else
bt=exp(gammln(a+b)-gammln(a)-gammln(b)+a*log(x)+b*log(1.-x))
endif
if(x.lt.(a+1.)/(a+b+2.))then
betai=bt*betacf(a,b,x)/a
return
else
betai=1.-bt*betacf(b,a,1.-x)/b
return
endif
END
93
3.6. DISTRIBUZIONI
` E STATISTICA
la quale richiede una routine per valutare la frazione continua:
11
1
FUNCTION betacf(a,b,x)
INTEGER MAXIT
REAL betacf,a,b,x,EPS,FPMIN
PARAMETER (MAXIT=100,EPS=3.e-7,FPMIN=1.e-30)
INTEGER m,m2
REAL aa,c,d,del,h,qab,qam,qap
qab=a+b
qap=a+1.
qam=a-1.
c=1.
d=1.-qab*x/qap
d=1./d
h=d
do 11 m=1,MAXIT
m2=2*m
aa=m*(b-m)*x/((qam+m2)*(a+m2))
d=1.+aa*d
c=1.+aa/c
d=1./d
h=h*d*c
aa=-(a+m)*(qab+m)*x/((a+m2)*(qap+m2))
d=1.+aa*d
c=1.+aa/c
d=1./d
del=d*c
h=h*del
if(abs(del-1.).lt.EPS)goto 1
continue
pause a or b too big, or MAXIT too small in betacf
betacf=h
return
END
94
` E STATISTICA
3.6.3
3.7. NUMERI RANDOM
Distribuzione di Student
La distribuzione di Student, denotata con A(t|), è utile in parecchi

contesti di probabilità, ed in particolare quando si tratta di decidere se
due campioni hanno la stessa media. A(t|) è la probabilità, per gradi
di libertà, che una certa statistica t (misurando la differenza osservata
fra medie) sia minore del valore osservato nell ipotesi che le medie
siano uguali.Due medie sono significativamente differenti se ad esempio
A(t|) > 0.99. In altre parole, 1- A(t|) è il livello di significatività per
il quale l ipotesi che le medie siano uguali è scartata. La definizione
matematica della funzione è
1+
Z t
x2
1
2 dx .
1+
A(t|) = 1/2 1
B( 2 , 2 ) t
(3.19)
I valori limite sono

A(0|) = 0 A(|) = 1 .
(3.20)
A(t|) è legata alla funzione beta incompleta Ix (a,b) dalla relazione:
A(t|) = 1 I +t
2
1
,
2 2
(3.21)
e quindi adottiamo la funzione betai che abbiamo prima definito.
3.7
Numeri random
Un generatore uniforme è un algoritmo capace di generare dei numeri

senza una legge apparente fra 0 ed 1 mentre se vogliamo ottenere numeri estratti ad esempio da una distribuzione gaussiana caratterizzata
da una certa media e distribuzione standard dobbiamo partire da un
generatore uniforme e poi modificarlo opportunamente.
3.7.1
Generatori di sistema
Quasi tutti i linguaggi di programmazione contengono una subroutine che con l indimenticabile nome RAN produce una serie di numeri
random:
x = ran (iseed) ,
(3.22)
95
3.7. NUMERI RANDOM
` E STATISTICA
All inizio si fissa come primo passo un iseed molto grande e poi si
procede alle chiamate seguenti senza pi`
u modificare iseed. Cambiando
iseed si cambia la sequenza mentre chiamate successive con lo stesso
iseed producono sequenze uguali.
Bisogna però fare attenzione a questi generatori di sistema perchè
quasi sempre sono dei generatori lineari congruenti che generano delle
sequenze di interi I1 , I2 , I3 , ognuno fra 0 ed m-1 ( un numero grande )
attraverso la relazione ricorsiva
Ij+1 = aIj + c (mod m) ,
(3.23)
dove m è chiamato modulo, a moltiplicatore e c incremento. Questa ricorrenza si ripeterà eventualmente con un periodo che non è pi`
u grande
di m. Se m, a, c sono scelti in maniera appropriata allora il periodo
sarà massimo ovverosia di lunghezza m. In questo caso tutti gli interi
fra 0 ed m-1 saranno scelti. La sequenza parte esattamente da questo
punto. Il numero reale di ritorno compreso fra 0 ed 1 è generalmente
Ij+1 /m , cosicchè è generalmente minore di 1 ( eccetto che una volta
in m chiamate ). Il metodo lineare congruente ha il vantaggio di essere
molto veloce richiedendo solamente poche righe per chiamata e quindi
è di uso universale. Ha lo svantaggio di non essere libero da correlazioni sequenziali nelle chiamate successive. Se k numeri random sono
chiamati a plottare dei punti in uno spazio k-dimensionale ( con ogni
coordinata compresa fra 0 ed 1 ), allora i punti non tendono a coprire
uniformemente lo spazio ma piuttosto a distribuirsi su (k-1) piani. Ci
saranno almeno circa m1/k piani e se le costanti m, a e c non sono scelte
esattamente saranno meno di quelli. Il numero m è usualmente vicino al
pi`
u largo intero rappresentabile 232 . Cosicchè ad esempio il numero
di piani sui quali triple di punti giacciono in uno spazio tridimensionale
è usualmente non pi`
u grande della radice cubica di 232 , circa 1600.
3.7.2
Generatore Random - portatile
Tutto sommato possiamo adoperare il semplice algoritmo moltiplicativo

Ij+1 = aIj
(mod m) ,
(3.24)
se il moltiplicatore a e il modulo m sono scelti con attenzione. I signori

Park e Miller propongono
a = 75 = 16807 m = 231 1 .
96
(3.25)
` E STATISTICA
3.7. NUMERI RANDOM
Non è possibile implementare direttamente questo algoritmo poichè

il prodotto di a per m eccede il massimo intero possibile e quindi
dobbiamo passare attraverso una fattorizzazione approssimata di m:
m = aq + r
, q = [m/a] , r = m mod a ,
(3.26)
con le parentesi quadrate indicante la parte intera. Se r è piccolo ed in

particolare r < q, e 0 < z < m-1 può essere dimostrato che sia a ( z
mod q ) e r [ z/ q] stanno nel range 0,..., m-1 e che

az mod m =
a(z mod q) r[z/q]

se è 0;
a(z mod q) r[z/q] + m altrimenti.
(3.27)
L applicazione di questo algoritmo alle costanti summenzionate usa

i valori q =127773 e r=2836. Questo algoritmo viene implementato
attraverso la FUNCTION RAN0
FUNCTION ran0(idum)
INTEGER idum,IA,IM,IQ,IR,MASK
REAL ran0,AM
PARAMETER (IA=16807,IM=2147483647,AM=1./IM,IQ=127773,IR=2836,
*MASK=123459876)
INTEGER k
idum=ieor(idum,MASK)
k=idum/IQ
idum=IA*(idum-k*IQ)-IR*k
if (idum.lt.0) idum=idum+IM
ran0=AM*idum
idum=ieor(idum,MASK)
return
END
Il periodo di ran0 è 231 -1 2.0109 . Una peculiarità e chè il valore 0
non è mai raggiunto al primo tentativo.
3.7.3
Generatore di interi
Il problema consiste nel generare una distribuzione di numeri interi con

un processo random fra un numero IMIN e IMAX, frontiere comprese.
Il problema è di facile soluzione e consiste nel moltiplicare il numero
reale random compreso fra 0 ed 1 per = IMAX - IMIN +1, dove
97
3.7. NUMERI RANDOM
` E STATISTICA
l addizione di uno significa che vogliamo anche gli interi sulla frontiera.
L implementazione avviene tramite la FUNCTION G05DYFZAN che
prende il nome dal tentativo di simulare una routine delle NAG.
function g05dyfzan (ilower,iupper,idum)
integer ilower ,iupper,iscelto,idum,g05dyfzan
external ran1
real
ran1
delta
=
iupper - ilower + 1.0
iscelto
=
int ( ran0 (idum) * delta )
g05dyfzan = ilower + iscelto
if (g05dyfzan .lt. ilower ) stop errore g05dyfzan
if (g05dyfzan .gt. iupper ) stop errore g05dyfzan
return
end
3.7.4
Distribuzione esponenziale
Nella sezione precedente, abbiamo imparato a generare dei numeri random con una distribuzione di probabilità uniforme, cosicchè la probabilità di generare un numero compreso fra x e x + dx, denotata con
p(x)dx, è data da

p(x)dx =
dx, e 0 < x<1;

0,
altrimenti.
(3.28)
La distribuzione è ovviamente normalizzata che significa:

Z
p(x)dx = 1 .
(3.29)
Supponiamo adesso di generare una variabile uniforme x. La distribuzione di probabilità di y, denotata p(y)dy, è determinata dalla legge
fondamentale per le trasformazioni di probabilità, che è semplicemente
|p(y)dy| = |p(x)dx| ,
(3.30)
oppure
p(y) = p(x)|
98
dx
| .
dy
(3.31)
piccolo
grande
` E STATISTICA
3.7. NUMERI RANDOM
Assumiamo ora che y (x) - ln (x), e che p( x) è dato per una

distribuzione uniforme. Avremo allora
p(y)dy = |
dx
|dy = ey dy
dy
(3.32)
che è distribuita esponenzialmente. Questa distribuzione occorre frequentemente nei problemi reali, ad esempio come tempo di attesa fra
eventi nei fenomeni governati dalla distribuzione di Poisson. Potete anche notare che la quantità y ha la distribuzione di probabilità ey . La
implementazione pratica avviene attraverso la FUNCTION EXPDEV.
CU
1
3.7.5
FUNCTION expdev(idum)
INTEGER idum
REAL expdev
USES ran1
REAL dum,ran1
dum=ran1(idum)
if(dum.eq.0.)goto 1
expdev=-log(dum)
return
END
Distribuzione Gaussiana
I metodi di trasformazione possono essere generalizzati a pi`

u di una
dimensione. Se x1 , x2 , x3 ,.... sono delle variabili random con una probabilità di distribuzione congiunta p ( x1 , x2 , x3 ,..... )dx1 , dx2 ,dx3 ...dxn
e y1 ,y2 ,.....yn sono funzioni delle x allora la probabilità congiunta delle
y vale:
(x1 , x2 , ....xn )
|dy1 , dy2 , .....dyn
(y1 , y2 , ....yn )
(3.33)
dove |(......)/(....)| è il determinante Jacobiano delle x rispetto alle
y. Un esempio importante della formula suddetta è il metodo di BoxMuller per generare una distribuzione Gaussiana:
p(y1 , y2 , ....yn )dy1 dy2 ...dyn = p(x1 , x2 , ...xn )|
1 y2
p(y)dy = e 2 dy
2
99
(3.34)
3.7. NUMERI RANDOM
` E STATISTICA
Consideriamo adesso la trasformazione fra due distribuzioni uniformi

su (0,1),x1 ,x2 e le due quantità y1 ,y2 :
y1 =
y2 =
2ln x1 cos(2x2 ) ,
(3.35)
2ln x1 sin(2x2 ) .
(3.36)
Oppure possiamo scrivere:

x1 = exp[
1 2
(y + y22 )] ,
2 1
y2
1
arctan
.
2
y1
Adesso il Jacobiano può essere facilmente calcolato come:
x2 = exp
h 1
i h 1
i
(x1 , x2 )
2
2
=
ey1 /2
ey2 /2 .
(y1 , y2 )
2
2
(3.37)
(3.38)
(3.39)
Abbiamo il prodotto delle funzioni y1 e y2 e quindi y è distribuita secondo una distribuzione normale. Un ulteriore trucco consiste nel prendere
v1 e v2 come ordinata ed ascissa di un punto random dentro il cerchio
unitario intorno all origine. La somma dei loro quadrati R2 v12 +
v22 è un generatore uniforme che può essere usato per x1 mentre l angolo che (v1 , v2 ) definisce rispetto all asse v1 può servire come angolo
random 2x
è chè seno e coseno possono essere scritti
2 . Il vantaggio
2
2
come v1 / R e v2 / R e quindi vengono eliminate le chiamate trigonometriche. L implementazione pratica di questo algoritmo avviene
attraverso la FUNCTION GASDEV.
CU
FUNCTION gasdev(idum)
INTEGER idum
REAL gasdev
USES ran1
INTEGER iset
REAL fac,gset,rsq,v1,v2,ran1
SAVE iset,gset
DATA iset/0/
if (iset.eq.0) then
v1=2.*ran1(idum)-1.
v2=2.*ran1(idum)-1.
100
` E STATISTICA
3.8. MOMENTI
rsq=v1**2+v2**2
if(rsq.ge.1..or.rsq.eq.0.)goto 1
fac=sqrt(-2.*log(rsq)/rsq)
gset=v1*fac
gasdev=v2*fac
iset=1
else
gasdev=gset
iset=0
endif
return
END
3.8
Momenti
Se gli elementi di un campione hanno la tendenza a raggrupparsi attorno

ad un valore particolare può essere utile rappresentare l insieme da
pochi numeri che sono i momenti; il pi`
u importante è il valor medio,
x=
N
1 X
xj
N j=1
(3.40)
che stima il valore centrale. Un altro importante valore è la varianza

empirica
N
1 X
s2 =
(xj x)2 ,
(3.41)
N 1 j=1
collegata ovviamente alla deviazione standard empirica
s = s2 .
(3.42)
In alcuni casi, tipo distribuzione di Lorentz, la deviazione standard non

esiste perchè tende ad infinito; bisogna allora ricorrere ad uno stimatore
pi`
u robusto che è la deviazione assoluta
N
1 X
|xj x| .
ADEV (x1 .......xN ) =
N j=1
(3.43)
Questa definizione è stata poco adoperata dagli statistici per il fatto

che essendo un valore assoluto i teoremi sono difficilmente provabili.
101
` E STATISTICA
3.8. MOMENTI
Abbiamo poi i momenti di ordine superiore che sono in realtà poco

usati; sono in genere numeri adimensionali mentre ricordiamo che il valor medio e deviazione standard empirica sono dimensionali. Abbiamo
quindi che la asimmetria è cos` definita
skew(x1 ....xN ) =
N h
1 X
x j x i3
N j=1
s
(3.44)
dove s è la deviazione standard empirica. Un valore positivo della

asimmetria significa che abbiamo una coda che si estende verso i valori positivi e negativo viceversa. Un altro parametro importante è la
curtosi
N h
n1 X
xj x i 4 o
3 .
(3.45)
Kurt(x1 ....xN ) =
N j=1
s
Ricordiamo che questo parametro nel caso di una distribuzione Gaussiana vale 0. Una maniera per calcolare la varianza che minimizza gli
errori di arrotondamento è l algoritmo a due passi: prima il calcolo di
x e poi quello di s2
s2 (x1 ....xN ) =
N
N
i2 o
1 hX
1 nX
.
(xj x)2
(xj x)
N 1 j=1
N j=1
(3.46)
La seconda somma è zero nel caso in cui x è esatto altrimenti corregge gli
errori di arrotondamento del primo termine. I vari momenti del campione che abbiamo testè definito sono implementati nella SUBROUTINE
MOMENT
11
SUBROUTINE moment(data,n,ave,adev,sdev,var,skew,curt)
INTEGER n
REAL adev,ave,curt,sdev,skew,var,data(n)
INTEGER j
REAL p,s,ep
if(n.le.1)pause n must be at least 2 in moment
s=0.
do 11 j=1,n
s=s+data(j)
continue
ave=s/n
adev=0.
102
` E STATISTICA
3.9. TEST DI STUDENT
var=0.
skew=0.
curt=0.
ep=0.
do 12 j=1,n
s=data(j)-ave
ep=ep+s
adev=adev+abs(s)
p=s*s
var=var+p
p=p*s
skew=skew+p
p=p*s
curt=curt+p
continue
adev=adev/n
var=(var-ep**2/n)/(n-1)
sdev=sqrt(var)
if(var.ne.0.)then
skew=skew/(n*sdev**3)
curt=curt/(n*var**2)-3.
else
pause no skew or kurtosis when zero variance in moment
endif
return
END
12
3.9
Test di Student
Sovente ci troviamo di fronte due set di dati e vogliamo capire se appartengono o no alla stessa popolazione. Quando si pensa che due distribuzioni abbiano la stessa varianza empirica ma possibilmente medie
diverse la variabile t di Student è calcolata in questa maniera
sP
sD =
iA (xi
xA )2 + iB (xi xB )2 1
1
+
,
NA + NB 2
NA NB
P
(3.47)
dove la sommatoria è estesa sui punti appartenenti ad un campione od

a un altro e NA e NB sono il numero dei punti nel primo e secondo
103
3.9. TEST DI STUDENT
` E STATISTICA
campione rispettivamente. Come secondo passaggio valutiamo t come:

t=
xA xB
sD
(3.48)
Terzo valutiamo la significatività di questo valore della t di Student con

NA + NB - 2 gradi di libertà attraverso le due formule prima introdotte
e la SUBROUTINE BETAI (funzione beta incompleta ). La significatività è un numero compreso fra 0 ed 1 e rappresenta la probabilità che
|t| sia cos` grande per caso, nell ipotesi che i campioni abbiano la stessa
media. Quindi un valore piccolo della significatività ( 0.05 oppure 0.01
) significa che la differenza osservata è molto significativa. Abbiamo
quindi la SUBROUTINE TTEST dove data1 (1:n1 ) e data2 (1:n2 )
sono i due vettori contenenti i dati dei due campioni.
CU
SUBROUTINE ttest(data1,n1,data2,n2,t,prob)
INTEGER n1,n2
REAL prob,t,data1(n1),data2(n2)
USES avevar,betai
REAL ave1,ave2,df,var,var1,var2,betai
call avevar(data1,n1,ave1,var1)
call avevar(data2,n2,ave2,var2)
df=n1+n2-2
var=((n1-1)*var1+(n2-1)*var2)/df
t=(ave1-ave2)/sqrt(var*(1./n1+1./n2))
prob=betai(0.5*df,0.5,df/(df+t**2))
return
END
che fa uso della SUBROUTINE AVEVAR
11
SUBROUTINE avevar(data,n,ave,var)
INTEGER n
REAL ave,var,data(n)
INTEGER j
REAL s,ep
ave=0.0
do 11 j=1,n
ave=ave+data(j)
continue
ave=ave/n
104
` E STATISTICA
12
3.10
3.10. FIT CON RETTA
var=0.0
ep=0.0
do 12 j=1,n
s=data(j)-ave
ep=ep+s
var=var+s*s
continue
var=(var-ep**2/n)/(n-1)
return
END
Fit con retta
Supponiamo di avere una serie N di punti (xi ,yi ) e di volerli fittare con
una retta
y = a + bx .
(3.49)
La misura di quanto il modello aderisce alla realtà è rappresentata dalla
funzione chi-quadro:
2 (a, b) =
N
X
yi
j=1
a bxi 2
si
(3.50)
Annullando le derivate prime rispetto ad a e b troviamo la condizione di minimo del chi-quadro. Può essere utile introdurre le sequenti
sommatorie:
S
N
X
1
2
i=1 si
Sxx
Sx
i=1
N
X
x2i
i=1
N
X
xi
s2i
Sy
s2i
Sxy
N
X
yi
i=1
N
X
xi y i
i=1
s2i
(3.51)
s2i
(3.52)
Ricordando che il determinante dei coefficienti vale:

SSxx (Sx )2
(3.53)
troviamo facilmente dalla teoria dei minimi quadrati che

a=
Sy Sxx Sx Sxy
b=
S Sxy Sx Sy
105
(3.54)
3.10. FIT CON RETTA
` E STATISTICA
Ci restano ancora gli errori su a e b e dalla teoria della propagazione

degli errori otteniamo:
s2a = Sxx / s2b = S/ .
(3.55)
Una stima della bontà del fit è data dalla probabilità Q che il valore
del chi-quadro trovato sia casuale è
Q = gammq (
N 2 2
, ) .
2
2
(3.56)
Ricordiamo che GAMMQ è la nostra FUNCTION per la funzione gamma incompleta Q(a,x). Se q è pi`
u grande di 0.1 il fit è accettabile. Se
è pi`
u grande di 0.001 il fit può essere accettabile se gli errori non sono
distribuiti in maniera normale e sono stati sottostimati. Se q è minore
di 0.001 allora il modello o la procedura di stima degli errori sono sbagliati. L implementazione pratica di queste formule avviene attraverso
la SUBROUTINE FIT dove in input abbiamo:
ndata = numero di punti del campione
x (1:ndata)= vettore delle x
y (1:ndata)= vettore delle y
sig (1:ndata)= vettore degli errori sulle y
mwt = 0 allora applichiamo le formule senza errori
In output abbiamo invece
a,b = parametri della retta
siga,sigb= errori sui parametri a e b
chi2= chi-quadro finale
q= parametro di bontà del fit. Se mwt = 0 allora q=1
CU
SUBROUTINE fit(x,y,ndata,sig,mwt,a,b,siga,sigb,chi2,q)
INTEGER mwt,ndata
REAL a,b,chi2,q,siga,sigb,sig(ndata),x(ndata),y(ndata)
USES gammq
INTEGER i
REAL sigdat,ss,st2,sx,sxoss,sy,t,wt,gammq
sx=0.
sy=0.
st2=0.
b=0.
if(mwt.ne.0) then
106
` E STATISTICA
11
12
13
14
15
ss=0.
do 11 i=1,ndata
wt=1./(sig(i)**2)
ss=ss+wt
sx=sx+x(i)*wt
sy=sy+y(i)*wt
continue
else
do 12 i=1,ndata
sx=sx+x(i)
sy=sy+y(i)
continue
ss=float(ndata)
endif
sxoss=sx/ss
if(mwt.ne.0) then
do 13 i=1,ndata
t=(x(i)-sxoss)/sig(i)
st2=st2+t*t
b=b+t*y(i)/sig(i)
continue
else
do 14 i=1,ndata
t=x(i)-sxoss
st2=st2+t*t
b=b+t*y(i)
continue
endif
b=b/st2
a=(sy-sx*b)/ss
siga=sqrt((1.+sx*sx/(ss*st2))/ss)
sigb=sqrt(1./st2)
chi2=0.
if(mwt.eq.0) then
do 15 i=1,ndata
chi2=chi2+(y(i)-a-b*x(i))**2
continue
q=1.
sigdat=sqrt(chi2/(ndata-2))
107
3.10. FIT CON RETTA
3.10. FIT CON RETTA
16
` E STATISTICA
siga=siga*sigdat
sigb=sigb*sigdat
else
do 16 i=1,ndata
chi2=chi2+((y(i)-a-b*x(i))/sig(i))**2
continue
q=gammq(0.5*(ndata-2),0.5*chi2)
endif
return
END
108
Capitolo 4
I frattali
In questi ultimi anni grazie all avvento dei calcolatori un capitolo che
sembrava dimenticato della matematica ha avuto una evoluzione impressionante ed un numero molto alto di libri sui frattali ed affini è
stato scritto. Diciamo grosso modo che possiamo dividere in parti il
problema:
1. Enunciazione del processo; spesso un algoritmo iterativo.
2. Sviluppo di uno pseudo-codice che indica le operazioni da svolgere
indipendentemente dal linguaggio adoperato.
3. Traduzione pratica dello pseudo-codice in linguaggio di programmazione
4. Uso di uno o pi`
u pacchetti grafici che permettono l uscita finale
su terminale grafico, laser, etc...
Passiamo ora in rassegna alcuni di questi algoritmi seguendo una
specie di ordine cronologico.
4.1
Henon mapping
All inizio degli anni 60 Michel Henon all Osservatorio di Nizza studiando le orbite delle stelle in una galassia si rese conto che lievi modifiche
nei parametri iniziali portavano ad orbite irregolari. Prese quindi piede
il concetto di comportamento caotico nelle orbite stellari o planetarie.
109
4.1. HENON MAPPING
CAPITOLO 4. I FRATTALI
Le curve di Henon non sono le classiche ellissi Newtoniane che gli astronomi usano da secoli. Nell universo vero l influenza di altri pianeti o
di altre stelle portano a comportamenti poco prevedibili. Il modello di
Henon che si sviluppa secondo il seguente mapping:
xn+1 = yn ax2n
(4.1)
yn+1 = bxn ,
(4.2)
con a = 1.4 e b = 0.3 ,
(4.3)
dice che le orbite planetarie possono essere non periodiche ed estremamente sensitive anche alla pi`
u piccola influenza gravitazionale. Per
maggiori dettagli sull attrattore di Henon consultare il libro [Ol 92] . A
differenza dei modelli lineari che sembrano capaci di predirre il cammino
esatto dei corpi celesti per l eternità, gli attrattori strani offrono la possibilità di orbite stabili per molto tempo con un susseguente improvviso
cambio di traiettoria vedi figura 4.1 . Riportiamo la SUBROUTINE
HENON10 che implementa l attrattore di Henon.
SUBROUTINE HENON10 (xx,yy,max,kounter,n)
implicit REAL * 4 (A-H,O-Z)
dimension xx (1:max )
dimension yy (1:max )
common /quadro / xmin,ymin,delta
xmax=xmin + delta
ymax=ymin + delta
QA=1.4E+00
Qb=0.3E+00
J=0
k=0
18 continue
QZ=1.0-QA*(QX**2.0)+QY
QY=QB*QX
QX=QZ
k=k+1
IF ((QX.GT.xmin.AND.QX.LT.xmax).and.
& (QY.GT.ymin.AND.QY.LT.ymax))then
J=J+1
xx ( J ) =
qx
yy ( J ) =
qy
110
4.1. HENON MAPPING
Figura 4.1: Tipico plot di Henon
111
4.2. FEIGENBAUM MAPPING
c fase di plot
end if
20 IF (K.LT.N) GO TO 18
kounter = j
return
END
4.2
Feigenbaum mapping
Questo mapping è collegato alla crescita della popolazione che assumiamo essere x0 all inizio. La relazione ricorsiva già adottata da Verhulst
è:
xn+1 = 4xn (1 xn ) ,
(4.4)
dove è un parametro di controllo che varia tra 0 ed 1. Questo mapping al variare di incomincia con una soluzione, che poi diventano
due, che poi diventano quattro, etc... Questo comportamento prende il
nome di teoria delle biforcazioni, vedi figura 4.2. Il famoso matematico
Feigenbaum riesce poi anche a calcolare un numero che rappresenta la
transizione al caos. Per maggiori dettagli sul mapping e sul numero di
Feigenbaum consultare il libro [Ol 92] oppure il libro [Ba 88].
L implementazione pratica di questo algoritmo avviene attraverso
il programma FEIGEN.
program feigen
c questo programma produce dei files di dati per calcolare lo splitting
c di Feigenbaum........................................................
implicit REAL (A-H,R-Z)
implicit real*8 (Q)
character * 1 mode,risposta
parameter
( nn = 200
)
parameter
( max= 1000
)
real* 8 fe
( 1 :max
)
real* 4 fi
( 1 :max
)
real* 4 fy
( 1:nn,1 : max )
integer *2 ify ( 1:nn
)
real* 4 fx ( 1:nn
)
mode =M
call init9 ( mode )
112
Figura 4.2: Biforcazioni di Feigenbaum
113
go to 402
400 continue
type *,Vuoi continuare Y/N ?
accept 1000,risposta
if ((risposta.eq.N).or.(risposta.eq.n)) then
go to 401
end if
1000
format (A1 )
402 continue
c qx0old ==> condizione iniziale ,ql0 ==> lambda iniziale
c qld ==> delta lamda ,npunti===>numero attrattori
c nn=divisioni in lamda
type *,inserire limite inferiore + limite superiore
accept *,ql0,qxmax
qld = qxmax - ql0
qx0old=0.5
npunti=600
delta = 1.0 / max
qxmax=ql0+qld
qymin=0.0
qymax=1.0
do 111 ii=1,nn
qx0=qx0old
ql= ql0+ii*qld/nn
k=0
j=0
n=3000
maxfe=N-npunti
18 continue
QX=4*QL*QX0*(1.0-QX0)
qx0=qx
k=k+1
if (k.gt.maxfe) then
j=j+1
fe(j)=qx
end if
20 IF (K.LT.N) GO TO 18
k=0
do 67 j=1,npunti
114
4.3. MANDELBROT-SET
if (fe(j).lt.1.0D-10) then
fe(j)=1.0Q-10
end if
67 continue
call m01apf(fe,1,npunti,k)
fi(1)=fe(1)
mm=1
do 4 k=2,npunti
diff = abs (fe (k) - fi ( mm) )
if (diff .gt . delta) then
mm=mm+1
fi(mm)=sngl ( fe(k) )
endif
4 continue
do 3 j=1,mm
fy ( ii,j ) = fi ( j )
3 continue
ify( ii )
= mm
fx ( ii )
= sngl ( ql )
111 continue
xmin = sngl ( ql0 )
xmax = sngl ( ql0 + qld )
ymin = -0.1
ymax =
1.1
call feigengraf ( fy, fx ,nn ,max,xmin,xmax,ymin,ymax,ify)
go to 400
401 continue
call donepl
stop
END
4.3
Mandelbrot-set
Sia zn = xn + i yn un numero complesso definito dalla relazione ricorsiva

zn+1 = zn2 + c ,
115
(4.5)
4.4. IMPLEMENTAZIONE DEI SET
dove c =a + i b è un altro numero complesso. Se incominciamo

il processo da z0 = 0 e e ripetiamo pi`
u volte la relazione ricorsiva
notiamo che esistono due possibilità. La prima è che il valore assoluto
di zn+1 esploda la crescere di n, la seconda è che rimanga finito a dispetto di quante volte iteriamo la relazione. Il risultato finale dipende
` quindi possibile dividere il set di
ovviamente dal valore di c usato. E
tutti i numeri complessi {c} in due gruppi in accordo al loro andamento
dopo un numero alto di iterazioni. L insieme di Mandelbrot è il gruppo
che contiene tutti i c tali che
lim | zn | = f inito .
4.4
(4.6)
Implementazione dei set
In genere il set di Mandelbrot e derivati vengono rappresentati tramite

il colore perchè in tale maniera si originano delle immagini affascinanti
e ogni volta simili ma diverse nei particolari. Per maggiori dettagli
sui vari set tipo Mandelbrot e Julia rimandiamo il lettore interessato
al libro di [PS88] . Per semplicità tratteremo solo la situazione sul
monitor di un computer. Supponiamo che il numero totale di pixels
disponibile sia ( Nx Ny ); dove Nx , ad esempio 640, sono i punti sulla
linea orizzontale e Ny , ad esempio 480,sono i punti sulla linea verticale
di un tipico schermo di P.C. Possiamo invece anche lavorare su di un
quadrato e allora il numero di pixels (quadratini) sarà ( N N ) dove
N è il numero considerato fissabile a piacimento; in questa maniera si
eliminano eventuali errori di deformazione dell area. Identifichiamo
adesso lo schermo con il piano complesso e ogni pixel o quadratino è un
punto del piano. Come al solito useremo la linea orizzontale per la parte
reale e la direzione verticale per la parte immaginaria. Per inserire un
numero complesso c =a + ib sullo schermo dobbiamo selezionare un
origine in basso a sinistra, un considerato ed il numero di pixels. Per
fini pratici dobbiamo scegliere un valore nmax come il numero massimo
di iterazioni che vogliamo eseguire; questo sarà l infinito del nostro
processo iterativo. Per generare il plot ogni numero complesso c è
soggetto ad un processo ricorsivo partendo da z0 = 0. Alla fine di ogni
iterazione il valore assoluto di zn è calcolato. Se | zn | > 2, il numero
complesso c non fa parte del set di Mandelbrot, il processo iterativo
termina e assegniamo un colore al pixel considerato secondo lo schema
seguente: sia Nesc il numero di iterazioni considerato ed Nc il numero
116
di colori a disposizione, dove probabilmente Nc < Nmax ; assoceremo al

pixel il colore Ic secondo la seguente relazione
Ic = Nesc mod Nc
(4.7)
dove Ic è un numero nel range [0, Nc ] ed ogni intero 0,1,2,.... corrisponde

ad un particolare colore tipo nero, rosso,viola .... Se il valore di zn è
ancora minore di due il processo si ripete e se dopo Nmax iterazioni
| zn | è ancora minore di due abbiamo un elemento appartenente al set
di Mandelbrot. Questo ultimo pixel può essere colorato in nero: una
tipica implementazione di questo set è riportata in figura 4.3 .
Riportiamo la subroutine UNO che implementa praticamente tramite tre do innestati il numero Nesc ( nel nostro caso NDIM ) per ogni
pixel del piano.
subroutine uno ( matrix,traspo,itraspo)
implicit real* 4 (a-h,o-z)
integer
* 2 ndim,i,j,iterations
integer
* 4 im
complex
* 8
z,imm,complex
parameter
( pixels = 600 )
parameter
( nvector = pixels * pixels)
dimension matrix
(1:nvector)
dimension traspo
(1:10)
dimension itraspo
(1:10)
parameter(imm=(0,1))
c coordinate di partenza e valore del lato
xmin
= traspo (1)
ymin
= traspo (2)
delta
= traspo (3)
npix
= itraspo(1)
iterations = itraspo (2)
npix1
= npix-1
xmax
= xmin + delta
ymax
= ymin + delta
c griglia di lavoro + numero di pixels
im
= 0
do
i= 0,npix1
cy=ymin + i*delta/npix
do j=0,npix1
117
Figura 4.3: Tipico set di Mandelbrot
118
cx=xmin+j*delta/npix
complex = cx + imm*cy
c dimensione numero complesso
z=0
ndim = 0
do while (cabs(z) .le. 2.0 .AND. ndim .LT. iterations)
z=z*z+complex
ndim=ndim+1
end do
im = im +1
matrix (im) = ndim
end do
end do
return
end
Il colore viene invece calcolato dalla subroutine DUETUTTO.
subroutine duetutto( matrix,matrix8,traspo,itraspo)
implicit real * 4 (a-h,o-z)
parameter
( npixels=800
)
parameter
( nvector = npixels*npixels)
dimension matrix
(1:nvector )
dimension matrix8
(1:nvector )
dimension traspo
(1:10)
dimension itraspo
(1:10)
a
= traspo (1)
npix
= itraspo(1)
ncol
= itraspo(3)
npix2
= npix *npix
do j = 1 , npix2
ndim = matrix ( j)
ndim = ndim -1
if (ndim.lt.64) then
matrix8 (j) = ndim
elseif (ndim.ge.64 ) then
icolor = mod ( ndim,64 )
matrix8 (j) = icolor
end if
end do
119
4.5. SET DI JULIA E DERIVATI
return
end
4.5
Set di Julia e derivati
Gli insiemi di Julia si ottengono dalla stessa relazione ricorsiva del set di
Mandelbrot e si tratta di selezionare dei punti alla frontiera del medesimo; questi punti dell altro set danno origine a successioni periodiche
dalle forme strane e bizzarre. I pixels sullo schermo del computer rappresentano ora i punti nel piano complesso per tutti i possibili valori
di z0 ed ogni insieme è caratterizzato da un valore di c. Riportiamo nella figura 4.4 il set di Julia corrispondente a c = -0.74543 + i
0.11301. Un altra relazione ricorsiva cugina di quella di Mandelbrot,
che possiamo chiamare M2 , è
zn+1 = zn3 + c ,
(4.8)
che possiamo chiamare M3 . Essa origina strutture leggermente diverse

dal suo parente di grado minore e riportiamo nella figura 4.5 un tipico
plot. Possiamo poi passare in maniera continua da M2 a M3 attraverso
la seguente relazione ricorsiva
zn = tz 3 + (1 t)z 2 + c .
(4.9)
Dove il parametro t varia con continuità fra 0 ed 1.

Sembra che alcuni valori di t siano critici e potete partire con t
=0.12595. Riportiamo in figura 4.6 un tipico plot di di questo set
regolabile.
4.6
Le trasformazioni affini
Il metodo IFS ( Iterated Function System ) permette di produrre immagini di curve frattali, foglie, nuvole, etc...
Ricordiamo che una trasformazione affine wi è data da
wi = [ xy ] = [ a bc d ] [ xy ]+[ ef ] = [ ax+ by+ ecx+ dy+ f ] .
(4.10)
120
4.6. LE TRASFORMAZIONI AFFINI
Figura 4.4: Tipico plot di Julia
121
Figura 4.5: Tipico plot M**3
122
Figura 4.6: Tipico plot regolabile
123
Tabella 4.1: Tabella dei coefficienti

w
a
b
c
d
e f
1
0
0
0
0.16 0 0
2 0.85
0.04 0.04 0.85 0 1.6
3 0.20 0.26 0.23
0.22 0 1.6
4 0.15 0.28
0.26
0.24 0 0.44
p
0.01
0.85
0.07
0.07
Inoltre ogni trasformazione è caratterizzata da una certa probabilità

di avvenire pi associata a wi . Ovviamente essendo probabilità dovremo
avere:
p1 + p2 + .....pn = 1 e pi > 0 per
i = 1, 2, ...n .
(4.11)
Riportiamo in tabella i valori dei coefficienti che permettono di ottenere

una figura caratteristica.
Per capire le componenti di queste strutture complicate possiamo
studiare il significato geometrico dei coefficienti a,b,c,d,e ed f. Per partire osserviamo che e ed f sono semplici traslazioni nelle direzioni x ed
y. Adesso scriviamo a = r cos ( ), b = -s sen ( ), c = r
` facile realizzare che è l angolo del
sen ( ) e d = s cos ( ). E
quale ruotiamo l asse x e è l angolo del quale ruotiamo y, r è fattore
per il quale sono moltiplicate le distanze lungo x ed s è il fattore per il
quale moltiplicare le distanze lungo y. Prendendo = abbiamo una
riflessione attravesrso l asse x e prendendo s negativo si origina una
riflessione attraverso l asse y. Possiamo quindi riesprimere i parametri a, b, c,d attraverso r, s, e ; continuando possiamo mettere h e
k al posto di e ed f. Per maggiori dettagli sulle trasformazioni affini
consultare il libro di [Ba 88] . Riportiamo nella figura 4.7 seguente una
tipica implementazione pratica. L implementazione pratica avviene
attraverso il programma FELCI.
program
felci
logical
* 1 prob1,prob2,prob3,prob4
real * 4 xx , yy
parameter ( nvec
= 150 000 )
124
Figura 4.7: La felce
125
parameter ( minimum = 100

)
dimension xx (1 : nvec )
dimension yy (1: nvec )
integer g05dyf
call g05cbf ( 0 )
type *,numero di punti ?
accept *,npoints
x = 0.0
y = 0.0
do j = 1, npoints
intero = g05dyf ( 1, 100 )
prob1 = intero.eq.1
prob2 = (intero.gt.1 ).and.(intero.le.86 )
prob3 = (intero.gt.86).and.(intero.le.93 )
prob4 = (intero.gt.93).and.(intero.le.100)
if
( prob1 ) then
itipo = 1
call affine ( itipo,x,y,xnew,ynew )
elseif ( prob2 ) then
itipo = 2
itipo = 3
itipo = 4
end if
if ( j.gt. minimum ) then
jvec
= jvec + 1
xx ( jvec ) = sngl ( xnew )
yy ( jvec ) = sngl ( ynew )
end if
x
= xnew
y
= ynew
end do
call affinegraf ( xx, yy , jvec ,npoints,minimum,nvec)
stop
end
126
subroutine affine ( itipo,x,y,xnew,ynew )

implicit real *8 ( a-h,o-z)
if (itipo.eq.1) then
a
= 0.
b
= 0.
c
= 0.
d
= 0.16
e
= 0.
f
= 0.
elseif (itipo.eq.2) then
a
= 0.85
b
= 0.04
c
= -0.04
d
= 0.85
e
= 0.0
f
= 1.6
a
= 0.2
b
= -0.26
c
= 0.23
d
= 0.22
e
= 0.0
f
= 1.6
a
= -0.15
b
=
0.28
c
=
0.26
d
=
0.24
e
=
0.00
f
=
0.44
end if
xnew = a * x + b * y + e
ynew = c * x + d * y + f
return
end
127
4.7. IL SISTEMA L
4.7
Il sistema L
Questo sistema è stato inventato dal botanico tedesco Lindenmayer (

vedi il libro di [PL 90]) per spiegare teoricamente le strutture ricorrenti
delle piante. Ai fini pratici possiamo sintetizzare l algoritmo mediante
il moto di una tartaruga. Lo stato della tartaruga è definito da una
tripletta ( x,y, ), dove le coordinate cartesiane ( x, y ) rappresentano
la posizione della tartaruga e l angolo indica la direzione di moto
della tartaruga. Dato l incremento d di ogni step ( possiamo porlo
uguale ad uno ) e l incremento di angolo la tartaruga risponde ai
seguenti comandi
F Si muove avanti di uno step d. Lo stato della tartaruga diventa
( x, y, ) dove x = x + d cos e y = y + d sin . Una linea
viene tracciata fra i punti (x,y) e (x,y).
f Si muove avanti di una lunghezza d senza tracciare una linea.
+ Si gira a sinistra di un angolo . Il prossimo stato della tartaruga è (x,y, + ) e quindi gli angoli crescono in senso antiorario.
- Ruota a sinistra di un angolo . Il prossimo stato della tartaruga
è (x,y, - ).
[ Congela lo stato della tartaruga. Le informazioni correnti, posizione e angolo sono memorizzate per poi essere riesumate pi`
u
avanti.
] Scongela lo stato della tartaruga. Le informazioni vengono riesumate e diventano quelle attuali della tartaruga. Non viene tirata
nessuna linea e quasi sempre la tartaruga cambia posizione.
Data una stringa iniziale w, lo stato iniziale della tartaruga con (
x0 , , y0 ,0 ) e fissati i parametri d e , tramite una o pi`
u regole di
produzione otteniamo la posizione successiva e cos` via. Il problema è
quindi di ideare una stringa iniziale e regole di trasformazione tali da
ottenere le curve volute. Riportiamo come esempio una pianta curvata
dal vento, vedi figura 4.8 .
n=4
= 22.5
w=F
128
4.7. IL SISTEMA L
Figura 4.8: Pianta e vento di tramontana
129
4.7. IL SISTEMA L
F FF-[-F+F+F]+[+F-F-F]
A questo punto ricordiamo che sono attualmente disponibili una
quarantina di curve fra frattali e piante. Questa particolare stringa
viene implementata attraverso la SUBROUTINE MAKEPIANTA3.
subroutine makepianta3 (stringa,max,it,ifine)
parameter (new = 200 000 )
character * 1 stringa ,stringanew
dimension stringa
(1:max)
dimension stringanew (1:new)
ifine = 1
stringa (1) = F
do jit =1,it
nuovo = 0
do j = 1 ,ifine
if (stringa (j).eq.F) then
nuovo
= nuovo +1
stringanew (nuovo) =F
nuovo= nuovo +1
nuovo= nuovo +1
stringanew (nuovo) =+
nuovo= nuovo +1
stringanew (nuovo) =[
nuovo= nuovo +1
nuovo= nuovo +1
nuovo = nuovo +1
stringanew (nuovo )=-
nuovo= nuovo +1
stringanew (nuovo )=F
nuovo = nuovo +1
nuovo= nuovo +1
nuovo= nuovo +1
stringanew (nuovo )=]
130
4.7. IL SISTEMA L
nuovo= nuovo +1
nuovo
= nuovo +1
stringanew (nuovo) =[
nuovo= nuovo +1
stringanew (nuovo) =-
nuovo= nuovo +1
nuovo= nuovo +1
nuovo= nuovo +1
nuovo= nuovo +1
nuovo= nuovo +1
nuovo= nuovo +1
stringanew (nuovo )=]
else
nuovo = nuovo +1
stringanew (nuovo) = stringa(j)
end if
end do
do j= 1,nuovo
stringa(j) = stringanew (j)
end do
ifine = nuovo
end do
return
end
Invece la stringa finale risultante viene decodificata attraverso la SUBROUTINE GX.
subroutine gx(stringa,max,ifine,agl,xmax,xmin,ymax,ymin,ae)
character * 1 stringa,car
dimension stringa (1:max)
dimension stackx ( 1:1000)
dimension stacky ( 1:1000)
131
4.7. IL SISTEMA L
dimension stackae ( 1:1000)

xmax = - 10.**20
xmin =
10.**20
ymax = - 10.**20
ymin =
10.**20
x = 0.
y = 0.
numero = 0
do j =1,ifine
if (x.gt.xmax ) then
xmax = x
end if
if (x.lt.xmin ) then
xmin = x
end if
if (y.gt.ymax ) then
ymax = y
end if
if (y.lt.ymin ) then
ymin = y
end if
car = stringa (j)
cccccccccccc inizio sostituzioni
if (car.eq.F) then
xnew = x + cosd ( ae )
ynew = y + sind ( ae )
x = xnew
y = ynew
end if
if (car.eq.f) then
xnew = x + cosd ( ae )
ynew = y + sind ( ae )
x = xnew
y = ynew
end if
if (x.gt.xmax ) then
xmax = x
end if
if (x.lt.xmin ) then
132
4.7. IL SISTEMA L
xmin = x
end if
if (y.gt.ymax ) then
ymax = y
end if
if (y.lt.ymin ) then
ymin = y
end if
if (car.eq.+) then
ae = ae - agl
end if
if (car.eq.-) then
ae = ae + agl
end if
if (car.eq.[) then
numero = numero + 1
stackx ( numero ) = x
stacky ( numero ) = y
stackae (numero ) = ae
end if
if (car.eq.]) then
x = stackx ( numero )
y = stacky ( numero )
ae = stackae ( numero )
numero = numero - 1
end if
ccccccccccccccc fine sostituzioni ccccccccccccccccccccccccccc
cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
end do
return
end
133
4.7. IL SISTEMA L
134
Capitolo 5
Sistemi Monte Carlo
In questi ultimi anni abbiamo assistito ad un crescente numero di simulazioni di sistemi fisici mediante modelli al calcolatore. Il campo è
enorme ed in continua evoluzione e ci limiteremo ad una scelta random di alcune topiche; ah non dimentichiamoci che il nome deriva dal
famoso casinò...
5.1
DLA
Il nome prende le iniziali da Diffusion Limited Aggregation ed è un tipico esempio di crescita/aggregazione che simula il comportamento di
colonie di batteri, esperimenti fra fluidi con viscosità diverse e scariche
elettriche nei gas. La superficie considerata viene identificata con un
lattice consistente in N N pixels. All inizio il nostro aggregato consiste in una sola particella al centro della griglia. La diffusione delle altre
particelle viene simulata da una particella che entra da uno dei quattro
lati a seconda del numero random R1 [1, 4]. La particella si muove poi
di moto random sul lattice: questo significa che ad ogni step ha quattro
possibili movimenti scelti con un processo random R2 [1, 4]. Le quattro
direzioni di movimento sono:
1. destra,
2. alto,
3. sinistra,
4. basso.
135
5.1. DLA
CAPITOLO 5. SISTEMI MONTE CARLO

Ogni volta che viene raggiunta una locazione nuova viene controllato
se uno dei quattro vicini ( di nuovo destra, alto, sinistra e basso ) è
occupato. Se risulta occupato l aggregato aumenta di una unità e il
cammino random ricomincia con un altra particella su di un altro lato
del quadrato. Se invece il punto occupato non ha vicini appartenenti
all aggregato il cammino random continua; il processo si ferma quando
viene raggiunto un punto sulla frontiera e ricomincia ovviamente con un
altra particella su di un altro lato. Si possono poi introdurre ulteriori
regole che permettono di diminuire il tempo di calcolo; in particolare
possiamo ingrandire progressivamente il lato del quadrato interno dal
quale partiamo e idem dicasi per un cuscinetto detto killing zone pi`
u
grande del quadrato delle partenze superato il quale il processo comincia
di nuovo senza aspettare di raggiungere le frontiere naturali del lattice.
Per maggiori dettagli sulla teoria della DLA consultare il libro [Vi 92].
Riportiamo nella figura 5.1 un tipico esempio di crescita su di un lattice
con 500 pixels.
Questo algoritmo viene implementato attraverso la SUBROUTINE
WO:
subroutine wo(griglia ,ndim ,l_dist,k_dist,m_dist,n_max,n_vero)
implicit
real * 4 ( a-h,o-z)
logical * 1
griglia , occupato
external g05dyfzan
integer
g05dyfzan
dimension griglia(ndim,ndim)
dimension ivicinox
( 1 : 4 )
dimension ivicinoy
( 1 : 4 )
dimension iarrivo
( 1 : 4 )
c zero the lattice and mark the center as occupied
do i=1,ndim
do j=1,ndim
griglia(j,i)=.false.
end do
end do
npts=1
mid=ndim/2
griglia(mid,mid)=.true.
c define initial launching and kill boundaries
lx_min=mid-l_dist
136
Figura 5.1: Tipico esempio di DLA
137
5.1. DLA
5.1. DLA

lx_max=mid+l_dist
ly_min=mid-l_dist
ly_max=mid+l_dist
kx_min=lx_min-k_dist
kx_max=lx_max+k_dist
ky_min=ly_min-k_dist
ky_max=ly_max+k_dist
c set an artificial occupation boundary at the start
mx_min=mid-m_dist
mx_max=mid+m_dist
my_min=mid-m_dist
my_max=mid+m_dist
cc
cccc
abbiamo
fissato le zone di lancio
cc
e quelle di killing
idum
= 33333
kgen
= 77777
kdir
= 55555
nn
= 1
ilato = 0
itotale= 0
ccc
inizio zona di lancio
40 continue
ilato
= g05dyfzan ( 1 , 4 ,idum )
itotale = itotale
+ 1
c
ilato = ilato + 1
c
if (ilato.gt.4) then
c
ilato = 1
c
end if
c
c
lx_min,ly_max
2
lx_max,ly_max
c
------------------------c
|
|
c
|
|
c
| zona
di
|
c
1 |
| 3
c
|
lancio
|
c
|
|
138

c
c
c
------------------------lx_min,ly_min
4
lx_max,ly_min
if ( ilato.eq. 1 ) then
ix =
lx_min
iy =
g05dyfzan ( ly_min,ly_max,kgen )
elseif ( ilato.eq. 2 ) then
ix =
g05dyfzan ( lx_min,lx_max,kgen )
iy =
ly_max
ix =
lx_max
iy =
g05dyfzan ( ly_min,ly_max,kgen )
ix =
g05dyfzan ( lx_min,lx_max,kgen )
iy =
ly_min
end if
c adesso impostiamo la direzione di moto
100 continue
idir
= g05dyfzan ( 1 , 4 , kdir )
c
c
c
3
c
|
c
|
c
|
c
4 ------ * ------ 2
c
|
c
|
c
|
c
1
c
if (idir .eq . 1 ) then ! si muove giu in basso
ix
= ix
iy
= iy - 1
elseif ( idir.eq.2 ) then ! si muove a destra
ix
= ix +1
iy
= iy
139
5.1. DLA
5.1. DLA

elseif
ix
iy
elseif
ix
iy
c
cc
c
c
c
c
c
adesso
( idir.eq.3 ) then ! si muove in alto

= ix
= iy + 1
( idir.eq.4 ) then ! si muove a sinistra
= ix -1
= iy
end if
ci siamo mossi !!!!!
adesso facciamo un controllo sulla killing zone

se abbiamo raggiunto la frontiera
ricominciamo
dalla zona di lancio
if
((iy.eq.ky_min).or.(iy.eq.ky_max)) then
! limite alto
! e
basso
go to 40
elseif ((ix.eq.kx_min).or.(ix.eq.kx_max))then ! limite destro
! e sinistro
go to 40
end if
c
cc
c
c
c
c
c
c
c
c
costruzione dei quattro vicini
-------------
ivicinox (1)
ivicinoy (1)
primo vicino
ivicinox (2)
140
=
=
ix
iy
- 1
ix
+ 1

ivicinoy
secondo vicino
ivicinox
ivicinoy
c terzo vicino
ivicinox
ivicinoy
c quarto vicino
(2)
iy
(3)
(3)
=
=
ix
iy
(4)
(4)
=
=
ix
iy
5.1. DLA
c
cc
c
c
ccc
c
- 1
adesso vediamo se uno dei quattro vicini

e occupato
occupato =.false.
do jj = 1, 4
if ( griglia ( ivicinox ( jj), ivicinoy (jj)) ) then
if ( .not.griglia (ix,iy)) then
nn
=
nn + 1
if ( nn.eq.( n_max+1 ) ) then
nn = nn -1
type *,Abbiamo raggiunto n_max
go to 950
end if
griglia (ix,iy) = . true .
occupato
= . true .
iarrivo (ilato )= iarrivo ( ilato ) +1
ridefinizione dei massimi e dei minimi
if
if
c
ccc
c
+1
(ix.gt.mx_max) then
mx_max = ix
end if
(ix.lt.mx_min) then
mx_min = ix
end if
ridefinizione dei massimi e dei minimi

if
in x
(iy.gt.my_max) then
141
in y
5.1. DLA

my_max
if
c
ccc
c
iy
end if
(iy.lt.my_min) then
my_min = iy
end if
end if
end if
ridefinizione
if
((
go
elseif ((
go
elseif ((
go
elseif ((
go
eventuale della zona di
mx_min -lx_min)
.eq. 1
to 200
lx_max - mx_max ) .eq. 1
to 200
ly_max - my_max ) .eq. 1
to 200
my_min -ly_min
) .eq. 1
to 200
end if
go to 300
200 continue
c
ccccccc
c
lx_min = lx_min - l_dist
lx_max = lx_max + l_dist
ly_min = ly_min - l_dist
ly_max = ly_max + l_dist
idum
= idum +1
kgen
= kgen +1
ddir
= kdir + 1
c
cccc ma potremmo avere raggiunto
c
c
ccccccc
c
kx_min=lx_min-k_dist
142
lancio
) then
) then
) then
) then
la frontiera

kx_max=lx_max+k_dist
ky_min=ly_min-k_dist
ky_max=ly_max+k_dist
cc
ccccccccc ma potremmo avere raggiunto
cc
if
(kx_min.le. 1 ) then
type *,Abbiamo raggiunto la
go to 950
elseif (ky_min.le. 1 ) then
go to 950
elseif (ky_max.ge. ndim ) then
go to 950
elseif (kx_max.ge. ndim ) then
go to 950
end if
300
le frontiere
frontiera
frontiera
frontiera
frontiera
continue
end do
(.not.occupato ) then
go to 100
end if
go to 40
continue
call esci ( nn,n_vero)
isum = 0
do j = 1, 4
type *,numero di arrivi dal lato ,j, =,iarrivo (j)
isum = isum + iarrivo (j)
end do
fraz
=
isum * 1.0 /
itotale
type *,frazione arrivata sui totali partiti =,fraz
return
end
if
950
5.1. DLA
143
5.2. AGGREGAZIONE BALLISTICA

5.2
Aggregazione ballistica
Questo processo di aggregazione cerca di spiegare fenomeni in cui entra

in gioco la gravità, tipo deposizione di zinco su di un catodo, esperimenti di soluzione chimica, depositi di ossido di manganese su calcari,
neve che cade su di un vetro. Come al solito lavoriamo su di un lattice
composto da N N pixels e le particelle partono da un punto random
R1 [1,N] sul lato in alto. Inizialmente l aggregato consiste in una particella posta sul lato in basso in posizione centrale ( deposito a cono )
oppure in pi`
u di una particella ( deposito ad alberi ). Ad ogni spostamento delle particelle in caduta vengono controllati i quattro vicini. Se
un vicino è occupato l aggregato aumenta di una unità e il processo
riparte con un altra particella sul lato in alto. Se invece nessuno dei
quattro vicini è occupato il processo riparte con il moto random. Se
vengono raggiunti i lati-frontiera sinistro oppure destro oppure inferiore il processo si ferma e riparte dall alto. Anche qu` per velocizzare
il tempo di esecuzione del programma le particelle partono sul lato superiore variabile. Riportiamo nelle figure 5.2 e 5.3 due tipici esempi di
aggregazione ballistica.
L implementazione pratica avviene attraverso la SUBROUTINE
BA.
subroutine ba (occ ,ndim ,l_dist,k_dist,m_dist,n_max,n_vero,nba)
implicit
real * 4 ( a-h,o-z)
logical * 1
occ , occupato
external g05dyfzan
integer
g05dyfzan
dimension occ(ndim,ndim)
dimension ivicinox
( 1 : 4 )
dimension ivicinoy
( 1 : 4 )
c zero the lattice and mark the center as occupied
do i=1,ndim
do j=1,ndim
occ(j,i)=.false.
end do
end do
idum = 33333
do i =1 , nba
ipunto = g05dyfzan ( 1 , ndim ,idum )
144

Figura 5.2: Deposito ballistico con un punto iniziale
145

Figura 5.3: Deposito ballistico con pi`

u punti iniziali
146

if (nba.eq.1)
ipunto
then
= ndim / 2
end if
occ (ipunto,1) =.true.
end do
c define initial launching and kill boundaries
lx_min = 1
lx_max = ndim
ly_max=
1 + l_dist
ly_min=
1
ky_min = 1
ky_max=
ly_max+k_dist
kx_max = ndim
kx_min = 1
c set an artificial occupation boundary at the start
my_max= 1 + m_dist
cc
cccc
abbiamo
fissato le zone di lancio
cc
e quelle di killing
idum = 33333
kgen = 77777
kdir = 55555
nn
= 1
ccc
inizio zona di lancio
40 continue
c
ccccccccc
c
lx_min,ly_max .....
lx_max,ly_max
c
------------------------c
|
|
c
|
|
c
| zona
di
|
c
|
|
c
|
lancio
|
c
|
|
c
ix
g05dyfzan
( lx_min,lx_max,kgen )
147

iy
ly_max
c adesso impostiamo la direzione di moto

100 continue
idir
= g05dyfzan ( 1 , 3 , kdir )
c
c
3 ------ * ------ 2
c
|
c
|
c
|
c
1
c
if (idir .eq . 1 ) then ! si muove giu in basso
ix
= ix
iy
= iy - 1
elseif ( idir.eq.2 ) then ! si muove a destra
ix
= ix +1
iy
= iy
elseif ( idir.eq.3 ) then ! si muove a sinistra
ix
= ix -1
iy
= iy
end if
c
cc
c
c
c
c
c
adesso
ci siamo mossi !!!!!
adesso facciamo un controllo sulla killing zone

se abbiamo raggiunto la frontiera
ricominciamo
dalla zona di lancio
if
(iy.eq.ky_min) then
! limite alto
! e
basso
go to 40
elseif ((ix.eq.kx_min).or.(ix.eq.kx_max))then ! limite destro
! e sinistro
go to 40
148

end if
c
cc
c
c
c
c
c
c
c
c
costruzione dei tre
-------------
ivicinox
ivicinoy
c primo vicino
ivicinox
ivicinoy
c secondo vicino
ivicinox
ivicinoy
c terzo
vicino
c
cc
c
vicini
(1)
(1)
=
=
ix
iy
(2)
(2)
=
=
ix
iy
+ 1
(3)
(3)
=
=
ix
iy
- 1
- 1
adesso vediamo se uno dei quattro vicini

e occupato
occupato =.false.
do jj = 1, 3
if ( occ ( ivicinox ( jj), ivicinoy (jj)) ) then
if ( .not.occ (ix,iy)) then
nn
=
nn + 1
if ( nn.eq.( n_max+1 ) ) then
nn = nn -1
type *,Abbiamo raggiunto n_max
return
end if
occ (ix,iy) = . true .
occupato
= . true .
c
149
5.3. PERCOLAZIONE
ccc
c
ridefinizione del massimo

if
in y
(iy.gt.my_max) then
my_max =
ly_max =
iy
my_max + l_dist
end if
if (ly_max.ge. ndim ) then
type *,Abbiamo raggiunto la frontiera
return
end if
end if
end if
end do
if (.not.occupato ) then
go to 100
end if
go to 40
end
5.3
Percolazione
Anche qu` grazie all avvento dei computers è stato aperto un nuovo
capitolo al confine fra fisica e matematica. Prendiamo in esame un
lattice quadrato con N N occupazioni disponibili e introduciamo una
probabilità di occupazione dei punti del lattice p varianti fra 0 ed 1.
Questo significa che ad ogni p avremo un numero M di punti occupati
sul lattice pari a:
M = N IN T (p N N ) .
(5.1)
Possiamo generare queste M occupazioni con due processi random

(
Ix = R1 [1, N ]
Iy = R2 [1, N ]
(5.2)
controllando ogni volta che il punto del lattice ( Ix , Iy ) non sia già
occupato. Alla fine del processo avremo M punti occupati sul lattice (
N N ). Notiamo che quando P 0.59 è possibile trovare un cammino
150
5.3. PERCOLAZIONE
di siti occupati che connette alto e basso e destra e sinistra. Diciamo a

questo punto che il cluster percola attraverso il sistema come l acqua
percola attraverso una caffettiera. Questa probabilità prende il nome
di probabilità critica pc e gioca un ruolo cruciale in tutta la teoria.
Riportiamo nella figura 5.4 un tipico esempio di occupazione random
di un cluster di 300 pixels con p= 0.1 .
Le applicazioni pratiche della percolazione possono essere gli incendi nelle foreste, le transizioni di fase tipo ferro-magnetismo paramagnetismo, conduttività, etc. ; per maggiori dettagli consultate
il libro [TF 92]. Praticamente possiamo implementare l algoritmo
mediante la SUBROUTINE FAI-PUNTI.
50
subroutine fai_punti (kubo,mmm,perc)

implicit real * 4 ( a-h ,o-z)
logical
* 1 kubo
dimension kubo ( 0 : mmm , 0 : mmm )
external g05dyfzan
integer
g05dyfzan
do ix = 0, mmm
do iy = 0, mmm
kubo ( ix, iy ) = .false.
end do
end do
itotal
= ( mmm + 1 ) *( mmm + 1)
iselected = nint ( perc * itotal )
icambiati = 0
idum
= 777777
do jj = 1 , iselected
continue
ix
= g05dyfzan (0,mmm,idum)
iy
= g05dyfzan (0,mmm,idum)
if ( kubo ( ix,iy )) then
icambiati = icambiati + 1
go to 50
end if
kubo (ix,iy) =.true.
end do
return
end
151
5.3. PERCOLAZIONE
Figura 5.4: Percolazione con p=0.1
152
5.3. PERCOLAZIONE
Il problema di trovare il cluster di connessione può essere cos` risolto.

Prendiamo un punto occupato del lattice, eliminiamolo dal lattice e
mettiamolo in un vettore. Abbiamo adesso quattro vicini e controlliamo
quali sono quelli occupati: essi finiranno nel vettore. Calcoliamo adesso
i vicini occupati da tutti gli elementi del vettore e cos` via. Questo è
un cluster e il processo si ferma quando non troviamo pi`
u nessun vicino
occupato. Il cluster di connessione viene trovato quando quattro punti
di esso appartengono ai lati sinistro, destro alto e basso; vedi figura 5.5.
Questo algoritmo di ricerca del cluster viene implementato attraverso la SUBROUTINE FAICLUSTER.
subroutine fai_cluster ( kubo, mmm ,si ,cluster)
integer
*4 ifine
logical
*1 kubo,condizionea,condizioneb
logical
*1 condizionex
logical
*1 condizioney
logical
*1 si
logical
*1 cluster
parameter ( ipoints = 100 000 )
parameter (maxelements =20 000) ! dimensione vettori vari
dimension kubo
( 0:mmm,0:mmm
)
dimension cluster
( 0:mmm,0:mmm
)
dimension icx
( 1:maxelements )
dimension icy
( 1:maxelements )
dimension ielements ( 1:maxelements )
dimension inewx
( 1:maxelements )
dimension inewy
( 1:maxelements )
dimension inewxsur
( 1:maxelements )
dimension inewysur
( 1:maxelements )
dimension isx
( 1:ipoints
)
dimension isy
( 1:ipoints
)
ifine = 0
do jx
= 0 , mmm
do jy
= 0 , mmm
if ( kubo (jx ,jy) ) then
ifine = ifine + 1
isx (ifine) = jx
isy (ifine) = jy
153
5.3. PERCOLAZIONE
Figura 5.5: Cluster di connessione
154
5.3. PERCOLAZIONE
end if
end do
end do
if ( ifine.gt.ipoints) then
stop aumentare ipoints !
end if
icluster = 0
1015 continue
icluster = icluster +1
do jj=1,ifine
ix = isx (jj)
iy = isy (jj)
if (kubo(ix,iy))
then
icx (1) = ix
icy (1) = iy
kubo(ix,iy )
=.false.
inewx (1 )
= ix
inewy (1 )
= iy
go to 102
end if
end do
icluster = icluster -1
go to 1016
102 continue
mmm1 = mmm + 1
number = 1
new = 1
103
continue
iadd = 0
cccccccccccccccc caricamento primi vettori di nuovi punti ccccccccccccc
do j=1,new
do jcasi = 1, 4
if
( jcasi.eq. 1 ) then
isux = 0
isuy = 1
elseif ( jcasi.eq. 2 ) then
isux = +1
isuy = 0
155
5.3. PERCOLAZIONE
isux = 0
isuy = -1
isux = -1
isuy = 0
end if
newx =
inewx ( j ) + isux
newy =
inewy ( j ) + isuy
if (( newx.eq.-1).or.(newx.eq.mmm1)) then
go to 1050
end if
if (( newy.eq.-1).or.(newy.eq.mmm1)) then
go to 1050
end if
if (( isux.eq.0).and.(isuy.eq.0 )) then
go to 1050
end if
c x boundaries problem
if (kubo(newx,newy))
then
kubo(newx,newy)=.false.
iadd = iadd +1
inewxsur ( iadd ) = newx
inewysur ( iadd ) = newy
end if
1050
continue
end do
end do
c determinzaione 4 vicini ccccccccccccccc
if ( iadd.eq.0 ) then
ielements ( icluster) = number
cc
inseriamo il loop sul calcolo della percolazione
cc
scanning su y
condizionea
= .false.
condizioneb
= .false.
do j= 1 , number
if (icy(j).eq. 0 ) then
condizionea = . true .
end if
if (icy(j).eq. mmm ) then
156
5.3. PERCOLAZIONE
condizioneb = . true .
end if
end do
condizioney=.false.
if ((condizionea).and.(condizioneb)) then
condizioney =.true.
end if
cc scanning su x
condizionea
= .false.
condizioneb
= .false.
do j= 1 , number
if (icx(j).eq. 0 ) then
condizionea = . true .
end if
if (icx(j).eq. mmm ) then
condizioneb = . true .
end if
end do
condizionex =.false.
if ((condizionea).and.(condizioneb)) then
condizionex =.true.
if (condizionex.and.condizioney) then
si =.true.
do jjj = 1 , number
iixx = icx ( jjj )
jjyy = icy ( jjj )
cluster ( iixx , jjyy ) =.true.
end do
end if
end if
go to 1015
end if
do j = 1,iadd
number = number + 1
icx (number ) = inewxsur (j)
icy (number ) = inewysur (j)
end do
do j = 1,iadd
inewx ( j ) = inewxsur (j)
157
5.4. CATENE DI VORONOI
inewy ( j ) = inewysur (j)

end do
new = iadd
go to 103
ccccccccc end great loop cccccccccccccccccccccccccccccccccccccc
1016 continue
cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
type *,clusters veri=,icluster
return
end
5.4
Catene di Voronoi
Questi diagrammi prendono il nome da un matematico russo che nel

1908 fece un lavoro ( ovviamente analitico ) sui poligoni irregolari che
riempiono il piano. Il problema è poi stato ripreso da svariati autori ognuno con in mente una applicazione di diverso tipo: struttura
dei cristalli, struttura della cellula, raffreddamento e conseguente frammentazione delle rocce, struttura dell universo,etc. Il problema in due
dimensioni consiste nel trovare una volta che è dato un insieme di punti,
detti nuclei, una partizione dello spazio tale che ogni nucleo abbia un
suo dominio e le frontiere, ovverosia le zone equidistanti fra un nucleo
e l altro, siano marcate.
Per riassumere chiamiamo diagrammi di Voronoi il set dei punti tali
che le distanze fra i due nuclei pi`
u vicini siano uguali. Elenchiamo una
serie possibile di disposizioni di nuclei nel piano classificabile in base
alla distribuzione di probalità di partenza oppure in base all algoritmo
generante:
1. generazione random su x ed y,
2. generazione gaussiana polare su r e ,
3. numeri pseudo-random o di Sobol,
4. autovalori di matrice complessa,
5. punti frattali.
158
Figura 5.6: Diagramma di Voronoi con nuclei random su x e y
159
Figura 5.7: Diagramma di Voronoi con nuclei gaussiani
160
Figura 5.8: La testa della margherita
161
Si tratta poi di trovare tramite uno scanning degli N N punti del

lattice quelli equidistanti dai due nuclei pi`
u vicini per quanto riguarda i
lati e dai tre nuclei pi`
u vicini per quanto riguarda i vertici. Riportiamo
nelle due figure 5.6 e 5.7 un tipico esempio di tessellazione quando i
nuclei sono distribuiti in maniera random su x y ed in maniera gaussiana . Le applicazioni pratiche sono svariate e come esempio riportiamo
la struttura logaritmica della testa dei fiori tipo margherita o girasole.
Per generare i nuclei usiamo la formula di Vogel:
(5.3)
= n 137.5 r = c n ,
dove
1. n è il numero di punti in senso crescente dal centro. Questo e
l inverso dell età dell organismo vegetale in questione.
2. è l angolo di referenza in gradi del punto n in coordinate polari.
3. r è la distanza fra il centro ed il punto n.
Il risultante diagramma di Voronoi viene riportato nella figura 5.8
Per maggiori dettagli sui diagrammi di Voronoi consultare il libro [OBS 92] .
L implementazione pratica dello scanning avviene attraverso la SUBROUTINE MATRICE.
,
subroutine
matrice (vec,ipunti,side,matrix,nodes,mll,muu,mmm,traspo)
implicit real * 8
(a-h,o-z)
logical
* 1
matrix,yes,nodes,lato1,lato2
parameter
(nnnn=1000)
dimension
matrix (0:mmm,0:mmm )
dimension
nodes (0:mmm,0:mmm )
dimension traspo
(1:20
)
dimension vec
(1:ipunti,1:2)
dimension ads0
(1:nnnn)
dimension ads
(1:nnnn)
dimension awork
(1:nnnn)
dimension index
(1:nnnn)
dimension indexwork (1:nnnn)
dimension nodesx
(1:nnnn)
dimension nodesy
(1:nnnn)
162
delta
= side/mmm
delta0 = side/mll
rad2
= dsqrt (2.0 D+00)
correz = 1.
adelta = delta * correz
adelta0 = delta0 * correz
deltamezzi = delta /2.0
delta0mezzi= delta0/2.0
do jm=0,mmm
do jn=0,mmm
matrix (jm,jn)=.false.
nodes (jm,jn)=.false.
end do
end do
numero = 0
do jy0 =0 , mll -1
do jx0 =0 , mll -1
xx = jx0 * delta0 + delta0mezzi
yy = jy0 * delta0 + delta0mezzi
do jj =1,ipunti
ax = xx - vec(jj,1)
ay = yy - vec(jj,2)
ads0
(jj) = dsqrt ( ax*ax + ay*ay )
end do
ifail =0
call m01caf ( ads0,1,ipunti,A,ifail) ! riordino del vettore in
! senso ascendente
adiff0
= dabs (ads0(2)- ads0 (1))
if (adiff0.le.( adelta0* rad2)) then
do jy =jy0*muu , jy0*muu + muu-1
do jx =jx0*muu , jx0*muu + muu-1
xx = jx * delta + deltamezzi
yy = jy * delta + deltamezzi
do jj =1,ipunti
ax =xx - vec(jj,1)
ay =yy - vec(jj,2)
ads
(jj) = dsqrt ( ax*ax + ay*ay )
end do
ifail =0
163
call m01ajf (ads,awork,index,indexwork,ipunti,ipunti,ifail)

adiff
= dabs (ads(2)- ads (1))
cccccccccccc beginning check on all the square vertex ccccccccccccccccc
if (adiff.le.(adelta*rad2)) then
x1 = vec(index(1),1)
y1 = vec(index(1),2)
xc = xx
yc = yy
yes=.false.
call retta90 (x1,y1,x2,y2,xc,yc,deltamezzi,yes)
if (yes) then
numero = numero +1
matrix (jx,jy)=.true.
cccccccccc beginning nodes cccccccccccccccccccccccccccccccccccccccc
lato1 =.false.
lato2 =.false.
xc = xx
yc = yy
yes=.false.
if (yes) then
lato1=.true.
end if
xc = xx
yc = yy
yes=.false.
if (yes) then
lato2=.true.
164
end if
if ((lato1).and.(lato2)) then
nodes
(jx,jy)=.true.
endif
ccccccccccccccccccccccccc end nodes ccccccccccccccccccccccccccc
end if
end if
end do
end do
end if
end do
end do
traspo (1) = adelta
traspo (2) = numero
return
end
Questa subroutine fa uso della SUBROUTINE RETTA90.

subroutine retta90 (x1,y1,x2,y2,xc,yc,deltamezzi,yes)
logical * 1 yes,uno,due
yes=.false.
uno=.false.
due=.false.
deltay = y2 -y1
deltax = x2 -x1
am = deltay/deltax
100 continue
c
determinazione primo coefficiente angolare
amprimo = -1.0/am
c
determinazione secondo coefficiente angolare a 90 gradi
ymezzi = (y1+y2)/2.0
xmezzi = (x1+x2)/2.0
165
x = xc
+ deltamezzi
y = ymezzi + amprimo * ( x - xmezzi)
determinazione prima retta
ylower = yc - deltamezzi
yupper = yc + deltamezzi
if ((y.gt.ylower).and.(y.le.yupper))
uno=.true.
end if
x = xc
- deltamezzi
y = ymezzi + amprimo * ( x - xmezzi)
determinazione prima retta
if ((y.gt.ylower).and.(y.le.yupper))
uno=.true.
end if
y = yc + deltamezzi
x = (y-ymezzi)/amprimo + xmezzi
xlower = xc - deltamezzi
xupper = xc + deltamezzi
if ((x.gt.xlower).and.(x.le.xupper))
due=.true.
end if
y = yc - deltamezzi
x = (y-ymezzi)/amprimo + xmezzi
if ((x.gt.xlower).and.(x.le.xupper))
due=.true.
end if
if ((uno).or.(due)) then
yes = .true.
end if
return
end
166
then
then
then
then
Appendice A
Funzioni intrinseche
Riportiamo il nome generico delle funzioni intrinseche attualmente in
uso sui compilatori di FORTRAN 77 insieme ad una breve spiegazione
del loro significato.
ABS (numero) Una funzione che ritorna il valore assoluto dell argomento. Il valore assoluto di un numero complesso, (X,Y), è il suo
valore reale (X**2 + Y**2)**(1/2).
ACOS (numero)Una funzione che ritorna l arcocoseno dell argomento in radianti. Il valore assoluto dell argomento deve essere minore
o uguale a 1.
ACOSD ( numero reale)Una funzione che ritorna l arcocoseno
dell argomento in gradi. Il valore dell argomento deve essere compreso
fra 0 (escluso) e 1 (incluso).
AIMAG (numero complesso)Una funzione che ritorna la parte
immaginaria di un numero complesso. L argomento deve essere di tipo
COMPLEX*8. Il risultato è di tipo REAL*4.
AINT ( numero reale)Una funzione che ritorna l intero pi`
u grande il cui valore assoluto non supera il valore assoluto dell argomento e
ha lo stesso segno dell argomento.
AMAX0 (numero, numero,...)Una funzione che ritorna il maggiore dei valori specificato nella lista degli argomenti.
AMIN0 (numero, numero,...) Una funzione che ritorna il minore dei valori specificati nella lista degli argomenti.
ANINT ( numero reale) Una funzione che ritorna il valore dell intero pi`
u vicino al valore dell argomento.
167
APPENDICE A. FUNZIONI INTRINSECHE

ASIN ( numero reale) Una funzione che ritorna l arcoseno dell argomento in radianti. Il valore assoluto dell argomento deve essere
minore o uguale a 1.
ASIND ( numero reale) Una funzione che ritorna l arcoseno
dell argomento in gradi. Il valore dell argomento deve essere compreso
fra 0 (escluso) e 1 (incluso).
ATAN ( numero reale) Una funzione che ritorna l arcotangente
dell argomento in radianti. Il valore assoluto dell argomento deve
essere maggiore di 0.
ATAND ( numero reale) Una funzione che ritorna l arcotangente dell argomento in gradi. Il valore assoluto dell argomento deve
essere maggiore di 0.
ATAN2 ( numero reale, numero reale) Una funzione che ritorna l arcotangente del quoziente dei due argomenti in radianti. Se
ambedue gli argomenti sono zero, il risultato è indefinito. Se il primo
argomento è positivo, il risultato è positivo. Se il primo argomento è negativo, il risultato è negativo. Se il primo argomento è zero, il risultato
è zero. Se il secondo argomento è zero, il valore assoluto del risultato
è pi/2. Il range del risultato è compreso tra -pi e pi.
ATAN2D ( numero reale, numero reale) Una funzione che
ritorna l arcotangente del quoziente dei due argomenti in gradi. Se
ambedue gli argomenti sono zero, il risultato è indefinito. Se il primo
argomento è positivo, il risultato è positivo. Se il primo argomento
è negativo, il risultato è negativo. Se il primo argomento è zero, il
risultato è zero. Se il secondo argomento è zero, il valore assoluto
del risultato è 90. Il range del risultato è compreso tra -180 e 180
gradi.
BTEST (intero, posizione) Una funzione che ritorna il valore
logico.true. se il bit con l intero specificato dalla posizione è settato a
1. I Il bit di ordine basso è posizionato a 0.
CHAR (intero) Una funzione che ritorna il carattere associato
con il valore ASCII specificato dall argomento. L argomento deve essere BYTE, LOGICAL*1, LOGICAL*2, LOGICAL*4, INTEGER*2,
o INTEGER*4 come tipo di dato. Il risultato deve essere di tipo
CHARACTER. Il valore di input deve essere nel range da 0 a 255.
CMPLX (numero [,numero]) Una funzione che converte uno o
due argomenti nel tipo COMPLEX*8. Se viene specificato un argomento, questo è convertito nella parte reale del valore del complesso e
168

la parte immaginaria diventa zero. Se sono specificati due argomenti, il
primo è convertito nella parte reale del valore del complesso e il secondo
nella parte immaginaria del valore del complesso. I due argomenti che
sono specificati devono essere dello stesso tipo.
CONJG (numero complesso) Una funzione che ritorna il complesso coniugato dell argomento. Se l argomento è (X,Y), il suo
complesso coniugato è (X,-Y).
COS (numero) Una funzione che ritorna il coseno dell argomento.
L argomento deve essere in radianti.
COSD (numero) Una funzione che ritorna il coseno dell argomento. L argomento deve essere in gradi.
COSH ( numero reale) Una funzione che ritorna il coseno iperbolico dell argomento.
DATE (data) Una subroutine che mette la data corrente nel suo
argomento. L argomento a 9-byte può essere una stringa carattere,
una variable, vettore, o un elemento di vettore di ogni tipo. La data è
un valore ASCII formattato come segue: gg-mmm-aa.
DBLE (numero) Una funzione che converte l argomento in un
valore REAL*8.
DCMPLX (numero [,numero]) Una funzione che converte uno
o due argomenti nel tipo COMPLEX*16. Se viene specificato un argomento, questo è convertito nella parte reale del valore del complesso e
la parte immaginaria diventa zero. Se sono specificati due argomenti,
il primo è convertito nella parte reale del valore del complesso e il secondo argomento nella parte immaginaria del valore del complesso. I
due argomenti che sono specificati devono essere dello stesso tipo.
DFLOAT (integer) Una funzione che converte l argomento in un
valore REAL*8.
DIM (numero, numero) Una funzione che ritorna il valore del
primo argomento meno il minimo (MIN) dei due argomenti.
DIMAG (immaginario) Una funzione che ritorna la parte immaginaria di un numero complesso. L argomento deve essere di tipo
COMPLEX*16. Il risultato è del tipo REAL* 8.
DPROD (numeroreal*4, numeroreal*4) Una funzione che ritorna il prodotto di due valori REAL*4 come un valore REAL*8.
DREAL (numero complesso) Una funzione che ritorna la parte reale di un numero complesso. L argomento deve essere di tipo
COMPLEX*16. Il risultato è di tipo REAL*8.
169

EXP (esponente) Una funzione che ritorna e**X, dove X è il
valore dell argomento.
FLOAT (integer) Una funzione che converte l argomento in un
valore REAL*4.
IABS (numero) Una funzione che ritorna il valore assoluto di un
argomento intero. Il valore assoluto di un numero complesso, (X,Y), è
il valore reale (X**2 + Y**2)**(1/2).
IAND (intero, intero) Una funzione che produce il LOGICAL
degli argomenti su una base del tipo bit per bit.
IBCLR (intero, posizione) Una funzione che ritorna il valore del
primo argomento con il bit specificato settato a 0. Il bit di ordine basso
è in posizione 0.
IBITS (intero, posizione di partenza, lunghezza ) Una funzione che ritorna il valore del bit specificato dalla posizione di partenza
e dalla posizione finale. Il bit di ordine pi`
u basso è in posizione 0.
IBSET (intero, posizione) Una funzione che ritorna il valore del
primo argomento con il bit specificato settato a 0. Il bit di ordine pi`
u
basso è in posizione 0.
ICHAR (carattere) Una funzione che ritorna il valore ASCII
dell argomento. L argomento deve essere una espressione character
di lunghezza uno. Il risultato è un tipo di dato INTEGER*4.
IDATE ( mese, giorno, anno ) Una subroutine che ritorna i
tre valori rappresentanti la data corrente. Gli argomenti devono essere
definiti come interi o vettore di interi. Il mese è rappresentato con il
numero del mese (1 -12). Il giorno è rappresentato come il giorno del
mese. L anno è rappresentato dalle ultime due cifre dell anno.
IDIM (numero, numero) Una funzione che ritorna il valore del
primo argomento meno il minimo (MIN) dei due argomenti.
IDINT (numero) Una funzione che ritorna l intero pi`
u grande il
cui valore assoluto non eccede il valore assoluto dell argomento e ha lo
stesso segno dell argomento. L argomento deve essere di tipo real * 8.
IDNINT ( numero reale) Una funzione che ritorna il valore
dell intero pi`
u vicino al valore dell argomento. L argomento deve
essere di tipo real * 8.
IEOR (intero, intero) Una funzione che riporta un OR esclusivo
su argomenti di tipo bit per bit.
IFIX (real*4) Una funzione che converte un numero reale in un
intero
170

INDEX (stringa, sub-stringa ) Una funzione che cerca una stringa per la sua prima comparsa di una sottostringa e ritorna la posizione
di partenza della sottostringa come un valore INTEGER*4.
INT (numero) Una funzione che ritorna il pi`
u grande intero il
cui valore assoluto non eccede il valore assoluto dell argomento e ha
lo stesso segno dell argomento. La funzione ritorna un valore INTEGER*4 se il commando / I4 è in funzione; altrimenti ritorna un valore
INTEGER*2.
IOR (intero, intero) Una funzione che produce un OR logico
dell argomento sulla base di ragionamenti bit per bit.
IQINT (numero) Una funzione che ritorna l intero pi`
u grande il
cui valore assoluto non eccede il valore assoluto dell argomento ed ha
lo stesso segno dell argomento. L argomento deve essere di tipo real
* 16.
ISIGN (valore, segno )Una funzione che assegna il segno del
secondo argomento al valore assoluto del primo.
LEN (carattere)Una funzione che ritorna il numero di caratteri
dell argomento. L argomento deve essere un espressione CHARACTER. Il risultato è un valore INTEGER*4.
LGE (carattere, carattere )Una funzione che ritorna il valore.true. se la prima stringa carattere è pi`
u lunga o uguale alla seconda
stringa carattere. Gli argomenti devono essere del tipo CHARACTER
mentre il risultato è un valore LOGICAL*4.
LGT (carattere, carattere )Una funzione che ritorna il valore.true. se la prima stringa carattere è maggiore della seconda stringa
carattere. Gli argomenti devono essere del tipo CHARACTER mentre
il risultato è un valore LOGICAL*4.
LLE (carattere, carattere )Una funzione che ritorna il valore.true. se la prima stringa carattere è minore o uguale alla seconda
stringa carattere. Gli argomenti devono essere del tipo CHARACTER
mentre il risultato è un valore LOGICAL*4.
LLT (carattere, carattere )Una funzione che ritorna il valore.true. se la prima stringa carattere è minore alla seconda stringa
carattere. Gli argomenti devono essere del tipo CHARACTER mentre
il risultato è un valore LOGICAL*4.
LOG (numero) Una funzione che ritorna il logaritmo naturale
(base e) dell argomento. L argomento deve essere maggiore di zero.
171

LOG10 (numero) Una funzione che ritorna il logaritmo comune
(base 10 ) dell argomento. L argomento deve essere maggiore di zero.
MAX (numero, numero,...) Una funzione che ritorna il maggiore
dei valori specificati nella lista degli argomenti.
MIN (numero, numero,...) Una funzione che ritorna il minore
dei valori specificati nella lista degli argomenti.
MOD (dividendo, divisore) Una funzione che divide il primo
argomento per il secondo e ritorna il resto.
NINT ( numero reale) Una funzione che ritorna il valore dell intero pi`
u vicino al valore dell argomento.
QEXT (numero)Una funzione che converte l argomento in un
valore REAL*16.
QFLOAT (intero) Una funzione che converte un valore intero in
un REAL*16.
RAN (seme ) Una funzione che ritorna un valore un numero
REAL*4 fra 0.0 (incluso) e 1.0 (escluso). L argomento deve essere
una variabile o elemento di vettore INTEGER*4. Per ottenere i risultati migliori inizializzate con un valore grande e dispari per la prima
volta. Per generare sets differenti di valori random inizializzate il seme
ogni volta con un valore diverso.
REAL (numero) Una funzione che converte l argomento in un
valore real.
SIZEOF ( argomento ) La funzione ritorna il numero di bytes di
memoria usata dall argomento.
SECNDS ( numero reale) Una subroutine che ritorna il numero
di secondi da mezzanotte meno il valore dell argomento. L argomento
deve essere di tipo REAL*4. Il valore di ritorno è del tipo REAL*4. Il
tempo di ritorno è accurato a 1/100 di secondo.
SIGN (valore, segno ) Una funzione che assegna il segno del
secondo argomento al valore assoluto del primo.
SIN (numero) Una funzione che ritorna il seno dell argomento.
L argomento deve essere in radianti.
SIND (numero) Una funzione che ritorna il seno dell argomento.
L argomento deve essere in gradi.
SINH (numero) Una funzione che ritorna il seno iperbolico dell argomento che deve essere espresso in radianti.
SINHD (numero) Una funzione che ritorna il seno iperbolico
dell argomento che deve essere espresso in gradi.
172

SQRT (numero) Una funzione che ritorna la radice quadrata
dell argomento. Il risultato è il valore principale, con la parte reale
maggiore o uguale a zero. Se la parte reale è zero, il risultato è il valore
principale, con l immaginario maggiore o uguale a zero.
TAN ( numero reale) Una funzione che ritorna la tangente dell argomento. L argomento deve essere in radianti.
TAND ( numero reale) Una funzione che ritorna la tangente
dell argomento. L argomento deve essere in gradi.
TANH ( numero reale) Una funzione che ritorna la tangente iperbolica dell argomento. L argomento deve essere espresso in radianti.
TANHD ( numero reale) Una funzione che ritorna la tangente
iperbolica dell argomento. L argomento deve essere espresso in gradi.
TIME (tempo) Una subroutine che ritorna il tempo attuale in
formato ASCII 24-h. L argomento deve essere una variabile, vettori,
elemento di vettore o sottostringa di 8 bytes. Il tempo è formattato
come segue: hh:mm:ss.
ZEXT (intero) Una funzione che ritorna il valore dell argomento,
zero esteso.
173
174
Appendice B
Subroutine di interesse
comune
Riportiamo in questa appendice i listati delle subroutines adoperate pi`
u
frequentemente nei programmi precedenti.
B.1
CLEANTOP
Questa subroutine pulisce lo schermo e porta il cursore a sinistra in alto

sui terminali.
subroutine cleantop
implicit real*4 (a-h,o-z)
c
c
c
c
c
c
c
this program clears the screen , then changes the screen from
dark to light
print *,char (27),[2J
clear the screen
print *,char (27),[0;0H
bring the cursor at the top left
write (6,*)char(27),[?5h
change the screen background to light
return
end
175
B.2. MAXMIN
B.2
APPENDICE B. SUBROUTINE DI INTERESSE COMUNE
MAXMIN
Questa subroutine ritorna il massimo ( XXMAX) e il minimo ( XXMIN

) di un vettore XX di dimensioni IVEC.
subroutine maxmin (xx,ivec,xxmax,xxmin)
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
c
c
c this subroutine is producing a the max and the minimum of the c
c vector xx
c ivec :== vector dimension
c
c
c
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
dimension xx(1:ivec)
xxmax = xx (1)
xxmin = xx (1)
do j = 1, ivec
if (xx(j).gt.xxmax) then
xxmax = xx(j)
end if
if (xx(j).lt.xxmin) then
xxmin = xx(j)
end if
end do
return
end
176
Appendice C
Sistema operativo UNIX
Si entra su una macchina UNIX tramite la comunicazione dilogin e Password. Compiuta questa prima operazione comparirà un prompt che
dipende dal sistema operativo usato. Se nel file .login inserite il comando set prompt = % comparirà il segno di percentuale ad accompagnarvi nelle vostre avventure. Riportiamo adesso i comandi principali
che interessano a noi.
C.1
Alcuni comandi UNIX

% man nomecomando
(C.1)
` molto importante per chi non ha tempo o voglia di leggersi i manuali

E
in quanto permette di vedere cosa corrisponde alla voce nomecomando.
% man k stringa
(C.2)
Serve a cercare una particolare stringa inserita in un comando. La

schermata successiva visualizza il comando coinvolto e la posizione
contestuale della stringa.
% ls
(C.3)
Questo comando riporta su schermo tutti i files.
% ls l
(C.4)
Per vedere la loro grandezza ( numero di bytes ) e la data in cui furono

creati.
177
C.2. EDITOR
APPENDICE C. SISTEMA OPERATIVO UNIX
% ls l a
(C.5)
Serve a vedere i file nascosti (quelli che incominciano con punto tipo
.netscape , .csrhc, .login etc....).
% cat miof ile
(C.6)
Permette un display del file indicato sul terminale adoperato.

% rm miof ile
(C.7)
Cancella il file indicato; ricordiamo che in questo sistema operativo

esiste solo l ultima versione del file creato.
% mv vecchiof ile nuovof ile
(C.8)
Cambia il nome del file indicato in quello nuovo.

% cp miof ile altrof ile
(C.9)
Copia il file indicato in uno nuovo.

% exit
(C.10)
Serve a chiudere la sessione interattiva.

< Ctrl/c >
(C.11)
Serve ad interrompere il processo interattivo in corso e ritornare al

sistema operativo.
C.2
Editor
` il mezzo fondamentale per avere accesso ai files nuovi oppure a quelli

E
esistenti e ne abbiamo svariati. Ci limitiamo a quelli pi`
u semplici che
sono stati anche testati
% joe miof ile
(C.12)
Si può accedere all help on line dell editor con il comando ( in editing
) < Ctrl + K + H >
% pico miof ile
(C.13)
Questo è l editor che adotta la finestra del noto sistema di posta
elettronica che risponde al nome di PINE.
178
APPENDICE C. SISTEMA OPERATIVO

C.3. COMPILAZIONE+LINK/ESECUZIONE
UNIX
C.3
Compilazione+link/esecuzione
Per compilare ed eseguire un programma, ad esempio miofile.f, si danno

i seguenti due comandi:
% f 77 o miof ile.exe miof ile.f
(C.14)
% ./miof ile.exe
(C.15)
Che sono in ordine comando per la compilazione + link ed esecuzione.

Se invece vogliamo solamente controllare che il programma non
contenga eventuali errori di compilazione, diamo il comando
% f 77 g c miof ile.f
C.4
(C.16)
Shell Script
Spesso può essere utile abbreviare una intera serie di comandi tramite un solo file dettoscript. Come esempio riportiamo uno script per
compilare ed eseguire un programma che chiameremocalcola.
calcola
#!/bin/sh
clear
echo Inserire nome del file
read nome
echo ho inserito
echo $nome
rm $nome.exe
echo la data e l ora sono:date
f77 -o $nome.exe $nome.for
./$nome.exe
Volendo adesso eseguire questo file di comandi dovremo prima cambiare le protezioni con il comandochmod u+x calcola e poi il comando ./calcola. Cercate tramite il manuale di capire le varie operazioni
compiute da questa sequenza.
179
C.5. LE LIBRERIE
C.5
APPENDICE C. SISTEMA OPERATIVO UNIX
Le librerie
Se volete crearvi una vostra libreria personale dovete prima trasformare

i file sorgente in file oggetto e poi collezionarli in un unica libreria.
Riportiamo uno script che genera una libreria chiamata mia lib.
f77 -c *.f
ar rcv libmia lib.a *.o
ranlib libmia lib.a
rm *.o
Controllate sulle pagine del manuale il significato delle varie operazioni. Se avete il file della libreria potete linkare ad essa il programma
main con il seguente comando:
f77 main.f -L. -lmia lib
180
Appendice D
I caratteri ASCII
I sistemi collegati con i computers memorizzano i caratteri sotto serie
di bits, usualmente lunghi 7 bits oppure 8. Riportiamo di seguito la
sequenza dei 128 caratteri ASCII ( American Standard Code for Information Interchange ) in notazione decimale. Ricordiamo che esiste
pure la rappresentazione ottale e quella esadecimale.
181
APPENDICE D. I CARATTERI ASCII
Tabella D.1: Tabella caratteri ASCII

NUL
SOH
ST X
ET X
EOT
EN Q
ACK
BEL
BS
HT
LF
VT
FF
CR
SO
SI
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
DLE
DC1
DC2
DC3
DC4
N AK
SY N
ET B
CAN
EM
SU B
ESC
FS
GS
RS
US
16 SP 32 0 48 @ 64 P
17 ! 33 1 49 A 65 Q
18
34 2 50 B 66 R
19 # 35 3 51 C 67 S
20 $ 36 4 52 D 68 T
21 % 37 5 53 E 69 U
22 & 38 6 54 F 70 V
23 0 39 7 55 G 71 W
24 ( 40 8 56 H 72 X
25 ) 41 9 57 I 73 Y
26 42 : 58 J 74 Z
27 + 43 ; 59 K 75 [
28 , 44 60 L 76 \
29 45 = 61 M 77 ]
30 . 46 > 62 N 78
31
47 ? 63 O 79
182
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
96
p
97
q
98
r
99
s
100
t
101
u
102
v
103
w
104
x
105
y
106
z
107
{
108
|
109
}
110
111 DEL
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
Bibliografia
[Ba 88] M.Barnsley,Fractals everywhere ,
prima edizione, Academic Press ,Inc. , Boston(1988).
[Do 83] R. Doretti,R. Farabone,Dal FORTRAN IV al FORTRAN 77
,
prima edizione, Gruppo Editoriale Jackson , Milano (1983).
[El 85] T.M.R. Ellis,Programmazione strutturata in FORTRAN 77 ,
prima edizione, Zanichelli , Bologna (1985).
[Ol 92] D. Oliver,Fractal Visions ,
prima edizione, SAMS PUBLISHING , Carmel (1992).
[OBS 92] Okabe,A. ,Boots,B.,Sugihara,K. ,
Spatial Tessellations Concepts and Applications of Voronoi Diagrams,
prima edizione, John Wiley & Sons , Chichester (1992).
[Or 86] A. Orsi Palamara ,Programmare in FORTRAN 77 ,
prima edizione, Levrotto e Bella , Torino (1986).
[PS88] H.O. Peitgen,S. Saupe,The Science of Fractal Image ,
prima edizione, Springer Verlag , Londra (1988).
[Pa 83] C. Page,FORTRAN 77 ,
prima edizione, Pitman Publishing LTD , Londra (1983).
[REC 92] Press W.H.,Teukolsky S.A., Vetterling W.T.,Flannery B.P.,
Numerical Recipes in Fortran,
seconda edizione, Cambridge University Press, Cambridge (1992).
183
BIBLIOGRAFIA
BIBLIOGRAFIA
[PL 90] P. Prusinkiewicz, A. Lindenmayer, The Algorithmic Beauty

of Plants,
prima edizione, Springer Verlag, New York (1990).
[TF 92] Stauffer D., Aharony A., Introduction to Percolation Theory,
seconda edizione, Taylor & Francis , London (1992).
[Vi 92] T.vicsek, Fractal Growth Phenomena,
seconda edizione, Word scientific, Singapore (1992).
184
Indice analitico
A
BACKSPACE istruzione, 41
DIMENSION istruzione, 24
dimensione-vettori, 20
distribuzione
esponenziale, 98
gaussiana, 99
Student, 95
DO istruzione, 31
DO-WHILE istruzione, 33
DOUBLE PRECISION variabile,
7
DOUBLE PRECISION istruzione,
5
ACCEPT istruzione, 40
aggregazione-ballistica, 142
aggregazione-DLA, 133
algoritmi-Montecarlo, 133
argomenti-subroutine, 20
ASCII-caratteri, 179
assegnazioni, 27
ASSIGN istruzione, 28
B
CALL istruzione, 19
caratteri, 2
catene-Voronoi, 156
CHARACTER variabile, 7, 8, 11
CHARACTER istruzione, 5
CLOSE istruzione, 38
colonne , 3
commento, 4
COMMON istruzione, 24
COMPLEX variabile, 7
COMPLEX istruzione, 5
concatenazione, 11
continuazione, 4
CONTINUE istruzione, 33
D
DATA istruzione, 27
ELSE istruzione, 30
ELSEIF istruzione, 30
END DO istruzione, 32
ENDFILE istruzione, 41
END istruzione, 5
ENTRY istruzione, 21
EQUIVALENCE istruzione, 25
espressioni, 9
Etichette, 5
EXTERNAL istruzione, 25
F
file, 36
fit
retta, 105
format
/, 44
185
INDICE ANALITICO
INDICE ANALITICO
Aw, 44
BN, 44
BZ, 44
Dw.d , 43
Ew.d, 43
Fw.d, 42
Gw.d , 43
IW, 42
KP, 44
Lw, 43
nHc1..cn , 43
SP, 44
SS, 44
stringa, 44
Tln, 44
Tn, 44
Trn, 44
FORMAT istruzione, 42
FORTRAN, 1
FUNCTION istruzione, 16
funzione
beta incompleta, 93
coefficiente-binomiale, 87
errori, 91
fattoriale, 86
gamma, 88
gamma-incompleta, 88
generatori-interi, 97
generatori-sistema, 95
numeri-random, 95
p-chiquadro, 92
funzione intrinseca, 165
ABS, 165
ACOS, 165
ACOSD, 165
AIMAG, 165
AINT, 165
AMAX0, 165
AMIN0, 165
186
ANINT, 165
ASIN, 166
ASIND, 166
ATAN, 166
ATAN2, 166
ATAN2D, 166
ATAND, 166
BTEST, 166
CHAR, 166
CMPLX, 167
CONJG, 167
COS, 167
COSD, 167
COSH, 167
DATE, 167
DBLE, 167
DCMPLX, 167
DFLOAT, 167
DIM, 167
DIMAG, 167
DPROD, 167
DREAL, 167
EXP, 168
FLOAT, 168
IABS, 168
IAND, 168
IBCLR, 168
IBITS, 168
IBSET, 168
ICHAR, 168
IDATE, 168
IDIM, 168
IDINT, 168
IDNINT, 168
IEOR, 168
IFIX, 168
INDEX, 169
INT, 169
IOR, 169
INDICE ANALITICO
IQINT, 169
ISIGN, 169
LEN, 169
LGE, 169
LGT, 169
LLE, 169
LLT, 169
LOG, 169
LOG10, 170
MAX, 170
MIN, 170
MOD, 170
NINT, 170
QEXT, 170
QFLOAT, 170
RAN, 170
REAL, 170
SECNDS, 170
SIGN, 170
SIN, 170
SIND, 170
SINH, 170
SINHD, 170
SIZEOF, 170
SQRT, 171
TAN, 171
TAND, 171
TANH, 171
TANHD, 171
TIME, 171
ZEXT, 171
G
globali, 4
GO TO istruzione, 29
I
IF istruzione, 30
IMPLICIT istruzione, 22
INDICE ANALITICO
IMPLICIT istruzione, 4
INQUIRE istruzione, 39
INTEGER istruzione, 5
INTEGER variabile, 6
INTRINSIC istruzione, 26
L
locali, 4
LOGICAL variabile, 7
LOGICAL istruzione, 5
M
main, 14
mapping
Feigenbaum, 112
Henon, 109
Julia, 119
regolabile, 120
memoria, 6
momenti-campione, 101
asimmetria, 102
curtosi, 102
deviazione-assoluta, 101
deviazione-standard-empirica, 101
valor-medio, 101
varianza-empirica, 101
O
OPEN istruzione, 37
P
PARAMETER istruzione, 22
parole-chiave, 5
PAUSE istruzione, 34
Percolazione, 148
PRINT istruzione, 40
priorita-istruzioni, 15
PROGRAM, 16
187
INDICE ANALITICO
INDICE ANALITICO
FAI-PUNTI, 151
FEIGEN, 115
FELCI, 126
FIT, 106
G05DYFZAN, 98
GAMMA, 85
GAMMLN, 85
GAMMP, 89
GAMMQ, 89
GASDEV, 100
GCF, 90
GSER, 90
GX, 132
HENON10, 112
MAKEPIANTA3, 130
MATRICE, 160
MAXMIN, 174
MOMENT, 102
RAN0, 97
RETTA90, 163
SCRIVIDATI, 41
TTTEST, 104
UNO, 118
WO, 134
SUBROUTINE istruzione, 18
PROGRAMMA
CAVEN, 60
GAUSS, 74
PARABO, 50
PENDO, 52
RETTA, 47
testc2, 80
testt, 79
R
READ istruzione, 39
REAL istruzione, 5
REAL variabile, 6
record, 35
relazioni, 12
relazioni-logiche, 13
RETURN istruzione, 21
REWIND istruzione, 40
S
SAVE istruzione, 26
scheda, 3
sottostringhe, 8
STOP istruzione, 34
SUBROUTINE
AVEVAR, 105
BA, 142
BETA, 88
BETACF, 94
BETAI, 93
BICO, 87
CLEANTOP, 173
DUETUTTO, 119
ERF, 92
ERFC, 92
EXPDEV, 99
FACTLN, 87
FACTRL, 86
FAI-CLUSTER, 156
T
test
medie, 103
tipi, 5
TYPE istruzione, 40
U
UNIX
cp, 176
exit, 176
joe, 176
ls, 175
man, 175
188
INDICE ANALITICO
INDICE ANALITICO
mv, 176
rm, 176
V
vettori, 8
W
WRITE istruzione, 39
189

Fortran

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fortran

Uploaded by

Copyright:

Available Formats

Guida al FORTRAN

5 Sistemi Monte Carlo

B Subroutine di interesse comune

C.5 Le librerie . . . . . . . . . . . . . . . . . . . . . . . . . . 180

1.1. ALCUNI LIBRI

Prima di continuare introduciamo brevemente una lista di libri che

L insieme dei caratteri in FORTRAN consiste di 26 lettere dalla A alla

1.3. LUNGHEZZA DELLA LINEA

Attualmente il simbolo corrente pu`o avere un valore diverso a seconda

Lunghezza della linea

Il compilatore fa uso solamente delle prime 72 colonne in ogni linea:

Qualsiasi linea con i caratteri C o * in prima colonna viene considerata

Linea iniziale e di continuazione

Una linea di istruzione `e caratterizzata da uno spazio oppure da uno

1.5. LINEA INIZIALE E DI CONTINUAZIONE

Figura 1.1: La scheda

1.6. NOMI SIMBOLICI

colonna 1 alla colonna 5 e il simbolo di continuazione in colonna 6.

Nomi locali e globali

Un istruzione di etichetta `e un numero intero da 0 a 99999, senza segno,

Tipi di dati e costanti

1.13. TIPO REAL

macchina a macchina e nel UNIX-FORTRAN abbiamo:

Ogni variabile REAL memorizza un numero in virgola mobile, con o

da 0.56E 308 a 0.9E + 308

Una costante reale deve contenere un punto ( che rappresenta la

Sul UNIX-FORTRAN una variabile real *4 ( precisione singola ) occupa

Tipo DOUBLE PRECISION

La DOUBLE PRECISION `e simile a quella REAL ma memorizza un

Sul UNIX-FORTRAN una variabile real*8 (o doppia precisione) occupa

1.15. TIPO COMPLEX

Una variabile COMPLEX consiste in un paio ordinato di numeri reali,

Le stringhe sono definite da apostrofi () o virgolette (). La costante di

Un vettore `e un set ordinato di dati (tutti dello stesso tipo) riferito ad

1.19. SOTTOSTRINGA CHARACTER

devono essere dichiarati nelle istruzioni COMMON o DIMENSION.

Una sottostringa specifica un set di caratteri adiacenti dislocati in una

1.21. ESPRESSIONI ARITMETICHE

Un espressione aritmetica `e usata per specificare un calcolo numerico

L ordine di valutazione di un espressione `e:

CAPITOLO 1. IL FORTRAN-77 1.22. ESPRESSIONI COSTANTI INTERE

Altrimenti la potenza è calcolata con i logaritmi cosicchè A**B sarà

Espressioni costanti intere

Le espressioni aritmetiche in cui tutti gli operandi siano costanti o nomi

1.24. ESPRESSIONI DI RELAZIONE

Ambedue gli apostrofi sono richiesti .

Un espressione di relazione d`a un risultato di tipo logico (vero o falso)

1.25. ESPRESSIONI LOGICHE

Le variabili confrontate devono essere omogenee e ovviamente in campo

Un espressione logica consiste di operandi e operatori logici e ritorna

1.26. STRUTTURA DEL PROGRAMMA

Tabella 1.1: Tabella sugli operatori OR e AND

L1.OR.L2 L1.AN D.L2

L effetto degli operatori.OR. d`a come risultato .true. se `e vero uno

Struttura del programma

Un programma deve contenere un corpo principale, detto main. Pu`o

1.27. CLASSI DI ISTRUZIONE

Tabella 1.2: Tabella sugli operatori EQV e NEQV

L1.EQV.L2 L1.N EQV.L2

Possiamo chiamare istruzioni tipologiche INTEGER, REAL, DOUBLE

Ordine delle istruzioni

1.28. ORDINE DELLE ISTRUZIONI

Questo significa, per esempio, che se si usa una istruzione di tipo

DELTA = (-1)**P2 * P1**(2P2+1) / FACTRL(2P2+1)

VAB (X,Y,Z) = SQRT (XX2 +Y2 +Z**2)

CHARACTER () TITLE