Héritage

#include <fstream>



#include <iostream>



#include <cstdlib>



#include <cmath>



using namespace std;





class Uniforme



{



  friend ostream& operator<<(ostream& os, const Uniforme& uniforme);





public:





  Uniforme();



  Uniforme(const int nomb);



  Uniforme(const Uniforme& uniforme);





  virtual ~Uniforme();



  void get_MomentsUpTo2();

  

  void Sauve();





  int _nombre;



  double * _var;

};







Uniforme::Uniforme()



  : _nombre(0), _var(new double[1])



{



  _var[0] = 0;



}







Uniforme::Uniforme(const int nomb):_nombre(nomb),_var(new double[nomb])



{





for (int k=0;k<_nombre;k++)

{



double tir = drand48();



		_var[k] = tir;

}		



}







Uniforme::Uniforme(const Uniforme& uniforme)



{





  _nombre = uniforme._nombre;



  _var = new double[_nombre];

  

  for (int i=0;i<_nombre;i++)





		_var[i] = uniforme._var[i];



}







Uniforme::~Uniforme()



{



  delete [] _var;



}





ostream&



operator<<(ostream& os, const Uniforme& uniforme)



{

  for (int i=0;i<uniforme._nombre;i++)





  os << uniforme._var[i]<<endl;



  return os;



}



void Uniforme::Sauve()



{



  ofstream fic("result.dat");

  

  for (int i=0;i<_nombre;i++)





  fic << _var[i]<<endl;



 

}





void Uniforme::get_MomentsUpTo2()

 

  {

    double m=0.;

	double variance=0.;

	

	for (int i=0;i<_nombre;i++)

	{

	m+=_var[i];

	variance+=_var[i]*_var[i];

	}

	



	m=m/_nombre;

	variance=1./(_nombre)*variance - ( double (_nombre)/(_nombre - 1))*m*m;

    

	cout<<"La moyenne est: "<<m<<endl;

	cout<<"La variance est: "<<variance<<endl;



	  

   

 

   }





class Normale : private Uniforme



{



public:





	Normale();

	

	Normale(const int nomb, const double m, const double sig);

	

	Normale(const Normale& normale);

	

	virtual ~Normale();

	

	

	void get_momentsUpTo2();

	

private:	

	

	double * _nvar;

	int _nnombre;

	double _moyenne;

	double _sigma;

	

}  





Normale::Normale()



	: _nnombre(0),_moyenne(0),_sigma(0), _nvar(new double[1]),Uniforme()



{



  _nvar[0] = 0;



}







Normale::Normale(const int nomb, const double m, const double sig):_nnombre(nomb),_moyenne(m),_sigma(sig),_nvar(new double[nomb]),Uniforme(nomb)



{



if (!(_nnombre%2))					// Si _nnombre est pair

  {

		for(int i=0;i<_nnombre;i+2)

				{	double Z1=sqrt(-2*log(_var[i]))*cos(2*M_PI*_var[i+1]);

					double Z2=sqrt(-2*log(_var[i]))*sin(2*M_PI*_var[i+1]);

					_nvar[i]=_sigma *Z1+_moyenne;

					_nvar[i+1]=_sigma *Z2+_moyenne;

				

				}



  }

  

else						//Si _nnombre est impair

	

		for(int k=0;k<_nnombre - 2;k+2)

				{	double Z1=sqrt(-2*log(_var[k]))*cos(2*M_PI*_var[k+1]);

					double Z2=sqrt(-2*log(_var[k]))*sin(2*M_PI*_var[k+1]);

					_nvar[k]=_sigma *Z1+_moyenne;

					_nvar[k+1]=_sigma *Z2+_moyenne;

				

				}

				





  	



}







Normale::Normale(const Normale& normale)



{





  _nnombre = normale._nnombre;



  _nvar = new double[_nnombre];

  

  _moyenne=normale._moyenne;

  

  _sigma=normale._sigma;

  

  

  for (int i=0;i<_nnombre;i++)





		_nvar[i] = normale._nvar[i];



}





void Normale::get_momentsUpTo2()

 

  {

    double m=0.;

	double variance=0.;

	

	for (int i=0;i<_nnombre;i++)

	{

	m+=_nvar[i];

	variance+=_nvar[i]*_nvar[i];

	}

	



	m=m/_nnombre;

	variance=1./(_nnombre)*variance - ( double (_nnombre)/(_nnombre - 1))*m*m;

    

	cout<<"La moyenne est: "<<m<<endl;

	cout<<"La variance est: "<<variance<<endl;



	  

   

 

   }









Normale::~Normale()



{



  delete [] _nvar;



}







int main()



{



  srand48(103);





  Uniforme u1(10000.);

  

  cout<<u1;



  u1.get_MomentsUpTo2();



  Normale n1(10000.,0,1);

  

  n1.get_momentsUpTo2();





  return 0;



}