Istruzioni per la connesione internet:
- una volta loggati, aprire un browser (firefox)
- in Modifica/preferenze/avanzate/rete/impostazioni
- attivare la modalità "configurazione manuale del proxy"
ed inserire "proxyu9.lib.unimib.it" - porta 8080
- attivare "utilizza questo proxy per ogni protocollo"
- confermare tutto e tornare alla pagina del browser
- se viene richiesto di inserire utente e password, mettete le vostre
(utente è : lib\bi01matricola)

ROOT Troubleshooting

Dato che "a volte ritornano" e di solito si tratta di problemi penso che sia utile riportare qui una mini guida per risolvere uno dei problemi più comuni che seguono l'installazione di ROOT sul proprio pc. Il problema riguarda gli utenti Linux, ma, ovviamente, è un problema da poco e la soluzione è immediata (c'è gia anche sulle slide, in particolare qui) ma capita che uno non la colga e rischi di impazzire perchè, nonostante l'installazione abbia funzionato, non si riesce a fare ripartire ROOT.
Per ulteriori informazioni (cos'è bash?, cos'è export? che vuol dire il carattere "$" prima dei nomi?) si rimanda ai testi specializzati sull'argomento.

************************************************************************
Troubleshooting (trad. "sparalo allo problema!")
Hai installato ROOT (hai digitato "make" da qualche parte e hai visto
una lista di scritte che scorrevano?) e magari l'avevi anche fatto
partire appena installato ma adesso hai aperto un terminale e digitando:
----------------------------------------------------------------------
root
----------------------------------------------------------------------
non parte?
Prima di tutto, controlliamo se la tua shell è una  bash  o una
 tcsh  apri un terminale e digita
