Breve introduzione a Linux (e dintorni...)

Breve introduzione a Linux (e dintorni...)
Luca Baldini, INFN - Pisa
versione 1.1
23 dicembre 2003
Indice
Introduzione
Indice delle versioni . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
3
1 Login e Logout: la shell
1.1 Linux . . . . . . . . . . . .
1.2 Il Login . . . . . . . . . . .
1.3 La shell ed i comandi Linux
1.4 Il Logout . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
5
5
6
2 Il filesystem Linux
2.1 I file Linux . . . . . .
2.2 Navigare nel filesystem
2.2.1 pwd . . . . . .
2.2.2 ls . . . . . . . .
2.2.3 cd . . . . . . .
2.3 Modificare il filesystem
2.3.1 mkdir . . . . .
2.3.2 rmdir . . . . .
2.3.3 rm . . . . . . .
2.3.4 cp . . . . . . .
2.3.5 mv . . . . . . .
2.3.6 chmod . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
7
8
8
8
9
10
10
11
11
12
12
12
3 I file di testo
3.1 Visualizzare i file . . . .
3.1.1 more . . . . . . .
3.1.2 less . . . . . . . .
3.1.3 head . . . . . . .
3.1.4 tail . . . . . . . .
3.2 Modificare i file: emacs .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
14
14
14
14
15
15
15
4 Qualcosa di più utile
4.1 I processi . . . . .
4.1.1 ps . . . . .
4.1.2 top . . . . .
4.1.3 kill . . . . .
4.2 La stampa . . . . .
4.2.1 lpr . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
16
16
16
17
17
17
17
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
18
18
18
18
18
19
19
19
19
19
19
20
20
20
21
21
5 Un
5.1
5.2
5.3
5.4
5.5
word-processor avanzato: LATEX
Dalla stesura alla stampa . . . . . .
Stesura del documento LATEX . . . .
LATEX e la matematica . . . . . . . .
Inserire le figure . . . . . . . . . . .
Le funzioni avanzate di LATEX . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
22
22
23
25
26
27
6 Un
6.1
6.2
6.3
6.4
semplice programma di plotting:
Lanciare gnuplot . . . . . . . . . . .
Visualizzare una serie di dati . . . .
Formattazione dei grafici . . . . . . .
Fit dei dati . . . . . . . . . . . . . .
gnuplot
. . . . . .
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
28
28
30
31
32
4.3
4.4
4.5
4.6
4.2.2 lpq . . . . . . . . . .
4.2.3 lprm . . . . . . . . .
Accesso alle periferiche . . .
4.3.1 mount . . . . . . . .
4.3.2 umount . . . . . . .
Accesso al floppy disk . . .
4.4.1 mdir . . . . . . . . .
4.4.2 mcopy . . . . . . . .
4.4.3 mdel . . . . . . . . .
L’accesso alle risorse di rete
4.5.1 ping . . . . . . . . .
4.5.2 telnet . . . . . . . .
4.5.3 ssh . . . . . . . . . .
4.5.4 ftp . . . . . . . . . .
Il compilatore C++ . . . .
4.6.1 g++ . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
A Un esempio di fit con Scilab
36
A.1 Minimo χ2 nel caso lineare . . . . . . . . . . . . . . . . . . . . . 36
A.2 Implementare il fit con Scilab . . . . . . . . . . . . . . . . . . . . 37
Bibliografia
39
2
Introduzione
Questo breve tutorial raccoglie un certo numero di informazioni (per la verità
piuttosto superficiali, bisogna dirlo) sul sistema operativo Linux e sui principali
pacchetti software, built in (come Emacs e LATEX) e no (come gnuplot), comunemente usati negli ambienti scientifici. Sono tutte cose che il “fisico quadratico
medio” deve imparare, una volta nella vita; e allora... perchè non cominciare il
prima possibile?
La scelta degli argomenti da toccare, è bene notarlo, è stata eseguita secondo
un criterio minimale; nel senso che, giunto all’ultima pagina, il lettore non saprà
utilizzare Linux, non saprà utilizzare Emacs e men che meno LATEXe gnuplot (a
meno che non sapesse già farlo sin dall’inizio, ma questo è un altro discorso...).
L’idea è che uno dovrebbe acquisire un certo numero di idee fondamentali in
modo da essere capace di andare avanti da solo, minimizzando in un certo senso
il trauma dovuto all’impatto iniziale con questo mondo che per molti, probabilmente, potrebbe essere nuovo. D’altra parte la documentazione disponibile in
rete è talmente vasta e cosı̀ facilmente reperibile, che c’è solo l’imbarazzo della
scelta. Buona fortuna!
Indice delle versioni
• versione 1.1
Data: 22 dicembre 2003.
Descrizione: Alcune piccole correzioni ortografiche e sintattiche.
Credits: R. Metere
• versione 1.0
Data: 21 febbraio 2003.
Descrizione: versione iniziale.
Credits: F. Angelini, B. Barsella, L. Martinelli.
Segnalare errori ed inesattezze a [email protected].
3
Capitolo 1
Login e Logout: la shell
Nel 1965 i laboratori della Bell Telephone (una divisione della AT&T) decisero di interrompere una collaborazione avviata con la General Electric ed il
Project MAC del MIT per la scrittura di un sistema operativo che avrebbe
dovuto chiamarsi Multics. Purtuttavia due programmatori, Ken Thompson e
Dennis Ritchie, ritennero che fosse un peccato sprecare il lavoro fatto; i loro
sforzi culminarono nella realizzazione di una prima versione del sistema che un
altro ricercatore, Brian Kernighan (futuro “inventore” del linguaggio di programmazione C), decise di chiamare, in opposizione a Multix, Unix. Nel 1973
Unix, originariamente scritto in assembly language venne interamente tradotto
in C; questa riscrittura, è facile immaginarlo, aumentò notevolmente la portabilità del codice e segnò l’inizio della sua diffusione. Alla fine degli anni ’70 la
AT&T fornı̀ a basso costo le licenze del sistema operativo a diversi college ed
università americane ed in pochi anni la popolarità di Unix riuscı̀ a superare i
confini ristretti delle istituzioni accademiche; ovviamente col tempo le cose sono
andate avanti ed oggi esistono svariate versioni commerciali del sistema, per le
diverse piattaforme hardware.
Linux è un sistema operativo Unix a tutti gli effetti; è una sorta di “clone”,
riscritto da zero, di Unix. La cosa interessante è che nessuna istituzione commerciale è stata coinvolta nella sua redazione (ed in effetti é assolutamente
freeware); esso è il risultato dello sforzo congiunto di migliaia di persone che,
in tutto il mondo, hanno dedicato (e continuano a dedicare) tempo e fatica per
perfezionare ciò che era iniziato come progetto di esplorazione del chip 80386.
Può essere curioso ricordare che uno dei primi “prodotti” di Linus Torvalds
(l’ideatore e padre di Linux) fu un programma che, tramite due processi funzionanti in multitasking, doveva stampare alternativamente AAAA e BBBB. Ne è
stata fatta di strada per arrivare al sistema operativo che conosciamo oggi!
Un ultima cosa: nel seguito parleremo solamente di Linux, ma intendiamoci:
probabilmente la maggior parte di quel che segue funzionerebbe altrettanto bene
su un qualsiasi sistema Unix.
1.1
Linux
Linux è un sistema operativo multi-utente e multi-tasking. Preciseremo il senso di questa affermazione “strada facendo”; purtuttavia spendere due parole
4
al proposito è probabilmente un buon punto di partenza. Multi-utenza significa che diversi utenti possono avere diversi dati, programmi ed impostazioni
di sistema memorizzate separatamente sulla stessa macchina; la struttura del
filesystem Linux è basata, come vedremo, sui concetti di proprietà e permesso.
Per certi versi è ciò che accade nei sistemi operativi come Windows NT/2000 e
simili; la differenza radicale è che Linux permette a piú utenti di accedere simultaneamente al sistema... Avremo occasione di apprezzare, per lo meno in parte,
le nuove possibilità che tutto questo apre. Multi-tasking significa semplicemente
che più comandi possono essere eseguiti contemporaneamente. Anche di questo
ci occuperemo più in dettaglio tra breve.
Come tutti i sistemi Unix, Linux è formato da un kernel e da programmi di
sistema, oltre ovviamente alle applicazioni propriamente dette, con cui l’utente
fa il lavoro vero e proprio. Il kernel costituisce il cuore del sistema operativo;
avvia i processi e permette loro di operare contemporaneamente, assegna le
risorse di sistema ai vari processi ed in definitiva fornisce tutti gli strumenti
necessari ad implementare i servizi che normalmente si richiedono ad un sistema
operativo; questa implementazione avviene attraverso chiamate di sistema. I
programmi di sistema, ed a maggior ragione le applicazioni, girano “sopra” al
kernel, in quella che si chiama modalità utente.
1.2
Il Login
Una macchina Linux deve “sapere chi si trova di fronte” prima di permettere
l’accesso al sistema. A tale scopo l’utente è tenuto a fornire il proprio username
e la propria password (che presumibilmente sono state fornite dall’amministratore di sistema) per potersi “loggare” (cioè eseguire il Login) alla macchina.
Esistono varie schermate di Login, che possono essere grafiche o testuali a seconda delle impostazioni di sistema e della distribuzione di Linux utilizzata...
Ma questo è un altro discorso (per altro complicato) e ci porterebbe lontano dal
punto essenziale della questione, che di complicato non ha niente. Una sola raccomandazione: Linux (al contrario di DOS e dei sistemi Windows in generale,
come probabilmente qualcuno sa) distingue maiuscole e minuscole (cioè è case
sensitive) per cui il nome utente, la password ed i comandi in generale devono
essere digitati esattamente come sono!
1.3
La shell ed i comandi Linux
Una volta loggato sulla macchina, l’utente può aprire una shell (se il sistema
non è configurato per farlo automaticamente). La shell è il luogo in cui si
impartiscono i comandi Linux; è per certi aspetti l’equivalente del prompt di
DOS sulle macchine Windows, per chi ha un po’ di esperienza al proposito.
Esistono svariati tipi di shell, che sostanzialmente differiscono tra di loro per
quanto riguarda il linguaggio di scripting ed alcune altre funzionalità che probabilmente l’utente medio tipicamente non utilizza. Anche questo è un discorso
che ci porterebbe molto lontano e non è il caso di approfondirlo adesso.
L’uso della shell è semplicissimo e consiste essenzialmente nello scrivere un
comando Linux valido e nel premere il tasto di INVIO. Ogni comando può avere
delle opzioni (che sono precedute da un carattere - e ne determinano l’esito) e
5
può accettare dei parametri; in sostanza la struttura tipica di un comando Linux
è del tipo:
>comando -opzione argomento
Sarà tutto più chiaro tra poco, quando vedremo alcuni esempi espliciti. Vale
la pena di notare che Linux ha un efficiente sistema di documentazione che
può rivelarsi utilissimo quando non si ricorda con precisione la sintassi di un
comando o l’effetto di un opzione sul comando stesso. E’ sufficiente digitare
dalla shell:
>man comando
per avere sul display tutta la documentazione disponibile (si torna alla shell
semplicemente premendo q).
Prima di andare avanti è utile ricordare che ci sono alcuni modi per “riprendere il controllo della shell” nel caso questo dovesse momentaneamente sfuggire
(il che accade tipicamente quando si esegue un comando che si apetta l’inserimento di dati da parte dell’utente oppure quando si avvia un programma la cui
esecuzione impiega più tempo del previsto):
1. CTRL + c
Solitamente elimina ogni programma in esecuzione e riporta alla linea di
comando.
2. CTRL + z
Sospende il processo corrente mentre è in esecuzione e riporta alla linea
di comando.
1.4
Il Logout
Il processo di Logout chiude tutti i file che sono (per qualche ragione) aperti e
termina ogni programma mandato in esecuzione dall’utente. E’ buona regola
scollegarsi sempre, una volta che abbiamo finito di utilizzare il computer; questo
permette agli altri utenti, eventualmente collegati da un terminale remoto, di
utilizzare nel modo più efficiente possibile le risorse di sistema. Per fare il logout
da una sessione testuale è sufficiente digitare dalla shell:
>logout
ed il sistema torna al prompt di login; un nuovo utente può collegarsi. Se la
sessione è grafica si può in generale avviare la procedura di logout (ed eventualmente quella di spegnimento della macchina) accedendo all’apposito menu
a tendina con il mouse.
6
Capitolo 2
Il filesystem Linux
A differenza di ciò che accade nei sistemi operativi tipo Windows, in cui i vari
drive sono associati alle lettere A, B, C, D ecc., il filesystem di Linux ha un’unica
directory radice (che si chiama root e che si indica con il simbolo /). La directory
root può contenere file ed altre directory e le directory dei livelli sottostanti
possono a loro volta fare altrettanto. La struttura fisica dell’hardware è in
un certo senso “nascosta” all’utente Linux: i drive appaiono semplicemente
come sottodirectory della root (come dire che un hard disk non è altro che una
directory...). Questa gestione del filesystem ha numerosi vantaggi che non è il
caso di discutere qui.
Ogni utente ha inoltre una home directory, che non ha niente di particolare
a parte il fatto di essere quella in cui l’utente stesso si trova immediatamente
dopo il Login.
2.1
I file Linux
I file Linux hanno tre attributi: r, w ed x (che stanno per read, write ed execute);
come dire che un file si può leggere, scrivere ed eseguire. O meglio che un
determinato utente può avere (o non avere) i privilegi necessari per leggere,
scrivere od eseguire un determinato file. Qualsiasi combinazione di questi tre
attributi è ammissibile per il sistema operativo, anche se non tutte sono cosı̀
sensate; Linux confida nella ragionevolezza dell’utente e lo prende alla lettera...
Ogni file Linux ha un proprietario (che è un utente con un account valido
sulla macchina) ed ogni proprietario può appartenere ad un gruppo di utenti.
I permessi su ogni file sono settati su tre livelli: quello del proprietario del file,
quello del gruppo a cui appartiene il proprietario e quello di tutti gli altri utenti del sistema; tanto per fare un esempio, è possibile che un file sia leggibile,
scrivibile ed eseguibile dal proprietario, solamente leggibile dal gruppo del proprietario ed assolutamente inaccessibile a tutti gli altri. Vedremo tra poco come
è possibile visualizzare (ed eventualmente cambiare) i permessi relativi ad un
determinato file o ad una directory.
7
2.2
Navigare nel filesystem
Esiste un certo numero di comandi che sono dedicati alla navigazione nel filesystem e ne vedremo tra breve alcuni esempi; dovrebbero essere più o meno sufficienti per sopravvivere nel sistema, ma è sempre importante ricordare che ogni
comando può avere un gran numero di opzioni che in generale è utile conoscere
per “soddisfare” in pieno le proprie esigenze (ed il comando man può essere
provvidenziale, a volte...).
2.2.1
pwd
E’ l’acronimo di present work directory e restituisce sullo schermo il nome della directory corrente. E’ sufficiente digitare pwd per sapere dove siamo; ad
esempio:
>pwd
/afs/pi.infn.it/user/lbaldini
>
2.2.2
ls
Elenca semplicemente i file contenuti in una certa directory (più o meno l’equivalente di dir in DOS); se l’utente non passa alcun argomento al comando, elenca
i file nella directory corrente. Ad esempio:
>ls
Ciao.doc
Temp
ClusterAxes.eps
>
Cioè la directory contiene tre oggetti. A questo livello non siamo in grado di
dire se essi sono files o directory. Per far questo è necessario invocare il comando
con l’opzione -l:
>ls -l
total 5
-rw-rw-r-drwxrwxr-x
-rw-rw-r->
1
2
1
lbaldini glast
lbaldini glast
lbaldini glast
36352
2048
21847
Dec 20 18:18 Ciao.doc
Jul 7 2002 Temp
Jul 24 2002 Cluster.ps
Adesso la soluzione si presenta molto più complicata; cerchiamo di chiarirla
brevemente. La prima riga dice quanti sono gli oggetti nella directory (in questo
caso cinque...capiremo tra un attimo il motivo per cui ne sono elencati solamente
3). Le linee successive visualizzano alcuni dettagli sugli oggetti in questione. Il
primo campo indica se si tratta di un file (-), di una directory (d) o di un
link (l); di seguito compaiono i permessi per il proprietario, per il gruppo del
proprietario e per l’utente generico (r, w ed x indicano rispettivamente che
l’utente possiede il permesso di lettura, scrittura ed esecuzione, mentre il simbolo
- indica che il corrispondente permesso è disabilitato). Ad esempio -rw-rw-r–
indica un file che il proprietario ed il suo gruppo possono leggere e modificare,
8
mentre tutti gli altri utenti possono solamente leggere. Invece Temp è una
directory e cosı̀ via... Il campo successivo nella linea indica il numero di hard
link all’oggetto in questione, ma per noi è poco importante. Seguono dunque
il nome del proprietario (in questo caso lbaldini) e del gruppo (glast). Infine
vediamo la dimensione dell’oggetto su disco, la data della sua ultima modifica ed
il nome; da notare che, nel caso delle directory, la dimensione non corrisponde
allo spazio su disco occupato dal contenuto, ma a quello occupato dal file dati
che controlla la directory stessa.
In generale Linux non mostra all’utente (a meno che esso non lo richieda
esplicitamente) tutti i file contenuti in una directory. In particolare il semplice
comando ls “nasconde” i file che cominciano con un punto (generalmente si
tratta di file di configurazione). Per visualizzare tutti i file si può utilizzare
l’opzione -a di ls:
>ls -a
.
..
Ciao.doc
Temp
ClusterAxes.eps
>
Adesso compaiono anche gli oggetti . (che in Linux sta per “directory corrente”)
e .. che viceversa indica la directory che nel filesystem si trova al livello immediatamente superiore rispetto a quella corrente. Notiamo che l’oggetto . esiste
in tutte le directory e che .. esiste in tutte le directory fatta eccezione per la
directory root (/), che si trova in assoluto al livello più alto nel filesystem.
Il comando ls può accettare un argomento, che indica la directory della quale
si vogliono elencare gli oggetti:
>ls -a Temp
.
..
Luca.jpg
>
In questo caso ci dice che la directory Temp contiene (oltre ovviamente a . e ..)
un solo file che si chiama Luca.jpg.
Prima di andare avanti, un trucco utilissimo per risparmiare tempo: nei
sistemi Linux il tasto TAB funziona da auto completion, cioè completa automaticamente i nomi di comandi od oggetti del filesystem, una volta che l’utente
ne abbia scritto una parte abbastanza lunga da rimuovere eventuali ambiguità.
Provare per credere, è più facile a dirsi che a farsi!
2.2.3
cd
Esattamente come in DOS, questo comando serve per cambiare directory; necessita, come argomento, del nome della directory di destinazione. Il percorso
verso quest’ultima può essere quello assoluto (cioè partendo da root) oppure
quello relativo (cioè partendo dalla directory corrente). L’esempio seguente, che
unisce i pochi comandi visti sino ad adesso, dovrebbe chiarire le idee:
9
>pwd
/afs/pi.infn.it/user/lbaldini
>ls
Ciao.doc
Temp
ClusterAxes.eps
>cd Temp
>ls
Luca.jpg
>cd .
>ls
Luca.jpg
>cd ..
>ls
Ciao.doc
Temp
ClusterAxes.eps
>cd /afs/pi.infn.it/user/lbaldini/Temp
>ls
Luca.jpg
>
Notiamo che il comando cd . non fa niente (essendo . la directory corrente),
mentre cd .. porta nella directory immediatamente superiore nel filesystem. La
documentazione di Linux contiene un’esposizione esauriente di tutte le possibili
opzioni del comando; per visualizzarla, al solito:
>man cd
(dopo di che barra spaziatrice o frecce per scorrere e q per tornare alla shell).
2.3
Modificare il filesystem
Ovviamente navigare non è l’unica cosa che si può fare col filesystem... Esistono
comandi per creare, copiare, muovere file e cosı̀ via. Al solito diamo un’occhiata
a quelli veramente indispensabili.
2.3.1
mkdir
Come si può intuire dal nome, crea una directory e richiede come argomento
il nome della directory da creare. Al solito il percorso può essere assoluto o
relativo; ovviamente se non si specifica niente, il nuovo oggetto viene creato
nella directory corrente. Esempio:
>pwd
/afs/pi.infn.it/user/lbaldini
>ls
Ciao.doc
Temp
ClusterAxes.eps
>mkdir NewDirectory
10
>ls
Ciao.doc
Temp
ClusterAxes.eps
NewDirectory
>
Un consiglio: sotto Linux è buona norma evitare gli spazi all’interno dei nomi
di file o directory!
2.3.2
rmdir
E’ il contrario del comando precedente e semplicemente rimuove una directory
esistente, a patto che sia vuota:
>ls
Ciao.doc
Temp
ClusterAxes.eps
NewDirectory
>rmdir NewDirectory
>ls
Ciao.doc
Temp
ClusterAxes.eps
>
Come vedremo tra un attimo, per cancellare una directory non vuota è necessario usare il comando rm con l’opzione -f.
2.3.3
rm
Rimuove il file che gli viene passato come argomento e la sintassi è analoga a
quella di rmdir (solo che, ovviamente, accetta come parametro un file e non una
directory). Ha alcune opzioni che forse vale la pena di conoscere:
1. -i il comando agisce in modo interattivo e chiede conferma prima di cancellare ogni file; caldamente consigliata quando si lavora a notte fonda!
2. -f il comando agisce in modo forzato senza tener conto dei permessi del
proprietario del file.
3. -r il comando agisce in modo ricorsivo: con questa può accettare il nome
di una directory come argomento ed in tal caso cancella ricorsivamente
tutto il contenuto della directory stessa.
Un breve commento: il risultato del comando rm è per ceri versi “più irreversibile” di quanto accada su altri sistemi operativi, nel senso che recuperare
un file cancellato per sbaglio può essere, sotto Linux, un’impresa veramente
disperata. Quando l’utente esegue il comando, ciò che fa la macchina è cancellare l’indirizzo che identifica la zona di memoria in cui i dati in questione
sono fisicamente contenuti; dopo di che il filesystem tende a “rimodellarsi” piuttosto velocemente ed è piuttosto probabile che non occorra molto tempo prima
11
che questa zona di memoria venga effettivamente riscritta. Se proprio dovesse
capitarvi di cancellare dei dati essenziali il consiglio è il seguente: smontare immediatamente il filesystem incriminato (impareremo che cosa vuol dire e come
si fa), quindi rimontarlo in modalità read only e sperare che qualche programmino particolarmente intelligente possa aiutarvi. In ogni caso può essere buona
abitudine utilizzare rm in modo interattivo (con l’opzione -i) e, cosa forse più
utile, evitare di lavorare fino a notte fonda dopo una giornata faticosa ed una
cena pesante!
2.3.4
cp
E’ l’analogo di copy in DOS e serve per copiare un file di partenza (che viene
passato come primo argomento) in un file o in una directory di destinazione (che
costituisce viceversa il secondo argomento). Ad esempio il comando:
>cp *.doc Temp
>
copia tutti i file il cui nome termina per .doc nella directory Temp. Il simbolo * è
un carattere speciale per Linux ed è spesso molto utile per esguire le operazioni
desiderate nel modo più rapido possibile. D’altra parte:
>cp Ciao.doc Salve.doc
>
crea una copia del file Ciao.doc nella directory corrente chiamandola Salve.doc.
2.3.5
mv
Serve per rinominare un file:
>mv Ciao.doc Salve.doc
>
oppure per spostarlo in una directory di destinazione, se quest’ultima viene
specificata:
>mv Ciao.doc Temp
>
Per inciso notiamo che, dopo il primo comando, il file Ciao.doc non esiste più!
2.3.6
chmod
Serve essenzialmente per cambiare i permessi su un file ed è spesso un comando
veramente indispensabile. L’utente deve passare al comando il livello del permesso che vuole cambiare (u = proprietario, g = gruppo, o = utente generico),
l’operazione da eseguire (+ = aggiungere permesso, - = togliere permesso), il
tipo di permesso (r = lettura, w = scrittura, x = esecuzione) ed infine il nome
del file su cui settare i nuovi permessi. E’ più semplice di quello che sembra; ad
esempio:
>chmod u-w Cluster.eps
>
12
toglie al proprietario i privilegi necessari per poter modificare il file Cluster.eps.
Con il comando ls -l, che abbiamo già visto, è possibile verificare facilmente il
funzionamento di chmod.
13
Capitolo 3
I file di testo
Al di là dei file di testo propriamente detti, molte applicazioni Linux (ed il
sistema stesso!) utilizzano file di configurazione di tipo testuale, per cui è essenziale avere strumenti per visualizzare (ed eventualmente modificare) gli oggetti
di questo tipo.
3.1
Visualizzare i file
Linux offre un ampio set di comandi dedicati alla visualizzazione dei file di tipo
testuale. Di seguito elenchiamo i principali; al solito le pagine man sono uno
strumento utile per esplorare le svariate opzione che ognuno di questi comandi
prevede.
3.1.1
more
Accetta come argomento un file e ne visualizza il contenuto sullo schermo; per
esempio
>more Cluster.eps
visualizza il contenuto del file Cluster.eps. La barra spaziatrice fa avanzare di
una pagina, mentre il tasto b riporta indietro di una pagina; si torna alla shell
premendo il tasto q. Le pagine man dovrebbero illustrare l’elenco completo dei
comandi che si possono usare all’interno di more.
3.1.2
less
La sintassi ed il funzionamento sono essenzialmente identici a quelli di more:
>less Cluster.eps
La differenza è che dovrebbe essere più facile muoversi all’interno del documento
(in particolare si possono usare le frecce direzionali...).
14
3.1.3
head
Visualizza le prime 10 righe (ma il numero può essere modificato utilizzando
l’opportuna opzione) del file che gli viene passato come argomento. La sintassi
è la solita:
>head Cluster.eps
E’ utile quando si vuole dare una sola occhiata ad un file.
3.1.4
tail
Al contrario del precedente visualizza le ultime righe di un file.
3.2
Modificare i file: emacs
La visualizzazione non è certo l’unica cosa di cui uno ha bisogno, lavorando con
i file di tipo testuale; emacs è probabilmente l’editor di testo più diffuso tra gli
utenti Linux, ormai. Descrivere, sia pur in modo sommario, le sterminate funzionalità di emacs ci porterebbe lontano dal filo della discussione; d’altra parte
il programma ha un ampio sistema di documentazione integrata che dovrebbe
essere più che sufficiente per cavarsela in ogni situazione. Essenzialmente si può
aprire un file con emacs semplicemente digitando dalla shell:
>emacs Cluster.eps
Fatto questo, emacs funziona più o meno come un qualsiasi editor di testo; da
notare che offre un grandissimo numero di comandi da tastiera (ad esempio
CTRL + x CTRL + s per salvare...) che rendono veramente veloce ed efficiente
(per lo meno per gli esperti) l’editing. Al solito provare a lavorare con emacs è
il miglior modo per imparare ad usarlo.
15
Capitolo 4
Qualcosa di più utile
E’ chiaro che dare un’occhiata ad un file di testo ed eventualmente modificarlo
non è granchè... Ci sono molte altre cose che, presumibilmente, un utente
vorrebbe essere in grado di fare (stampare, gestire le periferiche, accedere alla
rete, ecc. ecc.); ne vedremo (molto superficialmente) alcune.
4.1
I processi
Ogni comando Linux crea un processo che il sistema operativo esegue fino a
quando non finisce o viene interrotto. Il punto fondamentale è che, essendo
multitasking, Linux permette di mandare in esecuzione più di un processo contemporaneamente; permette inoltre di mandare in esecuzione processi in background (o, come si dice, dietro le quinte) semplicemente facendo seguire un &
al comando.
Un esempio può essere utile per chiarire le idee. Supponiamo di voler aprire
con emacs il file Cluster.eps; possiamo farlo normalmente:
>emacs Cluster.eps
oppure possiamo farlo in background:
>emacs Cluster.eps &
[2] 12563
>
La differenza, come si vede, è che nel secondo caso il sistema torna alla linea
di comando e la shell è di nuovo utilizzabile, mentre nel primo la shell è inutilizzabile fino a che non chiudiamo emacs (possiamo sempre aprire una nuova
shell...). Per completezza, i numeri [2] 12563 identificano il processo all’interno
del sistema operativo.
Linux offre un set di comandi per monitorare i processi ed eventualmente
intervenire su di essi. Al solito vedremo i fondamentali.
4.1.1
ps
Visualizza l’elenco dei processi in memoria dei quali l’utente è proprietario. Non
servono argomenti e la sintassi è banale:
16
>ps
Il risultato è una lista dei processi con il proprio numero di identificazione, lo
stato (Running, Stopped, ecc.) ed altre informazioni per le quali si rimanda alle
pagine man.
4.1.2
top
Visualizza un elenco, aggiornato continuamente, di tutti i processi in memoria, fornendo inoltre alcune informazioni importanti come il numero di identificazione, il proprietario, il tempo di esecuzione, la priorità, ecc. Anche qui non
servono argomenti
>top
e le pagine man riportano tutte le opzioni valide. Si torna alla shell digitando
CTRL + c.
4.1.3
kill
Capita a volte, per qualche ragione, di voler interrompere forzatamente un processo; in tal caso si utilizza il comando kill, che accetta come parametro il numero
di identificazione del processo da eliminare. Ad esempio per uccidere il processo
avviato quando prima avevamo lanciato emacs in background dovremmo fare:
>kill -9 12563
[2]+ Killed
>
emacs
Si rimanda alle pagine man per il significato dell’opzione -9.
4.2
La stampa
L’installazione, la configuarzione e la gestione delle stampanti sono punti non
proprio banali di cui generalmente si occupa l’amministratore di sistema. All’utente è sufficiente conoscere pochi comandi, che fortunatamente sono gli stessi
in tutti i casi (stampante locale o stampante condivisa in rete).
4.2.1
lpr
Permette di stampare un file e richiede come argomanti (nell’ordine) il nome
della stampante ed il nome del file da stampare. Supponiamo ad esempio di
avere una stampante postscript che si chiama laser00 e di voler stampare il
solito Cluster.eps. La sintassi è:
>lpr -P laser00 Cluster.eps
>
in cui l’opzione -P indica che stiamo utilizzando una stampante di tipo postscript.
17
4.2.2
lpq
Accetta come parametro il nome di una stampante e mostra i processi nella
coda di stampa per la stampante in questione. Esempio:
>lpq -P laser00
4.2.3
lprm
Permette di rimuovere un processo dalla coda di stampa, nel caso ve ne sia
bisogno; supponiamo di voler eliminare il processo di stampa 123 (il numero di
identificazione è fornito dal comando lpq):
>lprm -P laser00 123
>
4.3
Accesso alle periferiche
Abbiamo già detto che Linux non fa alcuna distinzione, dal punto di vista dell’utente che accede al filesystem, tra dispositivi (ad esempio hard disk) che sono
fisicamente diversi tra loro. Questo è vero anche per le periferiche come cd rom
o floppy disk. L’unica cosa che l’utente deve fare è dire al sistema come accedere
a queste periferiche, dopo di che i dati in esse contenuti divengono disponibili
nel filesystem esattamente come i file contenuti sull’hard disk.
4.3.1
mount
Questo comando dice al sistema come accedere ad un disco o ad una periferica
e come essa deve essere visualizzata all’interno del filesystem. Supponiamo per
esempio di voler leggere il contenuto di un cd rom (che è probabilemnte una
delle operazioni più comuni che l’utente medio esegue). I comandi
>mount /dev/cdrom
>cd /dev/cdrom
>
dovrebbero essere sufficienti per montare il dispositivo e spostarsi nella directory
corrispondente del filesystem. A questo punto il contenuto del cd rom è disponibile nella directory stessa di modo che si possono eseguire senza particolari
problemi tutte le operazioni che già conosciamo.
4.3.2
umount
Non è il caso di preoccuparsi se non si riesce più ad aprire il drive del cd rom!
Probabilmente dipende dal fatto che non si è fatto correttamente l’umount del
dispositivo. E’ sufficiente digitare:
>umount /dev/cdrom
>
per poter riprendere il controllo della situazione ed estrarre fisicamente il disco.
18
4.4
Accesso al floppy disk
benché si possa accedere al floppy con i comandi mount e umount, esiste sotto
Linux una serie di utility ispirate ai comandi DOS che sono spesso più pratiche
da utilizzare.
4.4.1
mdir
Visualizza il contenuto del floppy (che, come generalmente accade sotto Windows, viene identificato con a:). La sintassi tipo è:
>mdir a:
4.4.2
mcopy
Permette di copiare dei file da e su floppy. Un paio di esempi per chiarire...
>mcopy Cluster.eps a:
>
copia il file Cluster.eps (che si trova nella directory corrente) sul floppy, mentre
>mcopy a:/Cluster.eps ./Temp
>
copia il file Cluster.eps (sul floppy) nella directory Temp, che è contenuta nella
directory corrente (./).
4.4.3
mdel
Permette di rimuovere file dal floppy. Esempio:
>mdel a:/Cluster.eps
>
4.5
L’accesso alle risorse di rete
Il fatto che Linux consenta a più utenti di lavorare contemporaneamente su una
stessa macchina da terminali remoti rende l’accesso alle risorse di rete un capitolo estremamente importante del bagaglio di conoscenze richiesto all’utente.
Dal proprio pc è possibile accedere al filesystem di un’altra macchina, lanciare
processi su di essa e copiare file e directory dal filesystem in questione. Vediamo
alcuni comandi essenziali.
4.5.1
ping
Consente di verificare che la propria macchina sia in grado di “dialogare” con un
altro pc Linux. Supponiamo di voler verificare la connessione con la macchina
galileo; è sufficiente digitare:
>ping galileo
ed il nostro pc cercherà di trasmettere e ricevere indietro alcuni byte di test,
verificando lo stato della connessione.
19
4.5.2
telnet
E’ un semplice programma di terminale che consente di aprire sessioni di lavoro
su una macchina remota (occorre ovviamente possedere un account su quella
macchina...). Digitando ad esempio:
>telnet galileo
si apre il prompt di login sulla macchina remota (in questo caso galileo) e vengono richiesti lo username e la password. Una volta loggato, l’utente può agire
come se stesse fisicamente lavorando sulla macchina remota (e quindi navigare
nel filesystem, muovere e copiare file, eseguire programmi, ecc.).
4.5.3
ssh
Telnet non è il massimo per la sicurezza... si tratta di un semplice protocollo
di connessione il cui punto di forza consiste nell’essere disponibile su qualsiasi
macchina Linux. In realtà quando è possibile (il che dipende probabilmente dal
tipo di installazione e dalla release utilizzata) è consigliabile usare il comando
ssh, che è l’acronimo di secure shell. E’ molto probabile, addirittura, che la
macchina a cui state cercando di loggarvi rifiuti ogni tentativo di connessione,
se non attraverso ssh... La sintassi è quella usuale:
>ssh galileo
Buona fortuna!
4.5.4
ftp
Si tratta di un protocollo che consente di connettersi ad un server e, oltre a
navigare nel modo consueto all’interno del filesystem, permette di trasferire
dati da una macchina all’altra attraverso i comandi put e get (o mput ed mget,
che supportano il trasferimento multiplo). Per inciso notiamo che esiste anche
la versione “sicura” di ftp che, nemmeno a farlo a posta, si chiama sftp (la s sta
per secure) ed è in un certo senso per ftp quello che ssh è per telnet. Digitando:
>ftp galileo
ci connettiamo al server remoto (ovviamente fornendo username e password).
A questo punto possiamo ad esempio copiare su di esso il nostro Cluster.eps:
>mput Cluster.eps
>
oppure copiare indietro il file nella directory Temp:
>mget Cluster.eps ./Temp
>
Una precauzione: per evitare che il file si corrompa nel trasferimento può essere
a volte necessario digitare:
>set bin
>
20
4.6
Il compilatore C++
Ogni sistema Linux include un compilatore C++ integrato, il che rende particolarmente facile la programmazione in C++ nelle macchine con questo sistema
operativo (se vogliamo proprio dirla tutta, Linux offre anche un compilatore C,
che si chiama gcc, ed un ottimo compilatore Fortran, il g77). E’ utile spendere
due parole al proposito, anche per chi non ha mai programmato in C++ (o per
chi non ha mai programmato tout court).
In generale la realizzazione di un programma (funzionante!) si compone di
tre operazioni:
1. Scrittura del codice sorgente (in C++ o in qualsiasi altro linguaggio di
programmazione).
2. Compilazione, cioè traduzione del codice sorgente in un insieme di istruzioni
interpretabili dalla macchina (che costituiscono il cosiddetto eseguibile). Il
programma che esegue questa traduzione prende il nome di compilatore.
3. Esecuzione dell’eseguibile.
4.6.1
g++
Il comando g++ compila il programma che l’utente passa come parametro e crea
un eseguibile che di default ha il nome di a.out. L’insieme di comandi riportato
di seguito compila il file HelloWorld.cxx e lancia il corrispondente eseguibile,
che non fa altro che stampare sullo schermo la stringa “Hello world!”.
>ls
HelloWorld.cxx
>g++ HelloWorld.cxx
>ls
HelloWorld.cxx
a.out
>./a.out
Hello world!
>
Notiamo che il comando ./a.out è quello che lancia l’eseguibile.
21
Capitolo 5
Un word-processor
avanzato: LATEX
Sulla maggior parte dei sistemi Linux è disponibile LATEX, un programma per
la formattazione di documenti di testo molto potente che si è guadagnato negli
anni una grossa popolarità all’interno della comunità scientifica e trai fisici in
particolare. Come tutte le applicazioni ha i suoi pregi ed i suoi difetti; di
sicuro offre alcune funzionalità che rendono la realizzazione di alcuni tipi di
documenti (ad esempio quelli contenenti formule matematiche) particolarmente
semplice (probabilmente su questo semplice non tutti sono d’accordo) e veloce.
Per quel poco che può contare, queste brevi dispense sono state redatte utilizzando LATEX (più precisamente utilizzando LATEX sotto Windows! Solamente
per notare che LATEX ed Emacs, come molte altre applicazioni, esistono anche
per Windows e possono essere scaricate gratuitamente dalla rete. Ma questo è
un altro discorso...).
5.1
Dalla stesura alla stampa
LATEX non è un programma di formattazione del tipo WYSIWYG (what you
see is what you get); il che può renderlo poco digeribile, per lo meno a prima
vista, a chi è abituato ad utilizzare word-processor come Microsoft Word, tanto
per citare quello che probabilmente è in assoluto il più diffuso. In un certo
senso è più vicino ad un linguaggio di programmazione. Un documento LATEX
è composto da un misto di testo e di comandi LATEX validi; il tutto va poi
compilato, dopo di che può essere visualizzato e convertito in postscipt, che
sotto Linux è il formato principe per la stampa. In sostanza la realizzazione
del prodotto finale passa attraverso le seguanti operazioni ed i seguenti comandi
Linux (che ovviamente si danno dalla shell...):
1. Stesura del documento LATEX. E’ il documento che contiene, come abbiamo già detto, il testo ed i comandi ed ha tipicamente l’estensione .tex;
vedremo in seguito alcuni esempi. Tipicamente l’utente medio utilizza
Emacs (che supporta alcune funzionalità speciali per LATEX) per questa
operazione, ma ovviamente qualsiasi altro editor di testo va benissimo!
22
2. Compilazione. Si esegue dalla shell di Linux attraverso il comando LATEX.
Ad esempio per compilare il documento Tutorial.tex è sufficiente digitare:
>latex Tutorial.tex
Con questo comando il programma crea un certo numero di file (Tutorial.aux, Tutorial.log e Tutorial.dvi) di varia natura. O meglio: dovrebbe
farlo, a meno che non ci siano errori di sintassi all’interno del documento.
Nel qual caso, non abbiate paura, ve ne accorgerete, poichè il compilatore si lamenterà (ed allora, al solito CTRL + Z per tornare alla shell,
un’occhiata al file sorgente pr trovare l’errore e poi si prova di nuovo!).
Il file .dvi contiene il documento compilato in una forma che permette la
visualizzazione attraverso l’apposito programma xdvi.
3. Visualizzazione. xdvi consente di vedere quale sarà la forma finale del
documento. Il comando è:
>xdvi Tutorial.dvi
4. Conversione in formato postscript. Il comando
>dvips -o Tutorial.dvi
crea il file postscript contenente il documento pronto per la stampa. E’
possibile visualizzarlo con una applicazione che supporti il formato (ad esempio con ghostview digitando gv Tutorial.ps) e stamparlo con il comando
usuale.
5.2
Stesura del documento LATEX
Adesso non ci resta che imparare quali sono in effetti le regole per la stesura di
un documento LATEX. Certamente in poche righe non è possibile descrivere in
modo esauriente le sterminate possibilità che il pacchetto offre; qui si vogliono
solamente introdurre alcune tra le idee base, di modo che poi andare avanti
(magari con l’ausilio di un buon manuale...) risulti meno ostico. Un buon
modo per cominciare (pur se un tantino brutale, forse) è dare un’occhiata al
documento sorgente della primissima parte di questo tutorial:
\documentclass[a4paper, 10pt]{report}
\usepackage[latin1]{inputenc}
\usepackage[dvips]{graphicx}
\begin{document}
\chapter{Login e Logout: la shell}
Linux \‘e un sistema operativo {\itshape multi-utente} e
{\itshape multi-tasking}. Preciseremo il senso di questa
affermazione ‘‘strada facendo’’; purtuttavia spendere
23
due parole al proposito \‘e probabilmente un buon punto di
partenza.
Multi-utenza significa che diversi utenti possono avere diversi
dati, programmi ed impostazioni di sistema memorizzate
separatamente sulla stessa macchina; la struttura del
{\itshape filesystem} Linux \‘e basata, come vedremo, sui
concetti di propriet\‘a e permesso. Per certi versi \‘e ci\‘o
che accade nei sistemi operativi come Windows NT/2000 e simili;
la differenza radicale \‘e che Linux permette a pi\‘u utenti di
accedere simultaneamente al sistema... Avremo occasione di
apprezzare, per lo meno in parte, le nuove possibilit\‘a che
tutto questo apre.
Multi-tasking significa semplicemente che pi\‘u comandi possono
essere eseguiti contemporaneamente. Anche di questo ci
occuperemo pi\‘u in dettaglio tra breve.
\section{Il Login}
Una macchina Linux deve ‘‘sapere chi si trove di fronte’’ prima
di permettere l’accesso al sistema.
\end{document}
Il risultato, dopo la compilazione, è sostanzialmente la prima parte di pagina 1
del nostro tutorial. Come si vede, già queste poche righe contengono un sacco
di cose da capire; ma cominciamo dal principio. Il comando:
\documentclass[a4paper, 10pt]{report}
setta l’impostazione della pagina (in questo caso un normale foglio A4), la dimensione del font per il testo generico (10 pt) ed il tipo di documento che ci
accingiamo a scrivere (report). Ogni comando LATEX, probabilmente lo avrete
notato, è preceduto da un backslash; questo permette al compilatore di capire
se l’utente sta cercando di immettere del semplice testo oppure, appunto, un
comando. I comandi, inoltre, possono accettare degli argomenti (inclusi tra
parentesi graffe, come in questo caso la classe del documento) e delle opzioni
(che sono tra parentesi quadre, come il formato ed il font in questo caso). Il
comando documentclass è obbligatorio; la classe report (ma ce ne sono molte
altre: article, book, slides, letter...) prevede i comandi “supplementari” chapter,
section e subsection, tra gli altri. Come si vede la grandezza dei font per il titoli
dei capitoli, delle sezioni e delle sottosezioni avviene automaticamente, senza
bisogno di dichiarare esplicitamente il cambiamento di corpo o do stile. Anche
la numerazione avviene in modo completamente automatico, il che è particolarmente comodo nel caso uno decida, per esempio, di aggiungere un capitolo nel
bel mezzo del suo documento: non è necessario rinumerare tutti i capitoli successivi, basta ricompilare e tutto va a posto da solo. A questo livello possiamo
tranquillamente disinteressarci delle righe:
\usepackage[latin1]{inputenc}
\usepackage[dvips]{graphicx}
24
che costituiscono il cosiddetto preambolo; il documento vero e proprio è, nemmeno a dirlo, quello compreso tra i comandi begindocument ed enddocument
(anch’essi obbligatori!). Un confronto tra il file sorgente ed il risultato della compilazione dovrebbe rendere chiaro immediatamente quale sia la sintassi
LATEX per accentare le lettere, scrivere in corsivo, cominciare un nuovo paragrafo, dichiarare capitoli e sezioni, tanto per citare alcune delle operazioni che
si eseguono con maggiore frequenza. Cosı̀ come si vede che il compilatore non si
cura affatto degli spazi e dei ritorni a capo... E’ chiaro che questo è solamente
l’inizio, ma come si dice... l’appetito vien mangiando e la letteratura su LATEX
è cosı̀ estesa e cosı̀ facilmente reperibile in rete che andare avanti da soli non
dovrebbe essere affatto difficile, una volta aperta la strada!
5.3
LATEX e la matematica
Uno dei motivi principali per cui LATEX ha avuto un tale successo tra i fisici
è probabilmente costituito dalla facilità con cui è possibile includere formule
matematiche arbitrariamente complesse, il che, come si può ben immaginare,
costituisce una notevole facilitazione nella redazione di documenti scientifici.
Per illustrare le potenzialità che il pacchetto offre in questo senso, è necessario introdurre il concetto di ambiente. Un ambiente LATEX è una parte del
documento delimitata dai comandi:
\begin{ambiente}
\end{ambiente}
L’esempio più semplice è quello dell’ambiente document che già conosciamo e
che si trova in ogni documento; ma ne esistono molti altri, ognuno con funzionalità e comandi diversi! Cosı̀ entro l’ambiente center il testo (come qualsiasi
altro oggetto) viene centrato, tabular è usato per realizzare tabelle e enumerate
elenchi, verbatim non fa altro che dire al compilatore di ignorare tutti i comandi
e di “stampar fuori” il testo cosı̀ com’è (vi siete chiesti come ho fatto a riprodurre
il sorgente del primo capitolo all’interno del documento senza che il compilatore
si preoccupasse di tutti i comandi ivi contenuti?).
LATEX offre diversi ambienti esplicitamente dedicati alla matematica, con
innumerevoli simboli e comandi specifici. Tanto per fare un esempio il seguente
frammento di “codice”:
Actually, working out the calculation$^7$, one finds that the
non relativistic, polarized photoemission cross section, in
this case, is given by:
\begin{equation}
\frac{d\sigma}{d\Omega} = r_0^2 Z^5 \alpha^4
(\frac{m_e c^2}{h\nu})^{\frac{7}{2}}
\frac{4 \sqrt{2} sin^2\theta cos^2\phi}{(1 - \beta cos\theta)^4}
\end{equation}
where $\theta$ is the polar angle between the direction of
propagation $\mathbf{k}$ of the incoming photon and the direction
of emission, $\phi$ the azimuthal angle measured starting from
the direction of polarization of the radiation and $\beta$ is
25
the final velocity of the photoelectron in terms of the speed
of light.
fornisce, dopo la compilazione:
Actually, working out the calculation7 , one finds that the non relativistic, polarized photoemission cross section, in this case, is given by:
√
2
7 4
dσ
2sin2 θcos2 φ
2 5 4 me c
2
= r0 Z α (
)
(5.1)
dΩ
hν
(1 − βcosθ)4
where θ is the polar angle between the direction of propagation k of the incoming photon and the direction of emission, φ the azimuthal angle measured
starting from the direction of polarization of the radiation and β is the final
velocity of the photoelectron in terms of the speed of light.
Anche qui un confronto tra il documento sorgente ed il risultato della compilazione dovrebbe essere un esercizio molto istruttivo, oltre che uno stimolo
all’approfondimento. Per inciso, notiamo che le equazioni, come i capitoli ed
i paragrafi, vengono numerate automaticamente; è uno dei vantaggi del “non
vedere” quello che si sta facendo...
5.4
Inserire le figure
Chiaramente LATEX offre la possibilità di inserire figure all’interno del testo, anche se per la verità accetta solamente il formato eps (encapsulated postscript)
e questa rigidità è talvolta piuttosto limitante. Per inciso notiamo che, sotto
Linux, praticamente qualsiasi formato grafico (jpg, tif, gif...) si può facilmente
convertire in eps con il comando convert, di cui si rimanda alle pagine man. Per
inserire una figura si utilizza l’ambiente figure ed è necessario caricare preventivamente l’estensione graphicx (ecco spiegata la prima riga del nostro preambolo...).
Per chiarire il tutto osserviamo il frammento:
\begin{figure}
\begin{center}
\begin{tabular}{c}
\includegraphics[height=5.5cm]{./Cluster1376.eps}
\includegraphics[height=5.5cm]{./Cluster52.eps}
\end{tabular}
\end{center}
\caption[Samples]
{
Two real tracks collected in a run with 5.9 keV unpolarized
radiation; the area of each hexagon is proportional to the
charge inducted on the corresponding pixel of readout plane.
The gas mixture used is Ne/DME 80/20 at 1 Atm; since Ne K-shell
is 0.9 keV, photoelectron energy is in this case 5 keV. Note
that most of this energy is released in the Bragg peak toward
the end of the path.}
\end{figure}
26
Hit Position
Hit Position
25
25
20
20
15
15
10
10
5
5
0
0
5
10
15
20
0
0
25
5
10
15
20
25
Figura 5.1: Two real tracks collected in a run with 5.9 keV unpolarized radiation; the area of each hexagon is proportional to the charge inducted on the
corresponding pixel of readout plane. The gas mixture used is Ne/DME 80/20
at 1 Atm; since Ne K-shell is 0.9 keV, photoelectron energy is in this case 5 keV.
Note that most of this energy is released in the Bragg peak toward the end of
the path.
che, dopo la compilazione, genera la figura 5.1 (notare che, anche in questo caso,
la numerazione è automatica!).
Con la pratica noterete che LATEX tende a posizionare le figure (apparentemente!) un po’ dove “pare a lui”; in realtà esistono comandi specifici, anche
se qui non è il caso di entrare nel dettagio, che consentono di riacquistare un
minimo di controllo sul layout del documento finale. Del resto non è che con
altri programmi di formattazione la situazione sia tanto meglio...
5.5
Le funzioni avanzate di LATEX
LATEX offre tutta una serie di funzioni avanzate che non abbiamo tempo di descrivere in dettaglio ma che costituiscono il vero punto di forza del programma.
Con LATEX è semplicissimo inserire dei riferimenti ad equazioni o figure che si
aggiornano automaticamente ad ogni compilazione (di modo che non è necessario rinumerare 35 figure per il solo motivo di averne aggiunta una all’inizio!).
Con LATEX è un gioco da ragazzi generare un indice analitico; cosı̀ come è facile
scrivere la bibliografia di un documento (ed avere, anche in questo caso, riferimenti “sparsi” per il testo che si aggiornano da soli). Il consiglio è sempre lo
stesso: armarsi di un buon manuale e provare; spero che queste poche pagine
via abbiano convinto che ne vale la pena.
27
Capitolo 6
Un semplice programma di
plotting: gnuplot
Avere a disposizione (ed essere in grado di padroneggiare...) un programma
efficiente di visualizzazione ed analisi di dati è una delle esigenze fondamentali
di chiunque si occupi di fisica. Inutile ripetere anche qui che i prodotti a disposizione non si contano... E’ proprio il caso di dire che ce n’è per tutti i gusti
(oltre che per tutte le piattaforme hardware e per tutti i sistemi operativi). I
fisici delle alte energie, tanto per fare un esempio, tendono in genere ad essere
molto affezionati a due pacchetti, paw e root, sviluppati al CERN (dalla cui
pagina web possono essere scaricati gratuitamente) e dotati ampie potenzialità
grafiche e computazionali; ma di nuovo: non è che una questione di gusti.
Tipicamente i software che si gestiscono da linea di comando sono più indicati, per le applicazioni avanzate, rispetto a quelli che l’utente può comandare
completamente a colpi di mouse da un’interfaccia grafica; questo perché essi
consentono in modo semplice di realizzare dei piccoli programmi (quelli che in
gergo si chiamano macro utili quando si desideri eseguire operazioni di routine di una certa complessità (come ad esempio potrebbe essere: leggere un
file di dati, istogrammare certe serie di numeri ivi contenute e fittare il tutto
con una funzione definita dall’utente). Intendiamoci: non è che i programmi
tipici windows-based (primo tra tutti Excel) non offrano questa possibilità; solo
che un approccio di questo tipo è molto più diretto ed immediato nei pacchetti
programmabili da linea di comando (basta mettere insieme un certo numero di
comandi in un file opportuno, lanciarlo ed il gioco è fatto!).
6.1
Lanciare gnuplot
Su di un sistema Linux è sufficiente digitare il comando gnuplot per lanciare
il programma (a patto che sia installato, intendiamoci!); cosı̀ facendo l’utente
viene a trovarsi all’interno del prompt da cui è in grado di digitare i comandi.
Il tutto dovrebbe apparire (più o meno!) cosı̀:
>gnuplot
G N U P L O T
28
1
sin(x)/x
0.8
0.6
0.4
0.2
0
-0.2
-0.4
-10
-5
Figura 6.1: Grafico della funxione
gnuplot.
0
sinx
x ,
5
10
ottenuto utilizzando il comando plot di
Version 3.7 patchlevel 3
last modified Thu Dec 12 13:00:00 GMT 2002
...
gnuplot>
Al solito cominciamo dall’inizio: il comando
gnuplot>help
gnuplot>
visualizza le pagine di aiuto on-line, che costituiscono sempre un ottimo punto
di partenza (per altro sono abbastanza ben scritte, meritano un’occhiatina!). A
parte questo, probabilmente, la cosa più semplice che l’utente possa fare è usare
il comando plot per visualizzare l’andamento di una funzione; una cosa del tipo:
gnuplot>plot sin(x)/x
gnuplot>
dovrebbe essere sufficiente a visualizzare un oggetto in qualche modo rassomigliante
alla figura 6.1. Notiamo, per inciso, che gnuplot è in generale capace di plottare
più o meno qualsiasi espressione matematica valida in C, FORTRAN, Pascal
o BASIC (per esempio i le espressioni sin(x), cos(x), tan(x), asin(x), acos(x),
atan(x), erf(x), exp(x), log(x), log10(x), sqrt(x) non dovrebbero aver bisogno di
alcun commento).
29
50
’LeggeOraria.txt’ using 1:2
45
40
35
30
25
20
15
10
5
10
15
20
25
30
Figura 6.2: Visualizzazione, mediante gnuplot, dei dati contenuti nel file
LeggeOraria.txt.
6.2
Visualizzare una serie di dati
Gnuplot è capace di visualizzare in modo molto semplice i dati contenuti in un
file, purchè organizzati per colonne e separati con spazi o TAB. Supponiamo ad
esempio di avere un file di testo (nominato LeggeOraria.txt) del tipo:
# File LeggeOraria.dat: contiene la posizione x di una massa
# puntiforme al variare del tempo.
# Notare che gnuplot ignora automaticamente le linee che
# cominciano con un carattere #, di modo che l’utente puo’
# aggiungere commenti a suo piacimento.
#
# Tempo (sec)
Posizione (cm)
Errore (cm)
5
10.1
2.0
10
17.8
1.5
15
26.6
1.5
20
32.8
2.0
25
40.2
2.5
30
47.4
2.0
Il comando:
gnuplot>plot ‘‘LeggeOraria.txt’’ using 1:2
dovrebbe generare qualcosa di non troppo diverso dalla figura 6.2.
30
6.3
Formattazione dei grafici
Il risultato, ammettiamolo, non si direbbe proprio esaltante, per lo meno dal
punto di vista estetico. Uno vorrebbe essere in grado di visualizzare il titolo del
grafico, i nomi degli assi e cosı̀ via; ovviamente gnuplot consente di fare tutto
questo (e molto altro...). In particolare possiamo farlo, come abbiamo già detto,
scrivendo una piccola macro e lanciandola. Una macro dovrebbe apparire più o
meno come il file qui di seguito (che chiamiamo PlotMacro.txt):
# PlotMacro.txt.
# Breve script per plottare i dati contenuti nel file
# LeggeOraria.txt.
# Di nuovo: gnuplot ignora tutte le linee che iniziano
# con il carattere #.
#
# Definizione del titolo.
set title ’Legge oraria per una particella libera’
# Label per l’asse delle x.
set xlabel ’Tempo (sec)’
# Label per l’asse delle y.
set ylabel ’Posizione (cm)’
# Definizione del range per l’asse delle x.
set xrange [0: 40]
# Definizione del range per l’asse delle y.
set yrange [0: 50]
# Opzione per eliminare la legenda.
set nokey
# Comando di plot: plottiamo la colonna 2 contro la 1
# usando la 3 come colonna degli errori sulla y.
plot ’LeggeOraria.txt’ using 1:2:3 with yerrorbars
# Generazione del file .eps per la stampa.
set out ’LeggeOrariaEdit.eps’
set terminal postscript
replot
# Ritorno al terminale usuale (l’output appare di nuovo
# sullo schermo e non piu’ sul file).
set terminal x11
La macro si lancia con il comando load:
gnuplot>load ’PlotMacro.txt’
ed il risultato è un grafico come quello che appare in figura 6.3. Notiamo, per
inciso, che scrivere una macro ed eseguirla non è affatto necessario; avremmo
potuto inserire tutti i comandi, uno dopo l’altro, dal terminale ed il risultato
sarebbe stato esattamente lo stesso. Cosı̀ come non sono necessari i commenti,
del resto; una macro del tipo:
set
set
set
set
title ’Legge oraria per una particella libera’
xlabel ’Tempo (sec)’
ylabel ’Posizione (cm)’
xrange [0: 40]
31
Legge oraria per una particella libera
50
45
40
Posizione (cm)
35
30
25
20
15
10
5
0
0
5
10
15
20
Tempo (sec)
25
30
35
40
Figura 6.3: Visualizzazione, mediante gnuplot, dei dati contenuti nel file
LeggeOraria.txt, dopo la formattazione.
set yrange [0: 50]
set nokey
plot ’LeggeOraria.txt’ using 1:2:3 with yerrorbars
set out ’LeggeOrariaEdit.eps’
set terminal postscript
replot
set terminal x11
sarebbe andata più che bene. Inutile notare che quelli mostrati non costituiscono
che una piccola parte dei comandi disponibili dentro gnuplot; al solito: in rete
si trovano con estrema facilità manuali aggiornati e dettagliati del pacchetto e
queste poche pagine non possono certo pretendere di sostituirli!
6.4
Fit dei dati
Gnuplot non è solamente un programma di visualizzazione di dati, ma possiede
anche alcune funzionalità di analisi ed in particolare è in grado di fittare una
serie di dati con una generica funzione definita dall’utente. La macro seguente
dovrebbe risultare chiarissima, ormai:
# FitMacro.txt.
# Breve script per plottare i dati contenuti nel file
# LeggeOraria.txt e fittarli con una retta.
#
32
# Definizione del titolo.
set title ’Legge oraria per una particella libera’
# Label per l’asse delle x.
set xlabel ’Tempo (sec)’
# Label per l’asse delle y.
set ylabel ’Posizione (cm)’
# Definizione del range per l’asse delle x.
set xrange [0: 40]
# Definizione del range per l’asse delle y.
set yrange [0: 50]
# Opzione per eliminare la legenda.
set nokey
#
# Definizione della funzione di fit (retta).
f(x) = a + b*x
# Stime iniziali dei parametri del fit.
a = 1
b = 1
# Esecuzione del fit.
fit f(x) ’LeggeOraria.txt’ using 1:2:3 via a, b
#
# Comando di plot: plottiamo la colonna 2 contro la 1
# usando la 3 come colonna degli errori sulla y.
# Plottiamo anche la funzione di fit.
plot ’LeggeOraria.txt’ using 1:2:3 with yerrorbars, a + b*x
# Generazione del file .eps per la stampa.
set out ’LeggeOrariaFit.eps’
set terminal postscript
replot
# Ritorno al terminale usuale (l’output appare di nuovo
# sullo schermo e non piu’ sul file.
set terminal x11
Il risultato è, come uno può aspettarsi, un grafico simile a quello riportato
in figura 6.4, oltre ad una serie di messaggi che forniscono informazioni sulla
convergenza del fit e sulla stima finale dei parametri. Il programma dovrebbe
fornire anche il valore del χ2 diviso per il numero di gradi di libertà (ChiSquare
/ d.o.f), che permette di valutare in modo immediato la bontà del fit stesso; il
tutto, tra l’altro , viene anche memorizzato su di un file fit.log che appare più o
meno cosı̀:
***********************************************************
Wed Feb 12 09:45:22 2003
FIT:
data read from ’LeggeOraria.txt’ using 1:2:3
#datapoints = 6
function used for fitting: f(x)
fitted parameters initialized with current variable values
33
Legge oraria per una particella libera
50
45
40
Posizione (cm)
35
30
25
20
15
10
5
0
0
5
10
15
20
Tempo (sec)
25
30
35
40
Figura 6.4: Visualizzazione, mediante gnuplot, dei dati contenuti nel file
LeggeOraria.txt, dopo la formattazione ed il fit con un polinomio di grado 1.
Iteration 0
WSSR
: 209.004
delta(WSSR) : 0
lambda
: 6.93718
delta(WSSR)/WSSR
: 0
limit for stopping : 1e-05
initial set of free parameter values
a
b
= 1
= 1
After 5 iterations the fit converged.
final sum of squares of residuals : 0.686015
rel. change during last iteration : -2.87956e-12
degrees of freedom (ndf) : 4
rms of residuals
(stdfit) = sqrt(WSSR/ndf)
: 0.41413
variance of residuals (reduced chisquare) = WSSR/ndf : 0.171504
Final set of parameters
=======================
Asymptotic Standard Error
==========================
a
b
+/- 0.698
+/- 0.03902
= 3.25533
= 1.48589
34
(21.44%)
(2.626%)
correlation matrix of the fit parameters:
a
b
a
b
1.000
-0.897 1.000
35
Appendice A
Un esempio di fit con Scilab
Gnuplot utilizza una variante del metodo di minimo χ2 per eseguire i fit. Il
procedimento in questione è di tipo iterativo: si parte da una stima iniziale
dei parametri (fornita dall’utente) e si cambiano questi ultimi fino a che il χ2
non converge ad un minimo. Questo è il modo in cui, in genere, funzionano i
pacchetti di analisi dati per effettuare dei fit. In realtà, per lo meno nei casi più
semplici, non è affatto complicato scrivere dei piccoli programmi che eseguano
dei fit; e provare a farlo, una volta nella vita, può sicuramente contribuire ad
eliminare quell’aura di sacralità con cui l’utente medio tende ad osservare certi
software complicati... In fondo il fatto che altre persone (magari molto più
esperte di noi nel campo) abbiano scritto dei programmi che noi utilizziamo
non significa che non dobbiamo avere idea di cosa questi programmi stiano
facendo!
A.1
Minimo χ2 nel caso lineare
Supponiamo di avere una serie di dati sperimentali (per esempio quelli contenuti
nel nostro solito file LeggeOraria.txt) e di volerli fittare con la funzione piú
semplice in assoluto:
f (x) = ax
(A.1)
(abbiamo scelto una funzione puramente lineare, è bene notarlo, solamente per
semplicità; in generale azzerare l’intercetta non è un’operazione lecita!) Al
solito, nell’ipotesi che gli errori sulla x siano “piccoli” (attenzione al significato
di questa assunzione!) possiamo eseguire il fit minimizzando la quantità:
χ2 =
N
X
(yi − axi )2
(∆yi )2
i=0
(A.2)
Nel nostro caso l’equazione da risolvere è:
N
X
∂χ2
(yi − axi )xi
= −2
=0
∂a
(∆yi )2
i=0
36
(A.3)
che conduce all’equazione per a:
PN
yi xi
i=0 (∆yi )2
(xi )2
i=0 (∆yi )2
a = PN
(A.4)
Notiamo, per inciso, che introducendo i vettori N-dimensionali:
xN
x1 x2
,
, ...,
)
∆y1 ∆y2
∆yN
y1
y2
yN
w=(
,
, ...,
)
∆y1 ∆y2
∆yN
v=(
(A.5)
l’equazione per a si può scrivere in forma compatta come:
a=
v·w
v·v
(A.6)
in cui il puntino sta ad indicare l’usuale prodotto scalare tra vettori.
A.2
Implementare il fit con Scilab
A questo punto eseguire il fit è una cosa semplice: basta prendere i dati ed
eseguire, nella giusta sequenza, i prodotti, le divisioni e le somme necessarie a
calcolare a secondo l’equazione scritta sopra. Una calcolatrice va benissimo, ma
il tutto si può fare in modo più efficiente (specialmente nel caso si abbia un gran
numero di dati) scrivendo un piccolo programma. Anche qui: qualsiasi linguaggio di programmazione può servire egregiamente allo scopo; noi proveremo a
farlo con il software Scilab, che offre tutta una serie di funzioni utili per maneggiare matrici e vettori. Lo scopo del gioco dovrebbe essere quello di tirar fuori
il “numerino” in modo trasparente (cioè avendo ben presente che cosa stiamo
facendo).
Scilab si lancia dalla shell (udite, udite!) con il comando:
>scilab
La prima cosa che dobbiamo fare è importare entro scilab la nostra matrice di
dati, che chiameremo M; il comando da utilizzare è read:
scilab>[M] = read(’LeggeOraria.txt’, 6, 3)
[M] =
| 5
10.1
2.0 |
| 10
17.8
1.5 |
| 15
26.6
1.5 |
| 20
32.8
2.0 |
| 25
40.2
2.5 |
| 30
47.4
2.0 |
scilab>
Essenzilmente questo significa: leggiamo il file LeggeOraria.txt ed estraiamo
una matrice di 6 righe e 3 colonne che chiamiamo M e che da questo momento
è disponobile in memoria per effettuare le operazioni desiderate; ad ogni passo
Scilab dovrebbe stampare sullo schermo ciò che abbiamo appena fatto, che è utile
37
per verificarne la correttezza. Una precisazione: Scilab non ama i commenti (le
righe precedute da #, che invece non creavano problemi a gnuplot) per cui
dobbiamo avere la precauzione di cancellarle dal file contenente i dati , prima di
eseguire il comando. A questo punto dobbiamo estrarre dalla matrice i vettori
che ci interessano, cioè quello delle x, quello delle y e quello degli errori sulla y.
Il modo per farlo (con ovvio significato dei termini) è:
scilab>[x] = M(:, 1)
[x] =
| 5 |
| 10 |
| 15 |
| 20 |
| 25 |
| 30 |
scilab>[y] = M(:, 2)
| 10.1 |
| 17.8 |
| 26.6 |
| 32.8 |
| 40.2 |
| 47.4 |
scilab>[dy] = M(:,3)
| 2.0 |
| 1.5 |
| 1.5 |
| 2.0 |
| 2.5 |
| 2.0 |
scilab>
Cioè: definiamo il vettore x come la prima colonna della matrice M, il vettore
y come la seconda colonna e dy come la terza colonna. Costruiamo quindi i
vettori v e w definiti nel paragrafo precedente:
scilab>v = x./dy
scilab>w = y./dy
scilab>
(notare che l’operatore ./ è quello che consente, dentro Scilab, di eseguire la
divisione membro a membro di due vettori). Non ci resta che eseguire i prodotti
scalari per calcolare a:
scilab>(v’*w)/(v’*v)
(l’apostrofo ’ indica il vettore trasposto, dopo di che il prodotto scalare si esegue con l’usuale simbolo di moltiplicazione); Scilab dovrebbe visualizzare sullo
schermo il valore del parametro cercato. Facile, no?
38
Bibliografia
[1] Linux: guida dell’amministratore di sistema, Lars Wirzenius.
ftp://ftp.pluto.linux.it/pub/pluto/ildp
[2] Linux: guida dell’utente, Larry Greenfield.
ftp://ftp.pluto.linux.it/pub/pluto/ildp
[3] GNU - Emacs manual
http://www.gnu.org/manual/emacs/index.html
[4] Impara LATEX! (...e mettilo da parte), Marc Baudoin.
ftp://ftp.pluto.linux.it/pub/pluto/ildp/misc/imparalatex
[5] GNUPLOT - A brief Manual and Tutorial
http://www.duke.edu/~hpgavin/gnuplot.html
39