Newsgroup: it.comp.lang.c++
Titolo: how to compile this file?

I have three file but I can't compile it... how can I do that?
Thankyou in advance, Mario.
-------------------------------------------------------------
ESP3.H
const double PI   = 3.1415926535897932384626433832795029;
const double mec2 = 0.511; //si puo' fare di meglio!
typedef double Energia;
enum TipoInterazione {COMPTON, FOTOELETTRICO};
class Random
{
  unsigned int seed;
public:
  Random();
  Random(unsigned int _seed);
  inline double Uniforme();
  inline double Normale();
};
class Mat_3_3; //forward declarations
class Cilindro;
//realizza un vettore 3D
class Vett_3
{
protected:
  double v[3];
 
public:
  Vett_3(double x = 0.0, double y = 0.0, double z = 0.0)
  { v[0] = x; v[1] = y; v[2] = z; }
  virtual void Stampa();
  double Mod();
  Vett_3 Molt(const Mat_3_3& );
  //overload dell'operatore somma
  //è parte dell'interfaccia, anche se non è un metodo
  friend Vett_3 operator*(const double, const Vett_3&);
  friend Vett_3 operator+(const Vett_3& , const Vett_3&);
  //friend bool Cilindro::Dentro(Vett_3 v);
  friend class Cilindro;
};
//specializza il vettore 3D al concetto di versore
class Vers_3 : public Vett_3
{
 public:
  //crea un versore
  Vers_3();
  Vers_3(double x, double y, double v);
  //converte in Vett_3 in un Vers_3
  Vers_3(const Vett_3& v3);
  //crea un versore da coordinate sferiche
  Vers_3(double theta, double phi);
  double Theta();
  double Phi();
  //lo sto ridefinendo rispetto alla classe base
  void Stampa();
};
//realizza una matrice 3x3
class Mat_3_3
{
  double m[3][3];
public:
  Mat_3_3(double m00 = 0.0, double m01 = 0.0, double m02 = 0.0, 
	  double m10 = 0.0, double m11 = 0.0, double m12 = 0.0, 
	  double m20 = 0.0, double m21 = 0.0, double m22 = 0.0);
  void Stampa(); 
  //è parte dell'interfaccia, anche se non è un metodo di Mat_3_3
  friend Vett_3 Vett_3::Molt(const Mat_3_3& m);
};
//geometria come in figura 
//(sorgente sul prolungamento dell'asse del cilindro, sull'asse z)
class Cilindro
{
protected:
  double dist_sorg_scint; //distanza rivelatore sorgente
  double raggio;
  double altezza;
 
  double theta_max; //massimo angolo azimutale dei fotoni incidenti
 
public:
  Cilindro(double h,  double a,  double r);  
  bool Dentro(Vett_3 v);
  bool Incide(Vers_3 v);  
};
class NaI
{
  //22 elementi: {energia, compton, fotoelettrico}
  static float en_mu[22][3];
public:
  double MuFotoelettrico(Energia e);
  double MuCompton(Energia e);
  double Mu(Energia e);
};
class Fotone; //forward decl
 
class Scintillatore : public Cilindro, public NaI
{
  static Random r;
public:
  Scintillatore(double h,  double a,  double r);
  bool Impatto(Fotone& f);//se il fotone incide viene aggiornata la sua pos. con quella d'impatto
  bool Interagisce(Fotone& f);////se il fotone interagisce viene aggiornata la sua posizione
  TipoInterazione Interazione(Fotone& f, Energia& e_dep); //sceglie il tipo di interazione, aggiorna lo stato del fotone e l'energia depositata
};
class Fotone
{
  Energia energia;
  Vett_3  coordinate;
  Vers_3  propagazione;
public:
  Fotone(Energia e, Vett_3 coord, Vers_3 prop);
  Energia GetEnergia() {return energia;} 
  void Stampa();
  friend class Scintillatore;
};
//classe di base astratta (ha un metodo pure-virtual)
//non si possono creare oggetti di questa classe!
class Sorgente
{
protected:
  static Random r;
  Vett_3 p;
public:
  Sorgente(Vett_3 ps) {p = ps;}
  Vers_3 EmissioneIsotropa();
  virtual Fotone Emetti() = 0; 
};
class SorgenteNa : public Sorgente
{
public:
  SorgenteNa(Vett_3 ps);
  Fotone Emetti();
};
class SorgenteCs : public Sorgente
{
public:
  SorgenteCs(Vett_3 ps);
  Fotone Emetti();
};
class SorgenteCo : public Sorgente
{
public:
  SorgenteCo(Vett_3 ps);
  Fotone Emetti();
};
class Istogramma
{
  static Random r;
  unsigned long* v;
  Energia delta;
  unsigned colonne;
  double A;
  Energia min;
  Energia max;
 public:
 