----------------------------------------------------------------------
echo $SHELL
----------------------------------------------------------------------
se ottieni una risposta del tipo:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/bin/bash
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
allora la tua shell è una bash.
Di seguito le istruzioni sono quelle per una shell bash, qui ci sono i
comandi adatti per le shell tcsh.
ROOT non parte perchè il sistema semplicemente... non sa dove andarlo a
pescar!! Bisogna impostare le variabili di ambiente che indichino
dove sta il nostro ROOT.
Per farlo ecco i tre seguenti comandi EXPORT che devi digitare nella shell.
----------------------------------------------------------------------
export ROOTSYS=percorso_di_base_di_root
export PATH=$ROOTSYS/bin:$PATH
export LD_LIBRARY_PATH=$ROOTSYS/lib:$LD_LIBRARY_PATH
----------------------------------------------------------------------
percorso_di_base_di_root è la cartella dove hai fatto "make"
quando l'hai installato. Ecco un esempio: ho scaricato il file .tar e
salvato nella cartella "~/root++" e poi estratto.
Quindi devo digitare (per la tilde si deve fare AltGr + ì [i con l'accento])
----------------------------------------------------------------------
export ROOTSYS=~/root++/root/
----------------------------------------------------------------------
e gli altri due comandi export.
A questo punto digitando
----------------------------------------------------------------------
root
----------------------------------------------------------------------
dovrebbe partire.
Se tutto funziona ora noterai che se chiudi la shell (che oltre a essere
un termine frequente in fisica atomica e nucleare è il nome tecnico del
terminale) e la riapri per far partire ROOT dovresti digitare di nuovo
quei comandi.
Per automatizzare la cosa, vai nella tua cartella "~" che è la tua
cartella "home" personale e digita il comando:
----------------------------------------------------------------------
ls -a
----------------------------------------------------------------------
che ti mostra tutti ( all ) i file (anche quelli nascosti) presenti
nella cartella. Cerca il file chiamato:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.bashrc
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
(il punto all'inizio vuol dire che il file è nascosto.)
Se lo trovi, digita:
----------------------------------------------------------------------
nano .bashrc
----------------------------------------------------------------------
Dovresti vedere una cosa tipo:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
e aggiungi le seguenti righe in fondo (le righe che cominciano con il #
sono commentate)
----------------------------------------------------------------------
# comandi per ROOT
export ROOTSYS=percorso_di_base_di_ROOT
export PATH=$ROOTSYS/bin:$PATH
export LD_LIBRARY_PATH=$ROOTSYS/lib:$LD_LIBRARY_PATH
----------------------------------------------------------------------
ossia i comandi che hai digitato prima.
Quando hai finito premi
----------------------------------------------------------------------
Ctrl+O
Invio
Ctrl+X
----------------------------------------------------------------------
In questo modo salvi il file, confermi il nome e esci.
(La guida dei comandi di "nano" la vedi nella parte inderiore della
finestra   ;) ).
A questo punto aprendo una shell e andando in una cartella qualsiasi,
digitando
----------------------------------------------------------------------
root
----------------------------------------------------------------------
Dovresti vedere il logo.
Buon lavoro.

    Permission is granted to copy, distribute and/or modify this
    document under the terms of the GNU Free Documentation License,
    Version 1.2 or any later version published by the Free Software
    Foundation; with no Invariant Sections, no Front-Cover Texts and
    no Back-Cover Texts.  A copy of the license is included in the
    section entitled "GNU Free Documentation License".
***********************************************************************

Disclaimer: se qualcuno ha da discutere sul fatto che il migliore editor non sia "nano", ma per esempio "vim" o "emacs" evidentemente ne sa abbastanza da solo da non avere bisogno di questo post.

esame del 19 marzo

Ciao, sul sifa c'è scritto che l'esame si svolgerà alle 14 mentre avevo sentito voci che dicevano che sarebbe stato di mattina.
L'aula è sempre la stessa?

root su vista

domanda di carattere tecnico: ho delle difficoltà nel far partire ROOT su Vista.
s i installa correttamene ma poi non riesco ad utilizzrlo.
consigli?
ciao

ROOT

Ecco le slide di introduzione a ROOT.
Potete trovare le slide (congelate alla versione corrente) in formato .zip sul google-group. Qui di seguito i link, per comodità:

Intro

Funzioni e passaggio di parametri

Generatori di numeri casuali

Puntatori e memoria dinamica

Introduzione alla programmazione ad oggetti

Introduzione ai template

Introduzione alle STL

Introduzione all'ereditarietà

Introduzione a ROOT

introduzione all'ereditarieta'

Ecco alcune slide di introduzione all'ereditarieta', da sfogliare come lettura serale prima della lezione del 3/4 dicembre.

Standard Template Library

le slide

varie

Precisazioni dell'esercizio per la prossima volta.

1. Partendo dalle indicazioni e dai suggerimenti sulle slide, scrivere una classe vettore per la gestione di array dinamici, templata sul tipo di dati da allocare nel vettore.
2. Compilare ed eseguire questo semplice programma. Riconoscete l'origine di ogni riga stampata come output?
3. Scrivere una funzione doppio_di, esterna alla classe (ovvero non un metodo della classe), che prenda come unico argomento, passato per valore, un oggetto V della vostra classe vettore e restituisca un vettore W i cui elementi W[i] sono ciascuno il doppio di V[i].
4. Scrivere una funzione void raddoppiami che prenda come unico argomento il riferimento di un vettore e raddoppi il valore di ciascun suo elemento.
5. Implementare gli opportuni metodi (e aggiungere eventualmente gli opportuni attributi) perchè la classe vettore consenta il cambiamento della dimensione dell'array dinamico. In particolare, consenta sia di ridurre il numero di elementi (preservando il valore dei primi elementi sopravvissuti) e sia di aumentarne (preservando il valore dei primi elementi già esistenti). Inutile dirlo: attenzione ai new e delete!

Nel risolvere gli esercizi 3 e 4, far tesoro dell'esercizio 2...

Nota tecnica: con linux, per connettersi ad internet con un modem telefonico (non-ADSL), è possibile usare i seguenti programmi: gnome-ppp (se usate gnome come) o kppp (se usate KDE). Se la versione di linux non e' troppo vecchia, tutto dovrebbe essere molto semplice e intuitivo: basta trovare una di queste due applicazioni nel menu e utilizzarle nel modo più naturale possibile. Per ulteriori dettagli (ma non dovrebbe essercene bisogno...) potete leggere qui.

introduzione ai template

qui le slides

complessi & istogramma

Esercizio facile-facile: dato il seguente header-file complesso.hpp per una possibile classe dei numeri complessi, scriverne l'implementazione in un corrispondente file complesso.cpp (e ovviamente, com'è sempre sottinteso, scrivere una test-unit per tale classe, ovvero un semplice programma capace di testare tutte le funzionalità implementate per la classe).
Esercizio facile: scrivere una classe istogramma da usare per l'analisi della soluzione all'esercizio 10. La classe istogramma non dovrà contenere al suo interno il generatore di numeri casuali, ma dovrà contenere solo quei metodi e quegli attributi che gli sono necessari per poter gestire una situazione del tutto generica in cui si vuole

• popolare l'istogramma inserendo un valore alla volta
• disegnare l'istogramma allo stato corrente (ovvero corrispondente alla popolazione di valori inseriti fino a quel momento)
• restituire il valore della media e della varianza della popolazione allo stato corrente

Ulteriori specifiche (come la possibilità di indicare il numero di bin dell'istogramma, la possibilità di poter cambiare al volo il numero di bin, ovvero di poter cambiare il numero di bin quando l'istogramma è già stato creato e (parzialmente) riempito, la possibilità di cambiare al volo il numero bin soltanto accorpando i bin correntemente usati, e così via...) sono lasciati alla libertà dello studente.

NOTA BENE
Se avete domande (ed è bene per voi che ne abbiate!) sfruttate almeno la mailinglist del gruppo, ovvero scrivete una mail a labinfodocet@googlegroups.com

allora...?

...chi è che racconta qui sul blog qual è la sottigliezza cui bisogna prestare attenzione nel risolvere l'esercizio 6, rispetto alla soluzione dell'esercizio 5?
...e chi è che mette un bello screenshot dell'ASCII-istogramma che ha ottenuto? Va bene con qualsiasi generatore random...!

strutture

Per chi le ha già viste durante la seconda lezione, per chi le vedrà nella prossima lezione, ecco le slide sulle strutture.
Vi ricordo che le slide delle lezioni precedenti si trovano qui.

materiale per cominciare

A parte un po' di filosofia sui numeri casuali, ecco le slides della prima lezione (cliccate sulle singole diapositive per vederle ingrandite).

Per avere una bozza di codice in C/C++ da cui partire, ecco il piccolo programma visto in classe.

Per gli affezionati di Windoz™, un modo per giocare col C/C++ è quello di usare DevCpp: leggete qui per sapere come scaricarlo e come usarlo.

Vi ricordo gli esercizi step-by-step richiesti per la prossima volta. Va da sè che la "soluzione" ad ogni esercizio (tipicamente la funzione che si richiede di scrivere) va testata in un main che la usa e mostra in qualche modo che il suo funzionamento e' quello richiesto. Per tutti questi esercizi si darà per scontato la conoscenza e l'utilizzo della funzione rand() del C/C++ che abbiamo visto in classe.

1. scrivere un(a funzione che costituisca da) generatore di numeri casuali interi distribuiti uniformemente nell'intervallo [0,RAND_MAX];
2. scrivere un generatore di numeri casuali floating-point (float o double) distribuiti uniformemente nell'intervallo [0,1];
3. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [0,1), ovvero 1 escluso;
4. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [0,6);
5. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [1,6);
6. scrivere un generatore di numeri casuali interi distribuiti uniformemente nell'intervallo [1,6];
7. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [-2,2);
8. scrivere un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [-M_PI,M_PI);
9. scrivere una funzione che accetta due argomenti di tipo floating-point (a e b) e che costituisca un generatore di numeri casuali floating-point distribuiti uniformemente nell'intervallo [a,b);
10. scrivere un generatore di numeri casuali floating-point distribuiti nell'intervallo [-M_PI/2,M_PI/2) con una probabilità proporzionale alla funzione coseno;

IMPORTANTE: siete caldamente invitati a scrivere post e commenti su questo blog per condividere problemi, idee, dubbi e — sì — anche soluzioni. Non è escluso che qualche problema, idea, dubbio e — sì — soluzione possa venire anche da parte nostra...

Buon lavoro!

Benvenuti!

Inizia il corso per l'anno accademico 2007-2008.

Questo blog, al quale sono registrati anche diversi studenti che hanno seguito il corso del 2006-2007, e' pensato come luogo di discussione fra gli studenti, di scambio di problemi e soluzioni, di condivisione di trucchi, link e scoperte (riguardo agli argomenti del corso ;) ).

Chiunque si iscriva, mandando uno dei seguenti email
valentina.tancini [at] mib.infn.it
vincenzo.miccio [at] mib.infn.it
verra' inserito fra gli amministratori, con tutte le prerogrative (ad esempio, potra' lui stesso inserire nuovi autori).

