Ancora Fortran

Questa è la continuazione dal post precedente. Poi basta, c’è parecchia altra roba più interessante in giro.

Nel Fortran 90/95 abbiamo l’istruzione select case, proprio come nel Basic, il do, quello che tutti gli altri chiamano for, è molto generalizzato e fa anche quello che altrove fa while; c’è exit e cycle (che sarebbe la continue degli altri linguaggi, continue in Fortran c’è ma fa un’altra cosa, since 1954).
Finalmente sono stati introdotti gli array dinamici e i puntatori per gestirli; questi sono diversi da quelli del C, cioè si usano in modo diverso, anzi nemmeno questo, bisogna provare…, ci sono anche operatori globali per gli array che semplificano il codice e velocizzano l’esecuzione.
Dove i cambiamenti sono maggiori è nella parte non eseguibile (dichiarativa) del linguaggio. Sono stati introdotti i moduli, le procedure possono essere interne o esterne; questo influisce sulla vita e visibilità delle variabili.
Molto ampliata la fase di dichiarazione, con possibilità, tra l’altro, di definire record (struct in C). Come nel C abbiamo le interfacce (i file .h del C). Queste permettono (finalmente) di distinguere i parametri passati a funzioni e procedure come parametri in lettura, scrittura e lettura-scrittura.
Le procedure possono essere ricorsive, a volte serve, credo anche ai fortranisti.
Da sempre in Fortran esistono le funzioni generiche (es. la MAX() è in grado di sapere se gli argomenti sono interi o reali e restituire il valore appropriato in base al tipo di variabile a sinistra del segno =); adesso è possibile costruire le proprie funzioni generiche, ecco servito il polimorfismo. E c’è anche l’operator overloading.
Inoltre ci si è liberati del formato fisso, probabilmente nessuno usa più le schede perforate; le righe possono essere più lunghe, non bisogna più fare attenzione a colonna 73.
Nel 2005 sono uscite altre specifiche (Fortran 2003), e si continua tuttora (Fortran 2008), ci sono tentativi di standardizzare il calcolo parallelo.
Ma in ogni caso restano anche tutti i costrutti antichi: io qualche mese fa ho portato su gfortran un programma di calcolo vecchio più di 20 anni, le modifiche richieste sono state davvero minime. Certo un programmatore oggi lo scriverebbe in modo diverso: sono diventato vecchio!
Scrivendo queste note mi si è installato nella mente un virus quesito cui non so rispondere e del quale non riesco a liberarmi: se Micro$oft et al. non avessero diffuso la leggenda che il Basic è più semplice e avessero prodotto compilatori Fortran come si deve o se Linus Torvalds fosse nato 10-15 anni prima sono sicuro che il mondo informatico di oggi sarebbe diverso. O no? Ma qualcuno diceva così anche prima, riferendosi a Algol, poi diventato Pascal (che a me piaceva parecchio).

Operazione nostalgia

* : ~/bin $ whereis gfortran
gfortran: /usr/bin/gfortran /usr/share/man/man1/gfortran.1.gz
* : ~/bin $ ln -s /usr/bin/gfortran-4.4 ftn

d’ora in poi posso di nuovo invocare il compilatore Fortran, inteso come gfortran con ftn 😉

Argomenti sulla riga di comando

Clive Page’s list of Fortran Resources ha notizie interessanti, tra le quali le librerie grafiche e come leggere gli argomenti passati sulla linea di comando:

  • COMMAND_ARGUMENT_COUNT() – This is an integer function returning the number of argument strings on the command-line (excluding the initial command-name if there is one).
  • CALL GET_COMMAND_ARGUMENT(number, value, length, status) – This is a subroutine returning the string value of the Nth argument (argument 0 being the command-name). The length (optional) returns the length of the value returned, and status (also optional) returns 0 normally, or non-zero if there is an error such as a non-existing argument).
program arghhh!!! come direbbe il pirata pastafariano che è in me

implicit none
integer :: argnum, cont, arglung, error
character(len=40) :: arg

argnum = command_argument_count()
print *, argnum, 'argomenti sulla riga di comando'

do cont = 1, argnum
    call get_command_argument(cont, arg, arglung, error)
    print *, cont, arglung, error
    print *, arg
end do

end program arghhh

Compilazione ed esecuzione:

* : /media/algol/lab/OKp/fortran $ ftn -o arghhh -ffree-form arghhh.f
* : /media/algol/lab/OKp/fortran $ ./arghhh alpha beta "gamma delta" 'epsilon e tutti gli altri'
           4 argomenti sulla riga di comando
           1           5           0
 alpha
           2           4           0
 beta
           3          11           0
 gamma delta
           4          25           0
 epsilon e tutti gli altri
* : /media/algol/lab/OKp/fortran $

Introducendo i format si può controllare l’output

program arghhh!!! come direbbe il pirata pastafariano che è in me

implicit none
integer :: argnum, cont, arglung, error
character(len=40) :: arg

argnum = command_argument_count()
print 10, argnum, 'argomenti sulla riga di comando'

do cont = 1, argnum
    call get_command_argument(cont, arg, arglung, error)
    print 11, cont, arglung, error
    print 12, arg
end do

!formats
10 format(i4,1x,a)
11 format(3(i3))
12 format(a)

end program arghhh

* : /media/algol/lab/OKp/fortran $ ftn -o arghhh-f -ffree-form arghhh-f.f
* : /media/algol/lab/OKp/fortran $ ./arghhh-f alpha beta "gamma delta" 'epsilon e tutti gli altri' "e una riga troppo lunga che viene troncata"
5 argomenti sulla riga di comando
  1  5  0
alpha
  2  4  0
beta
  3 11  0
gamma delta
  4 25  0
epsilon e tutti gli altri
  5 40 -1
e una riga troppo lunga che viene tronca
* : /media/algol/lab/OKp/fortran $

Operazione nostalgia, nuova ricaduta

Questo è il minicomputer che usavo io, il Prime 550. Il mio aveva un solo hard disk (80 MB) e un’unità nastro sul pannello dove si intravede la scritta “PR1ME 550”. A proposito di dischi: le dimensioni si possono immaginare dai loro contenitori; se si toglievano dall’unità bisognava proteggerli dalla polvere perché non erano sottovuoto e (diceva il manuale) bastava una particella di fumo per mandarlo in crash. Vietato fumare! La cosa più grossa della stanza era comunque il condizionatore perché il ‘puter scaldava peggio di una stufa.
L’immagine è presa da qui. Se scorrete la pagina nell’immagine successiva vedete in primo piano anche la stampante: sigh! bei tempi, allora 😀

Annunci
Post a comment or leave a trackback: Trackback URL.

Commenti

  • Marco  On 20 agosto 2010 at 14:40

    Ma del blocco COMMON non vogliamo parlare (e delle ore spese a debuggare)? 😉

  • juhan  On 20 agosto 2010 at 14:46

    Marco è un piacere vederti qui!
    E vedo che frequenti il Fortran, e hai avuto a che farci con quello di quando gli INTEGER erano piccoli e i programmatori veri programmatori che contavano i bytes.

Trackbacks

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...

%d blogger hanno fatto clic su Mi Piace per questo: