Index: trunk/SophyaLib/HiStats/histos2.h
===================================================================
--- trunk/SophyaLib/HiStats/histos2.h	(revision 1053)
+++ trunk/SophyaLib/HiStats/histos2.h	(revision 1092)
@@ -28,23 +28,23 @@
 
   // CREATOR / DESTRUCTOR
-  Histo2D(float xMin, float xMax, int nxBin
-         ,float yMin, float yMax, int nyBin);
+  Histo2D(r_8 xMin,r_8 xMax,int_4 nxBin,r_8 yMin,r_8 yMax,int_4 nyBin);
+  Histo2D(r_4 xMin,r_4 xMax,int_4 nxBin,r_4 yMin,r_4 yMax,int_4 nyBin);
   Histo2D(const Histo2D& h);
   Histo2D();
-  virtual  ~Histo2D();
+  virtual ~Histo2D();
 
   // OPTIONS
-  void   Errors();  
+  void Errors();  
   
   // UPDATING
-  void   Zero();
-  void   Add(float x, float y, float w = 1.);
+  void Zero();
+  void Add(r_8 x, r_8 y, r_8 w = 1.);
 
   // Operators
   Histo2D& operator = (const Histo2D& h);
-  Histo2D& operator *= (double b);
-  Histo2D& operator /= (double b);
-  Histo2D& operator += (double b);
-  Histo2D& operator -= (double b);
+  Histo2D& operator *= (r_8 b);
+  Histo2D& operator /= (r_8 b);
+  Histo2D& operator += (r_8 b);
+  Histo2D& operator -= (r_8 b);
   Histo2D& operator += (const Histo2D& a);
   Histo2D& operator -= (const Histo2D& a);
@@ -58,6 +58,6 @@
   void GetError2(TMatrix<r_8>& v);
   void GetError(TMatrix<r_8>& v);
-  void PutValue(TMatrix<r_8>& v, int ierr=0);
-  void PutValueAdd(TMatrix<r_8>& v, int ierr=0);
+  void PutValue(TMatrix<r_8>& v, int_4 ierr=0);
+  void PutValueAdd(TMatrix<r_8>& v, int_4 ierr=0);
   void PutError2(TMatrix<r_8>& v);
   void PutError2Add(TMatrix<r_8>& v);
@@ -66,125 +66,134 @@
   // INLINES
   //! Retourne l'abscisse minimum.
-  inline float   XMin() const {return xmin;}
+  inline r_8 XMin() const {return mXmin;}
   //! Retourne l'abscisse maximum.
-  inline float   XMax() const {return xmax;}
+  inline r_8 XMax() const {return mXmax;}
   //! Retourne l'ordonnee minimum.
-  inline float   YMin() const {return ymin;}
+  inline r_8 YMin() const {return mYmin;}
   //! Retourne l'ordonnee maximum.
-  inline float   YMax() const {return ymax;}
+  inline r_8 YMax() const {return mYmax;}
   //! Retourne le nombre de bins selon X.
-  inline int_4   NBinX() const {return nx;}
+  inline int_4 NBinX() const {return mNx;}
   //! Retourne le nombre de bins selon Y.
-  inline int_4   NBinY() const {return ny;}
+  inline int_4 NBinY() const {return mNy;}
   //! Retourne la largeur du bin selon X.
-  inline float   WBinX() const {return wbinx;}
+  inline r_8 WBinX() const {return mWBinx;}
   //! Retourne la largeur du bin selon Y.
-  inline float   WBinY() const {return wbiny;}
+  inline r_8 WBinY() const {return mWBiny;}
   //! Retourne le pointeur sur le tableaux des contenus.
-  inline float*  Bins() const  {return data;}
+  inline r_8* Bins() const  {return mData;}
   //! Retourne le contenu du bin i,j.
-  inline float   operator()(int i,int j) const {return data[j*nx+i];}
+  inline r_8 operator()(int_4 i,int_4 j) const {return mData[j*mNx+i];}
   //! Remplit le contenu du bin i,j.
-  inline float&  operator()(int i,int j)       {return data[j*nx+i];}
+  inline r_8& operator()(int_4 i,int_4 j)      {return mData[j*mNx+i];}
   //! retourne "true" si il y a des erreurs stoquees