  Istogramma(Energia _delta, unsigned colonne, double A);
  unsigned long Inserisci(Energia val); //ritorna la colonna che è stata incrementata
  void Stampa(ostream &os = cout);
};
---------------------------------------------------------------------
ESP3.CC
#include <stdlib.h>  
#include <math.h>
#include <assert.h>
#include <iostream.h>
#include "esp3.h"
//metodi di Random
Random::Random()
{ 
  srand(1101969); 
  seed = 1101969; 
}
Random::Random(unsigned int _seed) 
{ 
  srand(_seed); 
  seed = _seed; 
}
inline double Random::Uniforme()
{
  double res = double(rand()) / double(RAND_MAX);
 
  return res;
}
//algoritmo Box-Mueller
inline double Random::Normale()
{
  double r1 = Uniforme(); 
  double r2 = Uniforme(); 
  double theta = 2.0 * PI * r2;
 
  double g = sqrt( 2.0 * log(1.0 / r1) ) * cos(theta);
  return g;
}
//metodi ed operatori di Vett_3
void Vett_3::Stampa() 
{ cout << "(" << v[0] << '\t' << v[1] << '\t' << v[2] << ")" << endl; }
double Vett_3::Mod()
{
  double ris = sqrt( v[0]*v[0] + v[1]*v[1] + v[2]*v[2] );
 
   return ris;
}
Vett_3 Vett_3::Molt(const Mat_3_3& mat)
{
  Vett_3 ris;
 
  for(int i = 0; i < 3; i++)
    {
      ris.v[i] = 0.0;
      for(int j = 0; j < 3; j++)
	ris.v[i] += mat.m[i][j] * v[i];
    }
 
  return ris;
}
Vett_3 operator*(const double op1, const Vett_3& op2)
{
  Vett_3 ris;
 
  for(int i = 0; i < 3; i++)
    ris.v[i] = op1 * op2.v[i];
  return ris;
}
Vett_3 operator+(const Vett_3& op1, const Vett_3& op2)
{
  Vett_3 ris;
 
  for(int i = 0; i < 3; i++)
    ris.v[i] = op1.v[i] + op2.v[i];
 
  return ris;
}
//metodi di Vers_3
Vers_3::Vers_3()
{
  v[0] = 1.0;
  v[1] = 0.0;
  v[2] = 0.0;
}
Vers_3::Vers_3(double x, double y, double z) : Vett_3(x, y, z)
{
  double inv_rad_mod = 1.0/Mod();
  v[0] = inv_rad_mod * v[0];
  v[1] = inv_rad_mod * v[1];
  v[2] = inv_rad_mod * v[2];
}
Vers_3::Vers_3(const Vett_3& v3) : Vett_3(v3) 
{
  double inv_rad_mod = 1.0/Mod();
  v[0] = inv_rad_mod * v[0];
  v[1] = inv_rad_mod * v[1];
  v[2] = inv_rad_mod * v[2];
}
 
