FORTRAN

Transcript

FORTRAN

UNINA2 – INGEGNERIA MECCANICA/AEROSPAZIALE
ELEMENTI DI PROGRAMMAZIONE – a.a. 2012/13
FORTRAN
Documentazione di riferimento:
1.
2.
3.
4.
5.
CHAPMAN S.J. , Fortran 90/95 , McGraw-Hill
RAUCCI B., Il Linguaggio Fortran 90/95, web
ADAMS J. C., BRAINERD W. S., MARTIN J. T., SMITH B. T., WAGENER J. L., Fortran 90 Handbook,
McGraw-Hill (web)
WAGENER J. L., Concise Fortran 90/95 Reference, Absoft corporation (web)
CHIVERS I. D. and SLEIGHTHOLME J., Introduction to Programming with Fortran, Springer (web)
Ambienti di sviluppo:
http://www.lepsch.com/2009/05/downloads.html
- Force 2.0.9 plus GNU Fortran (GFortran)
- Force 2.0.9 plus G95 Fortran (G95)
Prof. Andrea Prevete
STRUTTURA DEI PROGRAMMI
Un progetto Fortran consiste – in generale - di un insieme di unità di
programma compilate separatamente. Una delle suddette unità – nei
progetti più semplici l’unica! – deve essere il cosiddetto programma
principale, cioè una sequenza di istruzioni e linee di commento
opzionali aperta e chiusa dalle keyword PROGRAM ed END
PROGRAM.
PROGRAM nome-programma
IMPLICIT NONE
[sezione dichiarativa]
[sezione esecutiva]
[eventuali sottoprogrammi interni]
END PROGRAM nome-programma
COMMENTI
I commenti, opzionali, sono preceduti dal segno ‘!’. Tutto
il testo che segue il suddetto segno, fino alla fine della
linea, non ha rilevanza ai fini dell’esecuzione del
programma.
! Programma esempio
!
PROGRAM Comment
..........
READ(*,*) x
! Leggi il valore di x
..........
x = x + 1
! incrementa x di un’unità
..........
END PROGRAM Comment
ISTRUZIONI LUNGHE
Alcune regole di base:
1) Un’istruzione per linea!
2) Se un’istruzione è troppo lunga è consentito andare
daccapo, utilizzando il carattere ‘&’.
PROGRAM &
Daccapo
! PROGRAM Daccapo
Perimetro = BaseMaggiore + BaseMinore + &
Lato1 + Lato2
! Perimetro = BaseMaggiore + BaseMinore + Lato1 + Lato2
ALFABETO
I caratteri riconosciuti da Fortran includono le lettere dell’alfabeto,
minuscole e maiuscole, le cifre numeriche ed un set di caratteri
speciali:
space
'"
()*+-/:=
_!&$;<>
%?,.
ATTENZIONE: Fortran è CASE INSENSITIVE, cioè non fa differenza
fra maiuscole e minuscole – in un senso che preciseremo meglio in
seguito.
LITERALS
Le costanti letterali o manifeste (o
semplicemente literals) rappresentano valori
fissi, numerici o alfabetici, utilizzati dal
progettista nell’ambito di un’istruzione.
In Fortran è possibile rappresentare
esplicitamente numeri interi, numeri reali,
numeri complessi, oppure valori logici,
oppure ancora stringhe di caratteri.
INTERI
Nelle istruzioni che seguono a destra del
simbolo di assegnazione (=) è presente un
literal che rappresenta un intero:
X=12345
X=-345
X=+789
X=+0
REALI
Nelle istruzioni che seguono a destra del
simbolo di assegnazione (=) è presente un
literal che rappresenta un reale:
X=2.45
X=.13
X=13.
X=-0.12
X=-.12
ANCORA REALI
Un literal per un reale può essere
rappresentato in forma esponenziale
utilizzando i caratteri ‘E’ oppure ‘e’, come
negli esempi che seguono:
X=12.E3
X=-12.e3
X=3.45E-8
X=-3.45e-8
!12×103
!-12×103
!3.45×10-8
!-3.45×10-8
ANCORA REALI
Negli esempi precedenti i simboli ‘e’ ed ‘E’ potevano essere
sostituiti da ‘d’ e ‘D’, col significato di forzare
un’interpretazione in doppia precisione del reale.
E’, infatti, importante ricordare che una costante di tipo
REAL viene registrata in memoria in due parti: la mantissa
e l’esponente.
Il numero di bit allocati per la mantissa determina la
precisione della costante (ossia il numero di cifre
significative), mentre il numero di bit allocati per
l’esponente determina il range della costante (ossia
l’intervallo dei valori che possono essere rappresentati).
COMPLESSI
Un literal per rappresentare un numero
complesso è una coppia di parentesi che
racchiudono due literal per reali separati
da una virgola:
X=(1., 0.) ! 1+0i
X=(1.5, 2.) !1.5+2i
STRINGHE
Una stringa di caratteri è una sequenza di caratteri
qualsiasi delimitata indifferentemente da singoli o
doppi apici:
X=“abc”
X=‘John Dow’
X=“#$%^”
X=‘()()’
La lunghezza di una stringa corrisponde al numero
di caratteri in essa contenuta, compresi gli
eventuali caratteri-spazio.
ANCORA SULLE STRINGHE
Una stringa di lunghezza 0 è una empty string:
X=“”
Se una stringa contiene apici singoli (doppi)
occorre usare apici doppi (singoli) come
delimitatori:
X=“L’avevo detto!”
X=‘Gli dissi: “va via!”’
Due apici consecutivi sono trattati come uno:
‘L’’ hai visto?’ ! L’hai visto?
VERO E FALSO
Due literal speciali,
.FALSE. e .TRUE.
Sono utilizzati per rappresentare i valori
logici VERO e FALSO.
Attenzione ai punti delimitatori, sono
richiesti!
IDENTIFICATORI
• Un IDENTIFICATORE di Fortran 90 non può avere più di
31 caratteri
• Il primo carattere deve essere una lettera, seguita da
altre lettere, cifre, il simbolo ‘_’.
• Come già detto Fortran 90 è case insensitive, quindi
Nome, NOME, nome .. sono lo stesso identificatore.
• A differenza di altri linguaggi (C, Java, etc) Fortran 90
non ha parole riservate. Comunque è buona
consuetudine non utilizzare keyword del linguaggio
(PROGRAM, IF, WHILE, etc) come identificatori, anche
per non penalizzare la leggibilità del codice.
DICHIARAZIONI
Una dichiarazione di Fortran 90 è un’ espressione del tipo:
specificatore-di tipo :: lista di oggetti
dove lo specificatore-di tipo è una delle seguenti keyword:
INTEGER, REAL, LOGICAL, COMPLEX and
CHARACTER
mentre la lista di oggetti è una sequenza di identificatori
(per variabili, parametri, funzioni) - separati da virgole.
Esempio:
INTEGER :: x, y, z
COMPLEX :: w
DICHIARARE STRINGHE
Una menzione a parte meritano le dichiarazioni di
variabili di tipo carattere.
CHARACTER :: c
dichiara una variabile che può contenere giusto un
carattere.
Se voglio dichiarare variabili di tipo stringa di
caratteri devo utilizzare lo specificatore LEN, per
esempio:
CHARACTER(LEN=10) :: s
dichiara una variabile stringa di lunghezza 10.
PARAMETER
Una identificatore con attributo PARAMETER fa
riferimento ad un valore fisso, definito subito nella
dichiarazione e non più modificabile durante il ciclo
di vita di un programma.
REAL, PARAMETER :: pigreco = 3.14
Nell’esempio pigreco identifica appunto un
parametro di tipo intero, fissato già nella
dichiarazione al valore 3.14 e non più modificabile.
COSTANTI STRINGHE
Per le stringhe di caratteri l’uso dell’attributo
PARAMETER è spesso combinato con la
specificazione LEN=* che lascia al compilatore
contare i caratteri della stringa fissa.
Esempi:
CHARACTER(LEN=3), PARAMETER :: x = “non”
CHARACTER(LEN=2), PARAMETER :: y = “si”
CHARACTER(LEN=*), PARAMETER :: &
z = “cosa vuoi che faccia?”
VARIABILI
Le variabili sono la classe di dati più importante di un
programma. Hanno un tipo, un nome (identificatore) ed un
valore.
Il valore è tipicamente impostato nella fase iniziale di un
programma già come parte della dichiarazione o con
un’assegnazione esplicita, oppure immesso dall’utente a
tempo di esecuzione - per esempio da tastiera.
REAL :: x=1.21
! È dichiarata la variabile intera x ed inizializzata al ! valore
1.21
REAL :: x
….
x=1.21 ! assegnazione esplicita
READ
INTEGER :: i, j
READ(*,*) i, j
Le linee di programma sopra riportate dichiarano
le variabili intere i e j e, quindi, consentono
all’utente di inizializzarle dal dispositivo standard
d’input, la tastiera.
Complementare alla precedente è l’istruzione
WRITE(*,*) i, j
Il cui effetto sarebbe la riproduzione sul dispositivo
standard d’output – il monitor – dei valori delle
variabili i e j.
READ e WRITE
Consideriamo il semplicissimo programma:
PROGRAM esempio
INTEGER :: i, j, k, l
READ (*,*) i, j
READ (*,*) k, l
WRITE (*,*) i, j, k, l
END PROGRAM esempio
READ e WRITE (bis)
Supponiamo di eseguirlo e di rispondere alla
richiesta di input con le linee:
1
2, 3, 4
5, 6, 7, 8
Avremmo poi il seguente output:
1256
Perché?
ASSEGNARE UN VALORE
La più semplice fra le istruzioni esecutive del Fortran è
l’istruzione di assegnazione, la cui sintassi è la seguente:
variabile = espressione
con il significato che il risultato di espressione viene
immagazzinato nella locazione di memoria assegnata alla
variabile.
L’esecuzione dell’istruzione produce, nell’ordine:
• il calcolo di espressione, il cui risultato viene valutato
secondo le regole proprie del tipo dell’espressione;
• la conversione di tipo, quando prevista e se il tipo di
espressione non coincide con quello di variabile;
• l’immagazzinamento del risultato nella locazione di
memoria relativa a variabile .
ASSEGNAZIONI ED ESPRESSIONI
Una espressione Fortran è una qualunque combinazione di operandi
ottenuta tramite operatori e parentesi tonde; l’esecuzione delle
operazioni indicate dagli operatori dà luogo ad un risultato detto valore
dell’ espressione. Si osservi che anche un singolo operando costituisce
un’ espressione.
Dunque l’istruzione di assegnazione calcola il valore dell’espressione a
destra del segno di uguale e assegna tale valore alla variabile
specificata a sinistra del segno di uguale. Si noti che il simbolo ”=” non
indica uguaglianza secondo il significato comune del termine. Piuttosto
un’istruzione di assegnazione va interpretata come: ”registra il valore di
espressione nella locazione di memoria di variabile ”. E’ solo in tal
modo che assumono un senso istruzioni di ”aggiornamento” del tipo
seguente:
INTEGER :: count=0
count = count+1
ESPRESSIONI MATEMATICHE
Tutti i calcoli effettuati da un programma Fortran vengono specificati
attraverso istruzioni di assegnazione il cui formato generale è il
seguente:
variabile = espressione_matematica
L’esecuzione di una istruzione di questo tipo avviene calcolando prima
il valore di espressione aritmetica e poi memorizzando poi tale valore
nella cella identificata dal nome variabile .
Si noti, tuttavia, che se il tipo dell’espressione non coincide con quello
della variabile a primo membro, allora il valore dell’espressione viene
convertito al modo seguente:
•Se il tipo di variabile è INTEGER mentre il tipo di espressione è REAL
allora la parte decimale, incluso il punto, viene rimosso dando luogo ad
un risultato intero.
•Se il tipo di variabile è REAL mentre il tipo di espressione è INTEGER
allora al valore (intero) del risultato viene aggiunto il punto decimale
dando così luogo ad un valore reale.
ESPRESSIONI MATEMATICHE(bis)
INTEGER :: totale, prezzo, numero
numero = 5
prezzo = 100.65
totale = numero*prezzo
WRITE(*,*) numero,prezzo,totale
Le precedenti istruzioni dichiarano, dapprima, tre variabili di tipo
INTEGER. Quindi, ha luogo la prima istruzione di assegnazione che
salva il valore intero 5 nella variabile numero. La seconda istruzione
salva il valore approssimato 100.65 nella variabile prezzo. Tuttavia, dal
momento che prezzo è una variabile intera, il valore reale 100.65 viene
dapprima troncato all’intero 100 e poi immagazzinato nella variabile.
Infine, la terza assegnazione calcola il valore dell’espressione 5*100 e
ne salva il risultato (500) nella variabile totale. Pertanto l’istruzione di
scrittura fornirà il seguente risultato:
5 100 500
ESPRESSIONI MISTE
Tutte le operazioni aritmetiche viste finora erano applicate ad operandi dello stesso tipo
ed il tipo del risultato coincideva con quello degli operandi. E’ tuttavia possibile utilizzare
in una stessa espressione operandi di tipo diverso dando luogo a quelle che vengono
dette operazioni miste. Le espressioni che contengono una o più operazioni miste si
chiamano espressioni miste.
Per quanto concerne il tipo del risultato, vale la regola generale secondo cui se il tipo di
due operandi non è lo stesso, quello più ”debole” viene automaticamente modificato in
quello più ”forte” mediante una operazione, detta di conversione, che permette il
passaggio da una rappresentazione interna ad un’altra. Questo processo di conversione
è subordinato alla seguente gerarchia fra i tipi degli operandi:
COMPLEX più forte
REAL #
INTEGER più debole
Un’operazione che coinvolga sia operandi interi che reali è un esempio di operazione
mista. Quando un compilatore incontra una operazione del genere, converte il valore
dell’operando intero in valore reale sicché l’operazione viene svolta con operandi reali. A
titolo di esempio si possono considerare le seguenti espressioni:
3/2 espressione intera risultato: 1 (intero)
3./2. espressione reale risultato: 1.5 (reale)
3./2 espressione mista risultato: 1.5 (reale)
ESPRESSIONI MISTE
Tuttavia, la conversione automatica viene effettuata soltanto se
l’operando intero e quello reale compaiono nella stessa operazione. Di
conseguenza, una parte dell’espressione potrebbe essere valutata
come una espressione intera e una parte come espressione reale. Ad
esempio, la seguente espressione:
1/2 + 1./4.
fornisce il valore 0.25 (che coincide con il valore del secondo
argomento della somma) in quanto la prima operazione, avvenendo fra
operandi interi, restituisce un valore intero, nella fattispecie il valore 0.
Se, invece, la prima operazione fosse stata di natura mista, come ad
esempio:
1./2 + 1./4.
avrebbe avuto luogo una conversione automatica tale che il valore
(reale) della prima operazione sarebbe stato 0.5 e, dunque, il valore
dell’intera espressione sarebbe stato 0.75, ben diverso da quello fornito
dall’espressione precedente.
PRIORITA’ OPERATORI
FUNZIONI INTRINSECHE IMPORTANTI
FUNZIONI DI CONVERSIONE
ALTRE FUNZIONI NOTEVOLI
FUNZIONI PER IL TIPO CHARACTER
ICHAR(C)
Restituisce la posizione occupata dalla variabile C, di tipo
CHARACTER, nel sistema di codifica utilizzato dall’elaboratore,
associato al parametro di kind dell’argomento. Il risultato, che è di
tipo INTEGER, è un valore compreso tra 0 ed n-1, essendo n il numero
di caratteri del sistema di codifica adottata dal processore.
CHAR(I[,KIND])
Restituisce il carattere che occupa la posizione I nella sequenza di
collating del processore, associato al parametro di kind KIND
opzionalmente specificato. Gli argomenti I e KIND devono entrambi di
tipo intero. In particolare il valore di I deve essere compreso tra 0 ed n1, essendo n il numero di caratteri del sistema di codifica adottato dal
processore. La funzione CHAR è l’inversa di ICHAR.
IACHAR(C)
Restituisce la posizione occupata dalla variabile C, di tipo CHARACTER,
nel sistema di codifica ASCII. Il risultato, che è di tipo INTEGER, è un
valore compreso tra 0 ed n-1, essendo n il numero di caratteri del sistema
di codifica adottata dal processore. Ad esempio, se i è una variabile di tipo
INTEGER, l’istruzione:
i = IACHAR(’W’) ! restituisce il valore 87.
ACHAR(I)
Restituisce il carattere corrispondente alla posizione I nella tabella ASCII.
Se I è compreso tra 0 e 127, il risultato fornito è effettivamente l’I_mo
carattere della tabella; se, invece, I è maggiore di 127, il risultato sarà
dipendente dal processore.
Ad esempio, se a è una variabile di tipo CHARACTER, l’istruzione:
a = ACHAR(87) ! restituisce il valore ’W’.
ADJUSTL(STRING)
Restituisce la stringa STRING giustificata a sinistra. In altre parole
rimuove i bianchi di testa e li sposta in coda.
Esempio:
CHARACTER(LEN=16) :: str
str = ADJUSTL(’ Fortran 90 ’) ! restituisce: ’Fortran 90 ’
ADJUSTR(STRING)
Restituisce la stringa STRING giustificata a destra. In altre parole
rimuove i bianchi di coda e li sposta in testa.
Esempio:
str = ADJUSTR(’ Fortran 90 ’) ! restituisce: ’ Fortran 90’
INDEX(STRING,SET[,BACK])
Se la variabile logica BACK è assente o vale .FALSE. restituisce la
posizione di partenza di SET nella stringa STRING. Se la variabile
logica BACK vale .TRUE. allora la funzione restituisce la posizione di
partenza dell’ultima occorrenza. Il valore ritornato è zero nel caso in cui
SET non sia presente in STRING.
Esempio:
INTEGER :: i
...
i = INDEX(’particolari’,’ar’,BACK=.TRUE.) ! ris: i = 9
i = INDEX(’particolari’,’ar’) ! ris: i = 2
i = INDEX(’particolari’,’or’) ! ris: i = 0
LEN(STRING)
Restituisce la lunghezza della stringa STRING omprensiva degli eventuali spazi bianchi di
coda.
Esempio:
CHARACTER(LEN=11) str
INTEGER :: i
...
i = LEN (str) ! restituisce 11
i = LEN(’Una frase con 6 spazi bianchi ’) ! restituisce 30
LEN_TRIM(STRING)
Restituisce la lunghezza della stringa STRING depurata degli eventuali spazi bianchi di coda.
Se STRING è completamente ”bianca”, il valore restituito è zero.
Esempio:
CHARACTER(LEN=11) str
INTEGER :: i
...
i = LEN (’ ’) ! restituisce 0
i = LEN(’Una frase con 6 spazi bianchi ’) ! restituisce 24
LGE(STRING_A,STRING_B)
Restituisce il valore .TRUE. se STRING_A >= STRING_B secondo la sequenza di collating
ASCII.
Gli argomenti STRING_A e STRING_B devono essere stringhe di caratteri con kind di default.
Esempio:
LOGICAL :: l
...
l = LGE(’abc’,’abd’) ! ris: .FALSE.
l = LGE (’ab’,’aaaaaaab’) ! ris: .TRUE.
LGT(STRING_A,STRING_B)
Restituisce il valore .TRUE. se STRING_A > STRING_B secondo la sequenza di collating
ASCII.
Esempio:
LOGICAL :: l
...
l = LGT(’abc’,’abc’) ! ris: .FALSE.
l = LGT(’abc’,’aabc’) ! ris: .TRUE.
LLE(STRING_A,STRING_B)
Restituisce il valore .TRUE. se STRING_A <= STRING_B secondo la sequenza di collating
ASCII.
Esempio:
LOGICAL :: l
...
l = LLE(’ABC’,’ABC’) ! ris .TRUE.
l = LLE(’ABC’,’AABCD’) ! ris .FALSE.
LLT(STRING_A,STRING_B)
Restituisce il valore .TRUE. se STRING_A < STRING_B secondo la sequenza di collating
ASCII.
Esempio:
LOGICAL :: l
...
l = LLT(’abc’,’abd’) ! ris: .FALSE.
l = LLT(’aaxyz’,’abcde’) ! ris: .TRUE.
REPEAT(STRING,NCOPIES)
Restituisce una stringa formata concatenando NCOPIES copie di STRING una dietro l’altra. Se
STRING è completamente ”bianca” e NCOPIES vale zero, la stringa restituita avrà lunghezza nulla.
Esempio:
str = REPEAT(’ho’,3) ! restituisce la stringa ’hohoho’
SCAN(STRING,SET[,BACK])
Restituisce la prima ricorrenza di un carattere di SCAN in STRING operando una ”scansione” da
sinistra. Se il parametro opzionale BACK è presente e vale .TRUE. la scansione avviene da destra ma
il ”conteggio” avviene ancora da sinistra. Se BACK vale .TRUE. la scansione viene effettuata da
destra e la funzione restituisce la posizione dell’ultima ricorrenza di un carattere di SCAN in STRING.
Se nessun carattere di SET si trova anche in STRING, oppure se la lunghezza di SET o di STRING è
nulla, la funzione restituisce il valore zero. Gli argomenti SET e STRING sono stringhe di caratteri
mentre l’argomento opzionale BACK deve essere di tipo LOGICAL.
Esempio:
INTEGER :: i
...
i = SCAN (’Fortran’,’tr’) ! ris: i = 3
i = SCAN (’Fortran’,’tr’, BACK=.TRUE.) ! ris: i = 5
i = SCAN (’Fortran’,’for’) ! ris: i = 0
TRIM(STRING)
Restituisce la stringa STRING depurata dagli eventuali
spazi bianchi di coda. Se STRING è completamente
”bianca”, il valore restituito è una stringa nulla.
Esempio:
! Questa istruzione stampa il valore 31
WRITE(*,*) LEN( Stringa con caratteri bianchi )
! Questa istruzione stampa il valore 26
WRITE(*,*) LEN(TRIM( Stringa con caratteri bianchi ))
VERIFY(STRING,SET[,BACK])
Restituisce la posizione della prima ricorrenza di un carattere di STRING che
non è presente in SET operando la ”scansione” da sinistra. Se la variabile
opzionale BACK è presente con valore .TRUE. allora la funzione restituisce la
posizione dell’ultima ricorrenza di un carattere di STRING che non è presente
in SET. Il risultato della funzione è zero se tutti i caratteri di STRING sono
presenti in SET.
Se tutti i caratteri di STRING sono presenti anche in SET oppure se entrambe
le stringhe hanno lunghezza nulla, la funzione restituisce il valore zero.
Esempio:
INTEGER(4) position
...
position = VERIFY (’particolari’,’prtl’) ! ris: position = 2
position = VERIFY (’particolari’,’prtli’, BACK=.TRUE.) ! ris: position = 9
position = VERIFY (’rosso’,’rso’) ! ris: position = 0
SPECIFICATORI DI RANGE
Una specifica di sottostringa seleziona una ”porzione” di
una variabile di caratteri e tratta questa variabile come se
fosse una variabile stringa indipendente. La porzione di
stringa selezionata è chiamata sottostringa.
Una sottostringa viene selezionata (estratta) ”appendendo”
al nome della variabile stringa uno specificatore di range.
Quest’ultimo ha la forma:
(inizio : fine )
Ad esempio, data la stringa così dichiarata:
CHARACTER(LEN=8) :: stringa="abcdefgh"
possibili esempi di sottostringa sono:
stringa(2:4) ! "bcd"
stringa(3:7) ! "cdefg"
CONCATENAZIONE DI STRINGHE
L’operatore di concatenazione di stringhe combina
due o più stringhe (o sottostringhe) a formare
un’unica stringa più grande. Esso è rappresentato
dal simbolo di un doppio slash (”//”). La forma
generale di questo operatore è la seguente:
stringa_1 //stringa_2 [// stringa_3 ...]
in cui, se le stringhe stringa_1 e stringa_2 hanno
lunghezza n_1 ed n_2 , rispettivamente, la
lunghezza della stringa finale sarà n_1+n_2 .
CONCATENAZIONE DI STRINGHE
L’operatore di concatenazione di stringhe combina
due o più stringhe (o sottostringhe) a formare
un’unica stringa più grande. Esso è rappresentato
dal simbolo di un doppio slash (”//”). La forma
generale di questo operatore è la seguente:
stringa_1 //stringa_2 [// stringa_3 ...]
in cui, se le stringhe stringa_1 e stringa_2 hanno
lunghezza n_1 ed n_2 , rispettivamente, la
lunghezza della stringa finale sarà n_1+n_2 .
RELAZIONE D’ORDINE FRA STRINGHE
Il processo mediante cui due operatori stringa vengono confrontati si
articola nei seguenti passi:
- Se i due operandi non hanno la stessa lunghezza, al più corto dei due
vengono idealmente aggiunti spazi bianchi in modo da rendere le
stringhe di uguale lunghezza.
- I due operandi vengono confrontati carattere per carattere a partire
dal primo (ossia da quello più a sinistra) fino a quando non vengono
riscontrati due caratteri differenti oppure fino al raggiungimento della
fine delle stringhe.
- Se vengono trovati due caratteri corrispondenti differenti, allora è la
relazione tra questi due caratteri che determina la relazione tra i due
operandi. In particolare viene considerato ”minore” il carattere che
viene prima nella sequenza di collating del processore. Se non viene
riscontrata alcuna differenza le due stringhe vengono considerate
uguali.
ESEMPI:
"Adamo" > "Eva“ è falsa in quanto in qualunque sequenza di collating la
lettera A precede sempre la E, ossia A è minore di E. Allo stesso modo, la
relazione:
"Eva" < "Evaristo“ è vera poiché la stringa Eva viene prolungata con
cinque caratteri vuoti e la relazione fra le due stringhe si riduce alla
relazione:
" " < "r“
e il carattere nullo precede tutti i caratteri alfanumerici.
Si noti, tuttavia, che le relazioni:
"ADAMO" < "Adamo"
"X4" < "XA"
"var_1" < "var-1“
non sono definite in Fortran ed il valore di ciascuna di esse dipende dalla
particolare sequenza di collating implementata dal processore in uso.
Se, per ragioni di portabilità, fosse richiesta la definizione di un ordine
per tutti i caratteri allora è necessario fare uso di un altro metodo di
confronto. Questo nuovo metodo si basa sull’utilizzo di quattro funzioni
intrinseche lessicali : LGT, LGE, LLE, LLT, la cui sintassi è:
LGT(STRING_A,STRING_B)
LGE(STRING_A,STRING_B)
LLE(STRING_A,STRING_B)
LLT(STRING_A,STRING_B)
ed il cui significato è, rispettivamente:
STRING_A > STRING_B
STRING_A >= STRING_B
STRING_A <= STRING_B
STRING_A < STRING_B
sempre e soltanto secondo l’ordinamento ASCII
THE END

FORTRAN

Transcript

Documenti analoghi

CONTROLLO DI STRINGA

1994 - Processo per l`omicidio di Carlo D`Andrea

versione

Classe String Metodi della classe String

Prevete Chiara - Scuola Superiore Sant`Anna

FORTRAN:

Secondo Appello 13/6/2001 - Dipartimento di Informatica

Andrea Pecile

Centro Culturale Turco presso L`Ambasciata Turca E` lieto di invitarvi