-  inline bool    HasErrors() { if(err2) return true; else return false;}
+  inline bool HasErrors() { if(mErr2) return true; else return false;}
   //! Retourne l'erreur du bin i,j.
-  inline float   Error(int i,int j)  const
-                   {if(err2)
-                      {if(err2[j*nx+i]>0.) return sqrt(err2[j*nx+i]); else return 0.;}
-                    else return 0.;}
+  inline r_8 Error(int_4 i,int_4 j)  const
+    {if(mErr2)
+       {if(mErr2[j*mNx+i]>0.) return sqrt(mErr2[j*mNx+i]); else return 0.;}
+     else return 0.;}
   //! Remplit l'erreur au carre du bin i,j.
-  inline double  Error2(int i,int j) const
-                   {if(err2) return err2[j*nx+i]; else return 0.;}
+  inline r_8 Error2(int_4 i,int_4 j) const
+             {if(mErr2) return mErr2[j*mNx+i]; else return 0.;}
   //! Remplit l'erreur au carre du bin i,j.
-  inline double& Error2(int i,int j) {return err2[j*nx+i];}
+  inline r_8& Error2(int_4 i,int_4 j) {return mErr2[j*mNx+i];}
   //! Retourne la somme ponderee.
-  inline float   NData() const    {return (float) nHist;}
+  inline r_8 NData() const    {return nHist;}
   //! Retourne le nombre d'entrees.
-  inline int_4   NEntries() const {return nEntries;}
+  inline int_4 NEntries() const {return nEntries;}
   //! Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j.
-  inline void BinLowEdge(int i,int j,float& x,float& y)
-                 {x = xmin + i*wbinx; y = ymin + j*wbiny;}
+  inline void BinLowEdge(int_4 i,int_4 j,r_8& x,r_8& y)
+              {x = mXmin + i*mWBinx; y = mYmin + j*mWBiny;}
+  //! Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j.
+  inline void BinLowEdge(int_4 i,int_4 j,r_4& xf,r_4& yf)
+              {r_8 x,y; BinLowEdge(i,j,x,y); xf=x; yf=y;}
   //! Retourne l'abscisse et l'ordonnee du centre du bin i,j.
-  inline void BinCenter(int i,int j,float& x,float& y)
-                 {x = xmin + (i+0.5)*wbinx; y = ymin + (j+0.5)*wbiny;}
+  inline void BinCenter(int_4 i,int_4 j,r_8& x,r_8& y)
+              {x = mXmin + (i+0.5)*mWBinx; y = mYmin + (j+0.5)*mWBiny;}
+  //! Retourne l'abscisse et l'ordonnee du centre du bin i,j.
+  inline void BinCenter(int_4 i,int_4 j,r_4& xf,r_4& yf)
+              {r_8 x,y; BinCenter(i,j,x,y); xf=x; yf=y;}
   //! Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j.
-  inline void BinHighEdge(int i,int j,float& x,float& y)
-                 {x = xmin + (i+1)*wbinx; y = ymin + (j+1)*wbiny;}
+  inline void BinHighEdge(int_4 i,int_4 j,r_8& x,r_8& y)
+              {x = mXmin + (i+1)*mWBinx; y = mYmin + (j+1)*mWBiny;}
+  //! Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j.
+  inline void BinHighEdge(int_4 i,int_4 j,r_4& xf,r_4& yf)
+              {r_8 x,y; BinHighEdge(i,j,x,y); xf=x; yf=y;}
   //! Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y.
-  inline void FindBin(float x,float y,int& i,int& j)
-    { i = (int) floorf((x - xmin)/wbinx); j = (int) floorf((y - ymin)/wbiny);}
+  inline void FindBin(r_8 x,r_8 y,int_4& i,int_4& j)
+    {i=(int_4) floor((x-mXmin)/mWBinx); j=(int_4) floor((y-mYmin)/mWBiny);}
 
   // Info, statistique et calculs sur les histogrammes
-  float   NOver(int i=-1,int j=-1) const;
-  int     BinNonNul() const;
-  int     ErrNonNul() const;
-  void    IJMax(int& imax,int& jmax,int il=1,int ih= -1,int jl=1,int jh= -1);
-  void    IJMin(int& imax,int& jmax,int il=1,int ih= -1,int jl=1,int jh= -1);
-  float   VMax(int il=1,int ih= -1,int jl=1,int jh= -1) const;
-  float   VMin(int il=1,int ih= -1,int jl=1,int jh= -1) const;
-  int     EstimeMax(float& xm,float& ym,int SzPav = 3
-                   ,int il=1,int ih= -1,int jl=1,int jh= -1);
-  int     EstimeMax(int im,int jm,float& xm,float& ym,int SzPav = 3);
-  int     FindMax(int& im,int& jm,int SzPav = 3,float Dz = 0.
-                 ,int il=1,int ih= -1,int jl=1,int jh= -1);
+  r_8   NOver(int_4 i=-1,int_4 j=-1) const;
+  int_4 BinNonNul() const;
+  int_4 ErrNonNul() const;
+  void IJMax(int_4& imax,int_4& jmax,int_4 il=1,int_4 ih= -1,int_4 jl=1,int_4 jh= -1);
+  void IJMin(int_4& imax,int_4& jmax,int_4 il=1,int_4 ih= -1,int_4 jl=1,int_4 jh= -1);
+  r_8 VMax(int_4 il=1,int_4 ih= -1,int_4 jl=1,int_4 jh= -1) const;
+  r_8 VMin(int_4 il=1,int_4 ih= -1,int_4 jl=1,int_4 jh= -1) const;
+  int_4 EstimeMax(r_8& xm,r_8& ym,int_4 SzPav = 3
+                 ,int_4 il=1,int_4 ih= -1,int_4 jl=1,int_4 jh= -1);
+  int_4 EstimeMax(int_4 im,int_4 jm,r_8& xm,r_8& ym,int_4 SzPav = 3);
+  int_4 FindMax(int_4& im,int_4& jm,int_4 SzPav = 3,r_8 Dz = 0.
+               ,int_4 il=1,int_4 ih= -1,int_4 jl=1,int_4 jh= -1);
 
   // Fit
-  int      Fit(GeneralFit& gfit,unsigned short typ_err=0);
-  Histo2D  FitResidus(GeneralFit& gfit);
-  Histo2D  FitFunction(GeneralFit& gfit);
+  int_4   Fit(GeneralFit& gfit,unsigned short typ_err=0);
+  Histo2D FitResidus(GeneralFit& gfit);
+  Histo2D FitFunction(GeneralFit& gfit);
 
   // Print et Display ASCII
-  void    PrintStatus();
-  void    Print(float min=1.,float max=-1.
-               ,int il=1,int ih= -1,int jl=1,int jh= -1);
+  void PrintStatus();
+  void Print(r_8 min=1.,r_8 max=-1.
+               ,int_4 il=1,int_4 ih= -1,int_4 jl=1,int_4 jh= -1);
 
   // PROJECTIONS
-  void           SetProjX();
-  void           SetProjY();
-  void           SetProj();
-  void           DelProjX();
-  void           DelProjY();
-  void           DelProj();
-  void           ZeroProjX();
-  void           ZeroProjY();
-  void           ZeroProj();
+  void SetProjX();
+  void SetProjY();
+  void SetProj();
+  void DelProjX();
+  void DelProjY();
+  void DelProj();
+  void ZeroProjX();
+  void ZeroProjY();
+  void ZeroProj();
   //! Retourne le pointeur sur l'histo 1D de la projection selon X.
-  inline Histo*  HProjX() const {return hprojx;}
+  inline Histo* HProjX() const {return mHprojx;}
   //! Retourne le pointeur sur l'histo 1D de la projection selon Y.
-  inline Histo*  HProjY() const {return hprojy;}
-  void           ShowProj();
+  inline Histo* HProjY() const {return mHprojy;}
+  void ShowProj();
 
   // BANDES
   //! Retourne le nombre de bandes selon X
-  inline int     NBandX() const {return lbandx.size();}
+  inline int_4 NBandX() const {return mLBandx.size();}
   //! Retourne le nombre de bandes selon Y
-  inline int     NBandY() const {return lbandy.size();}
-  int            SetBandX(float ybmin,float ybmax);
-  int            SetBandY(float xbmin,float xbmax);
-  void           DelBandX();
-  void           DelBandY();
-  void           ZeroBandX();
-  void           ZeroBandY();
-  Histo*         HBandX(int n) const;
-  Histo*         HBandY(int n) const;
-  void           GetBandX(int n,float& ybmin,float& ybmax) const;
-  void           GetBandY(int n,float& xbmin,float& xbmax) const;
-  void           ShowBand(int lp = 0);
+  inline int_4 NBandY() const {return mLBandy.size();}
+  int_4 SetBandX(r_8 ybmin,r_8 ybmax);
+  int_4 SetBandY(r_8 xbmin,r_8 xbmax);
+  void DelBandX();
+  void DelBandY();
+  void ZeroBandX();
+  void ZeroBandY();
+  Histo* HBandX(int_4 n) const;
+  Histo* HBandY(int_4 n) const;
+  void GetBandX(int_4 n,r_8& ybmin,r_8& ybmax) const;
+  void GetBandY(int_4 n,r_8& xbmin,r_8& xbmax) const;
+  void ShowBand(int_4 lp = 0);
 
   // SLICES
   //! Retourne le nombre de slices selon X
-  inline int     NSliX() const {return lslix.size();}
+  inline int_4 NSliX() const {return mLSlix.size();}
   //! Retourne le nombre de slices selon Y
-  inline int     NSliY() const {return lsliy.size();}
-  int            SetSliX(int nsli);
-  int            SetSliY(int nsli);
-  void           DelSliX();
-  void           DelSliY();
-  void           ZeroSliX();
-  void           ZeroSliY();
-  Histo*         HSliX(int n) const;
-  Histo*         HSliY(int n) const;
-  void           ShowSli(int lp = 0);
+  inline int_4 NSliY() const {return mLSliy.size();}
+  int_4 SetSliX(int_4 nsli);
+  int_4 SetSliY(int_4 nsli);
+  void DelSliX();
+  void DelSliY();
+  void ZeroSliX();
+  void ZeroSliY();
+  Histo* HSliX(int_4 n) const;
+  Histo* HSliY(int_4 n) const;
+  void ShowSli(int_4 lp = 0);
 
 #ifndef __DECCXX
@@ -193,8 +202,8 @@
   //! structure de definition des bandes
   struct bande_slice {
-    int num;   //!< nombre de bandes
-    float min; //!< limite minimum pour remplir la bande
-    float max; //!< limite maximum pour remplir la bande
-    Histo* H;  //!< pointer sur l Histo 1D de la bande
+    int_4 num;   //!< nombre de bandes
+    r_8 min;     //!< limite minimum pour remplir la bande
+    r_8 max;     //!< limite maximum pour remplir la bande
+    Histo* H;    //!< pointer sur l Histo 1D de la bande
     STRUCTCOMP(bande_slice)
   };
@@ -205,31 +214,31 @@
   void Delete();
 
-  float*         data; //!< donnees
-  double*        err2; //!< erreurs carrees
-
-  float          over[3][3]; //!< overflow table
-  double         nHist;      //!< somme ponderee des entrees
-  int_4          nEntries;   //!< nombre d'entrees
-
-  int_4          nx;    //!< nombre de bins en X
-  int_4          ny;    //!< nombre de bins en Y
-  int_4          nxy;   //!< nombre de bins total
-  float          xmin;  //!< abscisse minimum
-  float          xmax;  //!< abscisse maximum
-  float          ymin;  //!< ordonnee minimum
-  float          ymax;  //!< ordonnee maximum
-  float          wbinx; //!< largeur du bin en X
-  float          wbiny; //!< largeur du bin en Y
-
-  bande_slice    b_s;
-
-  Histo*         hprojx; //!< pointer sur Histo des proj X
-  Histo*         hprojy; //!< pointer sur Histo des proj Y
-
-  list<bande_slice>  lbandx; //!< liste des bandes selon X
-  list<bande_slice>  lbandy; //!< liste des bandes selon Y
+  r_8*        mData; //!< donnees
+  r_8*        mErr2; //!< erreurs carrees
+
+  r_8         mOver[3][3]; //!< overflow table
+  r_8         nHist;       //!< somme ponderee des entrees
+  int_4       nEntries;    //!< nombre d'entrees
+
+  int_4       mNx;    //!< nombre de bins en X
+  int_4       mNy;    //!< nombre de bins en Y
+  int_4       mNxy;   //!< nombre de bins total
+  r_8         mXmin;  //!< abscisse minimum
+  r_8         mXmax;  //!< abscisse maximum
+  r_8         mYmin;  //!< ordonnee minimum
+  r_8         mYmax;  //!< ordonnee maximum
+  r_8         mWBinx; //!< largeur du bin en X
+  r_8         mWBiny; //!< largeur du bin en Y
+
+  bande_slice mB_s;
+
+  Histo*      mHprojx; //!< pointer sur Histo des proj X
+  Histo*      mHprojy; //!< pointer sur Histo des proj Y
+
+  list<bande_slice>  mLBandx; //!< liste des bandes selon X
+  list<bande_slice>  mLBandy; //!< liste des bandes selon Y
   
