Soluzioni: Lezione 7
Contents
Soluzioni: Lezione 7¶
7.1 generazione di numeri pseudo-casuali distribuiti esponenzialmente¶
esercizio01.cpp
/*
c++ -o esercizio01 `root-config --glibs --cflags` esercizio01.cpp casual.cc
*/
#include "casual.h"
#include "TH1F.h"
#include "TCanvas.h"
int main (int argc, char ** argv)
{
double t_zero = 5. ;
TH1F h_expo ("h_expo", "h_expo", 100, 0., 30. * t_zero) ;
for (int i = 0 ; i < 1000000 ; ++i)
{
h_expo.Fill (rand_exp (t_zero)) ;
}
TCanvas c1 ;
h_expo.SetFillColor (kOrange) ;
h_expo.Fit ("expo") ;
h_expo.Draw ("hist") ;
c1.Print ("esercizio01.gif", "gif") ;
return 0 ;
}
7.2 generazione di numeri pseudo-casuali distribuiti Poissonianamente¶
esercizio02.cpp
/*
c++ -o esercizio02 `root-config --glibs --cflags` esercizio02.cpp casual.cc
*/
#include "casual.h"
#include "TH1F.h"
#include "TCanvas.h"
#include <iostream>
using namespace std ;
int main (int argc, char ** argv)
{
if (argc < 3)
{
cerr << "uso del programma: "
<< argv[0]
<< " t_zero tempo_di_misura\n" ;
return 1 ;
}
double t_zero = atoi (argv[1]) ; // tempo caratteristico dell'esponenziale
double tempo_di_misura = atoi (argv[2]) ; // tempo di misura
int N = 3 * tempo_di_misura / t_zero ;
TH1F h_pois ("h_pois", "h_pois", N, 0, N) ;
// ciclo su tanti pseudo-esperimenti
for (int i = 0 ; i < 1000000 ; ++i)
{
double t_tot = rand_exp (t_zero) ;
int N_evt = 0 ;
while (t_tot < tempo_di_misura)
{
++N_evt ;
t_tot += rand_exp (t_zero) ;
}
h_pois.Fill (N_evt) ;
} // ciclo su tanti pseudo-esperimenti
TCanvas c1 ;
h_pois.SetFillColor (kAzure + 2) ;
h_pois.Draw ("hist") ;
c1.Print ("esercizio02.gif", "gif") ;
return 0 ;
}
7.3 creazione di una libreria per la generazione dei numeri casuali¶
esercizio03.cpp
/*
c++ -o esercizio03 `root-config --glibs --cflags` esercizio03.cpp casual.cc
*/
#include "casual.h"
#include "TH1F.h"
#include "TCanvas.h"
#include <iostream>
using namespace std ;
int main (int argc, char ** argv)
{
if (argc < 2)
{
cerr << "uso del programma: "
<< argv[0]
<< " media_attesa\n" ;
return 1 ;
}
double media = atoi (argv[1]) ; // media della distribuzione di Poisson
int N = 3 * media ;
TH1F h_pois ("h_pois", "h_pois", N, 0, N) ;
// ciclo su tanti pseudo-esperimenti
for (int i = 0 ; i < 1000000 ; ++i)
{
h_pois.Fill (rand_pois (media)) ;
} // ciclo su tanti pseudo-esperimenti
TCanvas c1 ;
h_pois.SetFillColor (kAzure + 4) ;
h_pois.Draw ("hist") ;
c1.Print ("esercizio03.gif", "gif") ;
h_pois.DrawNormalized ("hist") ;
c1.Print ("esercizio03_pdf.gif", "gif") ;
return 0 ;
}
casual.h
#ifndef casual_h
#define casual_h
double rand_range (double min, double max) ;
float rand_exp (double t_zero) ;
float rand_pois (double media) ;
#endif
casual.cc
#include "casual.h"
#include <cstdlib>
#include <cmath>
double rand_range (double min, double max)
{
return min + (max - min) * rand () / static_cast<double> (RAND_MAX);
}
float rand_exp (double t_zero)
{
return -1. * log (1 - rand_range (0., 1.)) * t_zero ;
}
float rand_pois (double media)
{
double t_tot = rand_exp (1.) ;
int N_evt = 0 ;
while (t_tot < media)
{
++N_evt ;
t_tot += rand_exp (1.) ;
}
return N_evt ;
}
7.4 creazione di un campione di numeri pseudo-casuali e studio delle sue statistiche¶
esercizio04.cpp
/*
c++ -o esercizio04 esercizio04.cpp casual.cc
*/
#include "casual.h"
#include "statistiche.h"
#include <iostream>
#include <vector>
using namespace std ;
int main (int argc, char ** argv)
{
if (argc < 2)
{
cerr << "uso del programma: "
<< argv[0]
<< " media_attesa\n" ;
return 1 ;
}
double mediaP = atoi (argv[1]) ; // media della distribuzione di Poisson
vector<int> campione ;
// ciclo su tanti pseudo-esperimenti
for (int i = 0 ; i < 1000000 ; ++i)
{
campione.push_back (rand_pois (mediaP)) ;
} // ciclo su tanti pseudo-esperimenti
cout << "media del campione: " << media (campione) << "\n" ;
cout << "varianza del campione: " << varianza (campione) << "\n" ;
cout << "sigma del campione: " << sigma (campione) << "\n" ;
cout << "asimmetria del campione: " << asimmetria (campione) << "\n" ;
cout << "curtosi del campione: " << curtosi (campione) << "\n" ;
return 0 ;
}
statistiche.h
#ifndef statistiche_h
#define statistiche_h
#include <cmath>
#include <vector>
template <class T>
double media (std::vector<T> const & inputV)
{
double sum = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i) sum += inputV.at (i) ;
return sum / inputV.size () ;
}
template <class T>
double varianza (std::vector<T> const & inputV)
{
double sum = 0. ;
double sumSq = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i)
{
sum += inputV.at (i) ;
sumSq += inputV.at (i) * inputV.at (i) ;
}
return sumSq / inputV.size () - (sum * sum) / (inputV.size () * inputV.size ()) ;
}
template <class T>
double sigma (std::vector<T> const & inputV)
{
return sqrt (varianza (inputV)) ;
}
template <class T>
double asimmetria (std::vector<T> const & inputV)
{
double mediaV = media (inputV) ;
double asimmV = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i)
{
asimmV += pow ((inputV.at (i) - mediaV), 3.) ;
}
return asimmV / (inputV.size () * pow (sigma (inputV),3.)) ;
}
template <class T>
double curtosi (std::vector<T> const & inputV)
{
double mediaV = media (inputV) ;
double curtosiV = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i)
{
curtosiV += pow ((inputV.at (i) - mediaV), 4.) ;
}
return curtosiV / (inputV.size () * varianza (inputV) * varianza (inputV)) - 3. ;
}
#endif
7.5 studio delle caratteristiche della distribuzione di Poisson¶
esercizio05.cpp
/*
c++ -o esercizio05 `root-config --glibs --cflags` esercizio05.cpp casual.cc
*/
#include "casual.h"
#include "statistiche.h"
#include "TH1F.h"
#include "TGraph.h"
#include "TCanvas.h"
#include <iostream>
using namespace std ;
int main (int argc, char ** argv)
{
TGraph g_media ;
TGraph g_sigma ;
TGraph g_asimmetria ;
TGraph g_curtosi ;
// ciclo sulla media della distribuzione di Poisson
for (int mediaP = 1 ; mediaP < 101 ; mediaP+=5)
{
cout << "generazioni con media " << mediaP << endl ;
vector<int> campione ;
// ciclo su tanti pseudo-esperimenti
for (int i = 0 ; i < 1000000 ; ++i)
{
campione.push_back (rand_pois (mediaP)) ;
} // ciclo su tanti pseudo-esperimenti
g_media.SetPoint (g_media.GetN (), mediaP, media (campione)) ;
g_sigma.SetPoint (g_sigma.GetN (), mediaP, sigma (campione)) ;
g_asimmetria.SetPoint (g_asimmetria.GetN (), mediaP, asimmetria (campione)) ;
g_curtosi.SetPoint (g_curtosi.GetN (), mediaP, curtosi (campione)) ;
} // ciclo sulla media della distribuzione di Poisson
TCanvas c1 ("c1", "c1", 100, 100, 1000, 1000) ;
g_media.SetMarkerStyle (20) ;
g_media.SetMarkerColor (kAzure - 1) ;
g_media.SetLineColor (kGray + 1) ;
g_media.SetMarkerSize (2) ;
g_media.GetHistogram ()->GetXaxis ()->SetTitle ("media della distribuzione") ;
g_media.GetHistogram ()->GetYaxis ()->SetTitle ("media del campione") ;
g_media.Draw ("ALP") ;
c1.Print ("es5_media.gif", "gif") ;
g_sigma.SetMarkerStyle (20) ;
g_sigma.SetMarkerColor (kAzure - 1) ;
g_sigma.SetLineColor (kGray + 1) ;
g_sigma.SetMarkerSize (2) ;
g_sigma.GetHistogram ()->GetXaxis ()->SetTitle ("media della distribuzione") ;
g_sigma.GetHistogram ()->GetYaxis ()->SetTitle ("deviazione standard del campione") ;
g_sigma.Draw ("ALP") ;
c1.Print ("es5_sigma.gif", "gif") ;
g_asimmetria.SetMarkerStyle (20) ;
g_asimmetria.SetMarkerColor (kAzure - 1) ;
g_asimmetria.SetLineColor (kGray + 1) ;
g_asimmetria.SetMarkerSize (2) ;
g_asimmetria.GetHistogram ()->GetXaxis ()->SetTitle ("media della distribuzione") ;
g_asimmetria.GetHistogram ()->GetYaxis ()->SetTitle ("asimmetria del campione") ;
g_asimmetria.Draw ("ALP") ;
c1.Print ("es5_asimmetria.gif", "gif") ;
g_curtosi.SetMarkerStyle (20) ;
g_curtosi.SetMarkerColor (kAzure - 1) ;
g_curtosi.SetLineColor (kGray + 1) ;
g_curtosi.SetMarkerSize (2) ;
g_curtosi.GetHistogram ()->GetXaxis ()->SetTitle ("media della distribuzione") ;
g_curtosi.GetHistogram ()->GetYaxis ()->SetTitle ("curtosi del campione") ;
g_curtosi.Draw ("ALP") ;
c1.Print ("es5_curtosi.gif", "gif") ;
return 0 ;
}