lista di algoritmi

dalla wikipedia, una lista di algoritmi.

TPad

Ciao a tutti,
Volevo mettere in evidenza un nuovo oggetto di ROOT che ho scoperto da poco, si tratta del TPad. (documentazione e tutorial con un istrogramma riempito con numeri casuali). Utilizzando questo oggetto si possono rappresentare in un TCanvas più grafici contemporaneamente. Le opzioni sono molto simili a quelle del TCanvas.
Da segnalare anche (sempre nel TCanvas) l'azione "Inspect" che si può attivare facendo clic con il tasto destro del mouse è utile perchè da l'elenco dello stato di tutte le variabili che compongono l'oggetto, insieme ad una breve descrizione.
Posto un file di esempio con un TCanvas nel quale sono rappresentati due grafici (una carica di un circuito RC e la stessa relazione linearizzata) e qui l'output.

forum in web

Ecco un forum di sviluppatori, interessante da consultare per vedere se qualcuno ha gia' posto il problema che non riusciamo a risolvere

thescripts developers network

ancora documentazione on line

gcc gnu online docs

un altro sito interessante sulle STL

http://www.ishiboo.com/~nirva/c++/stl-ref/

vector, buono a sapersi

Ecco una serie di membri di std::vector, fra gli altri non conoscevo "at".

http://www.cppreference.com/cppvector/all.html

pietro