-  list<bande_slice>  lslix; //!< liste des slices selon X
-  list<bande_slice>  lsliy; //!< liste des slices selon Y
+  list<bande_slice>  mLSlix; //!< liste des slices selon X
+  list<bande_slice>  mLSliy; //!< liste des slices selon Y
 
 };
@@ -250,7 +259,7 @@
 // ObjFileIO<Histo2D>
 
-/*! \ingroup HiStats \fn operator*(const Histo2D&,double)
+/*! \ingroup HiStats \fn operator*(const Histo2D&,r_8)
   \brief Operateur H2 = H1 * b */
-inline Histo2D operator * (const Histo2D& a, double b)
+inline Histo2D operator * (const Histo2D& a, r_8 b)
 {
   Histo2D result(a);
@@ -258,7 +267,7 @@
 }
 
-/*! \ingroup HiStats \fn operator*(double,const Histo2D&)
+/*! \ingroup HiStats \fn operator*(r_8,const Histo2D&)
   \brief Operateur H2 = b * H1 */
-inline Histo2D operator * (double b, const Histo2D& a)
+inline Histo2D operator * (r_8 b, const Histo2D& a)
 {
   Histo2D result(a);
@@ -266,7 +275,7 @@
 }
 
-/*! \ingroup HiStats \fn operator/(const Histo2D&,double)
+/*! \ingroup HiStats \fn operator/(const Histo2D&,r_8)
   \brief Operateur H2 = H1 / b */
-inline Histo2D operator / (const Histo2D& a, double b)
+inline Histo2D operator / (const Histo2D& a, r_8 b)
 {
   Histo2D result(a);
@@ -274,7 +283,7 @@
 }
 
-/*! \ingroup HiStats \fn operator+(const Histo2D&,double)
+/*! \ingroup HiStats \fn operator+(const Histo2D&,r_8)
   \brief Operateur H2 = H1 + b */
-inline Histo2D operator + (const Histo2D& a, double b)
+inline Histo2D operator + (const Histo2D& a, r_8 b)
 {
   Histo2D result(a);
@@ -282,7 +291,7 @@
 }
 
-/*! \ingroup HiStats \fn operator+(double,const Histo2D&)
+/*! \ingroup HiStats \fn operator+(r_8,const Histo2D&)
   \brief Operateur H2 = b + H1 */
-inline Histo2D operator + (double b, const Histo2D& a)
+inline Histo2D operator + (r_8 b, const Histo2D& a)
 {
   Histo2D result(a);
@@ -290,7 +299,7 @@
 }
 
-/*! \ingroup HiStats \fn operator-(const Histo2D&,double)
+/*! \ingroup HiStats \fn operator-(const Histo2D&,r_8)
   \brief Operateur H2 = H1 - b */
-inline Histo2D operator - (const Histo2D& a, double b)
+inline Histo2D operator - (const Histo2D& a, r_8 b)
 {
   Histo2D result(a);
@@ -298,7 +307,7 @@
 }
 
-/*! \ingroup HiStats \fn operator-(double,const Histo2D&)
+/*! \ingroup HiStats \fn operator-(r_8,const Histo2D&)
   \brief Operateur H2 = b - H1 */
-inline Histo2D operator - (double b, const Histo2D& a)
+inline Histo2D operator - (r_8 b, const Histo2D& a)
 {
   Histo2D result(a);