Vers_3::Vers_3(double theta, double phi)
{
  v[0] = sin(theta) * cos(phi);
  v[1] = sin(theta) * sin(phi);
  v[2] = cos(theta);
}
double Vers_3::Theta()
{
  return acos(v[2]);
}
double Vers_3::Phi()
{
  return atan(v[1]/v[0]);
}
void Vers_3::Stampa() 
{ cout << "<" << v[0] << '\t' << v[1] << '\t' << v[2] << ">" << endl; }
//metodi di Mat_3_3
Mat_3_3::Mat_3_3(double m00 = 0.0, double m01 = 0.0, double m02 = 0.0, 
		 double m10 = 0.0, double m11 = 0.0, double m12 = 0.0, 
		 double m20 = 0.0, double m21 = 0.0, double m22 = 0.0)
{
  m[0][0] = m00; m[0][1] = m01; m[0][2] = m02;
  m[1][0] = m10; m[1][1] = m11; m[1][2] = m12;
  m[2][0] = m20; m[2][1] = m21; m[2][2] = m22;
}
void Mat_3_3::Stampa()
{
  for(int i = 0; i < 3; i++)
    {
      for(int j = 0; j < 3; j++)
	cout << m[i][j] << '\t';
 
      cout << endl;
    }
}
//metodi di Cilindro
Cilindro::Cilindro(double h,  double a,  double r) 
{ 
  dist_sorg_scint  = h; 
  raggio  = r;
  altezza = a; 
 
  theta_max =  dist_sorg_scint? atan(r/dist_sorg_scint) : PI/2.0;
}
bool Cilindro::Dentro(Vett_3 v)
{
  bool res = (fabs(v.v[0]) < raggio) && (fabs(v.v[1]) < raggio) && 
    (v.v[2] < (dist_sorg_scint + altezza)) && (v.v[2] > dist_sorg_scint);
 
  return res;
}
bool Cilindro::Incide(Vers_3 v)
{
  double theta_v = v.Theta();
 
  if(theta_v < theta_max)
    return true;
 
  return false;
}
//metodi di NaI
//ESERCIZIO: inserire i valori campionati
float NaI::en_mu[22][3] =
{
0.01,564.91466,0.6473,
0.015,178.47173,0.59441,
0.02,80.53353,0.58408,
0.03,26.25452,0.56344,
0.033,19.91214,0.55754,
0.034,110.91797,0.55754,
0.4,69.02874,0.54574,
0.05,37.90681,0.52951,
0.06,23.03908,0.51477,
0.08,10.39856,0.48822,
0.1,5.51639,0.46462,
0.15,1.74074,0.41889,
0.2,0.76699,0.38349,
0.3,0.24485,0.33334,
0.4,0.11372,0.29942,
0.5,0.06401,0.27302,
0.6,0.04086,0.25251,
0.8,0.02109,0.22184,
1,0.01313,0.19942,
1.5,0.00605,0.16195,
2,0.00369,0.1382,
3,0.00207,0.10871
};
double NaI::MuCompton(Energia e)
{
  register int i = 0;
 
  while( !( e >= en_mu[i][0] && e < en_mu[i+1][0]) )
    i++;
 
  double mu_compton = en_mu[i][1] + ( (en_mu[i+1][1] - en_mu[i][1]) / (en_mu[i+1][0] - en_mu[i][0]) ) * (e - en_mu[i][0]);
 
  return mu_compton;
}
double NaI::MuFotoelettrico(Energia e)
{
  register int i = 0;
  while( !( e >= en_mu[i][0] && e < en_mu[i+1][0]) )
    i++;
 
  double mu_foto = en_mu[i][2] + ( (en_mu[i+1][2] - en_mu[i][2]) / (en_mu[i+1][0] - en_mu[i][0]) ) * (e - en_mu[i][0]);
 
  return mu_foto;
}
double NaI::Mu(Energia e)
{
  double res = MuCompton(e) + MuFotoelettrico(e);
 
  return res;
}
//Metodi classe Scintillatore
Random Scintillatore::r(6532392);
Scintillatore::Scintillatore(double h,  double a,  double r) : Cilindro(h, a, r) {}
//se il fotone incide viene aggiornata la sua pos. con quella d'impatto
bool Scintillatore::Impatto(Fotone& f)
{
  if( Incide(f.propagazione) )
    {
      //Scintillatore friend di Fotone, aggiorna le coordinate di f con quelle del punto d'impatto
      f.coordinate = f.coordinate + (dist_sorg_scint/cos(f.propagazione.Theta())) * f.propagazione;
      return true;
    }
 
  return false;
}
//estrae un percorso e verifica se è compatibile con una interazione
bool Scintillatore::Interagisce(Fotone& f)
{
  Energia e_gamma = f.GetEnergia();
 
  double d = -( log(1 - r.Uniforme()) / Mu(e_gamma) );
 
  //aggiorna la posizione di possibile interazione del fotone
  f.coordinate = f.coordinate + d * f.propagazione;
 
  if(Dentro(f.coordinate))
    return true;
 
  return false;
}
//sceglie il tipo di interazione, se e` compton aggiorna lo stato del fotone, aggiorna l'energia depositata e quella del fotone
TipoInterazione Scintillatore::Interazione(Fotone& f, Energia& e_dep)
{
  Energia e_in = f.GetEnergia();
  double prob_compton = MuCompton(e_in) / Mu(e_in);
  double p = r.Uniforme();
 
  if(p > prob_compton)
    {
      //Caso Interazione Fotoelettrica
      //ESERCIZIO: implementare 
      //...
      return FOTOELETTRICO;
    }
  else
    {
      //Caso Interazione Compton
      //ESERCIZIO: implementare
      return COMPTON;
    }
 
}
 
//Metodi classe Fotone
Fotone::Fotone(Energia e, Vett_3 coord, Vers_3 prop)
{
  energia = e;
  coordinate = coord;
  propagazione = prop;
}
void Fotone::Stampa()
{
  cout << "Energia: " << energia << endl;
  coordinate.Stampa();
  propagazione.Stampa();
}
//Metodi classe Sorgente e derivate
Random Sorgente::r;
Vers_3 Sorgente::EmissioneIsotropa()
{
  double theta = r.Uniforme() * PI;
  double phi   = r.Uniforme() * 2.0 * PI;
 
  Vers_3 res(theta, phi);
  return res;
}
SorgenteNa::SorgenteNa(Vett_3 ps) : Sorgente(ps) {}
Fotone SorgenteNa::Emetti()
{
  Energia e_source;
 
  Vers_3 propagazione = EmissioneIsotropa();
 
  if(r.Uniforme() < 0.7)
    e_source = 0.511;
  else
    e_source = 1.27;
 
  Fotone res(e_source, p, propagazione);
 
  return res;
}
SorgenteCs::SorgenteCs(Vett_3 ps) : Sorgente(ps) {}
Fotone SorgenteCs::Emetti()
{
  Energia e_source = 0.662;
 
  Vers_3 propagazione = EmissioneIsotropa();
 
  Fotone res(e_source, p, propagazione);
 
  return res;
}
SorgenteCo::SorgenteCo(Vett_3 ps) : Sorgente(ps) {}
Fotone SorgenteCo::Emetti()
{
 Energia e_source;
 
  Vers_3 propagazione = EmissioneIsotropa();
 
  if(r.Uniforme() < 0.7)
    e_source = 0.511;
  else
    e_source = 1.27;
 
  Fotone res(e_source, p, propagazione);
 
  return res;
}
 
//Metodi classe Istogramma
Random Istogramma::r(1545375);
Istogramma::Istogramma(Energia _delta, unsigned _colonne, double _A)
{
  assert(_colonne >= 1);
  assert(_delta > 0);
 
  v = new unsigned long(_colonne);
  for(unsigned i = 0; i < _colonne; i++)
    v[i] = 0;
  delta = _delta;
  colonne = _colonne;
  A = _A;
  min = delta;
  max = delta * colonne;
}
//ritorna il valore inserito(errore gaussiano aggiunto)
unsigned long Istogramma::Inserisci(Energia e)
{
  unsigned indice;
  Energia e_mis = e + A * r.Normale() / sqrt(e);
 
  if(e_mis < min)
    indice = 0;
  else if(e_mis > max)
    indice = colonne-1;
  else
    indice = unsigned( (e_mis / max) * (colonne-1) + 1);
 
  v[indice]++;
  return indice;
}
 
void Istogramma::Stampa(ostream &os = cout)
{
  for(unsigned i = 0; i < colonne; i++)
    os << dec << i << "\t" << v[i] << endl;
}
 
--------------------------------------------------------------------
MAIN.cc
#include <iostream.h>
#include <stdlib.h>
void main()
{
  unsigned num_fotoni = 10000, n_colonne = 400;
  Energia e_min = 0.005, delta_e = 0.005;
  double  h_legno=1., h_scint=5.08, r_scint=2.74;
  double A = 0.0697;
  Vett_3 origine(0.0, 0.0, 0.0);
  SorgenteCs sorg(origine);
  Scintillatore scint(h_legno, h_scint, r_scint);
  Istogramma isto(delta_e, n_colonne, A);
 
  unsigned i = 0;
  while(i < num_fotoni)
    {
      Fotone f = sorg.Emetti();
      Energia e_dep;
      if(scint.Impatto(f))
	{
	  e_dep = 0.0;
	  bool processa_fotone = true;
	  while(processa_fotone)
	    {
	      if(!scint.Interagisce(f)) //esce dal while
		break;
	      switch ( scint.Interazione(f, e_dep) )
		{
		case FOTOELETTRICO:
		  processa_fotone = false;
		  break;
		case COMPTON:
		  if(f.GetEnergia() < e_min)
		    processa_fotone = false;
		  break;
		default:
		  //ERRORE
		  cerr << "Errore: Tipo di interazione sconosciuto." << endl;
		  exit(0);
		}
	    }//while(processa_fotone)
	} //if(scint.Impatto(f))
      isto.Inserisci(e_dep);
 
      i++;
    }
  isto.Stampa();
}

 I have three file but I can't compile it... how can I do that?
The ability to compile several files and produce a single executable is a
function of the particular compiler you use.  Some compilers use a _make
file_ and the latest compilers from say Borland or Microsoft use a
more-or-less GUI approach to this.  Borland calls it an IDE (Integrated
Development Environment?) and I suppose Microsoft has some cute name too.
Please repost in a NG related to *your* compiler.

Hi,
You may not be aware that you posted your message on the italian C++
newsgroup (the "it" in the group's name stands for "Italy").
Best regards,
Nicola Musatti