| # Gaudi Framework, version v20r3
Generated: 24 Nov 2008

# Gaudi::Utils::HistoStats Class Reference

`#include <GaudiUtils/HistoStats.h>`

List of all members.

## Detailed Description

The collection of trivial functions to access the statistical information for the histograms.

Author:
  Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
  2007-08-06

Definition at line 27 of file HistoStats.h.

## Static Public Member Functions
static double | moment (const AIDA::IHistogram1D *histo, const unsigned int order, const double value=0)
| get the "bin-by-bin"-moment around the specified "value"
static double | momentErr (const AIDA::IHistogram1D *histo, const unsigned int order)
| evaluate the uncertanty for 'bin-by-bin'-moment
static double | centralMoment (const AIDA::IHistogram1D *histo, const unsigned int order)
| evaluate the 'bin-by-bin'-central moment (around the mean value)
static double | centralMomentErr (const AIDA::IHistogram1D *histo, const unsigned int order)
| evaluate the uncertanty for 'bin-by-bin'-central moment (around the mean value) ( the uncertanty is calculated with O(1/n2) precision)
static double | skewness (const AIDA::IHistogram1D *histo)
| get the skewness for the histogram
static double | skewnessErr (const AIDA::IHistogram1D *histo)
| get the error in skewness for the histogram
static double | kurtosis (const AIDA::IHistogram1D *histo)
| get the kurtosis for the histogram
static double | kurtosisErr (const AIDA::IHistogram1D *histo)
| get the error in kurtosis for the histogram
static double | mean (const AIDA::IHistogram1D *histo)
| get the mean value for the histogram (just for completeness)
static double | meanErr (const AIDA::IHistogram1D *histo)
| get an error in the mean value
static double | rms (const AIDA::IHistogram1D *histo)
| get the rms value for the histogram (just for completeness)
static double | rmsErr (const AIDA::IHistogram1D *histo)
| get an error in the rms value
static double | nEff (const AIDA::IHistogram1D *histo)
| get the effective entries (just for completeness)

## Member Function Documentation

double Gaudi::Utils::HistoStats::moment | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order,
|  | const double | value = `0` |
| ) |  |  | `[static]`

get the "bin-by-bin"-moment around the specified "value"

Parameters:

  | histo | histogram
  | order | the moment parameter
  | value | central value

Returns:
  the evaluated moment

Definition at line 42 of file HistoStats.cpp.

    00045 {
    00046   if ( 0 == histo ) { return s_bad ; }                       // RETURN
    00047   if ( 0 == order ) { return 1.0   ; }                       // RETURN
    00048   if ( 1 == order ) { return mean( histo ) - value ; }       // RETURN
    00049   if ( 2 == order )
    00050   {
    00051     const double _r =         rms  ( histo ) ;
    00052     const double _d = value - mean ( histo ) ;
    00053     return _r *_r + _d * _d ;                            // RETURN
    00054   }
    00055   const double n = nEff ( histo )  ;
    00056   if ( 0 >= n     ) { return 0.0   ; }                    // RETURN
    00057
    00058   const int _order = (int) order ;
    00059
    00060   // get the exis
    00061   const AIDA::IAxis& axis = histo -> axis () ;
    00062   // number of bins
    00063   const int nBins = axis.bins() ;
    00064   double result = 0 ;
    00065   double weight = 0 ;
    00066   // loop over all bins
    00067   for ( int i = 0 ; i < nBins ; ++i )
    00068   {
    00069     const double lE   = axis . binLowerEdge ( i ) ;
    00070     const double uE   = axis . binUpperEdge ( i ) ;
    00071     //
    00072     const double yBin = histo -> binHeight    ( i ) ;   // bin weight
    00073     const double xBin = 0.5 * ( lE + uE ) ;             // bin center
    00074     //
    00075     weight += yBin ;
    00076     result += yBin * std::pow ( xBin - value , _order ) ;
    00077   }
    00078   if ( 0 != weight ) { result /= weight ; }
    00079   return result ;
    00080 }

double Gaudi::Utils::HistoStats::momentErr | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order |
| ) |  |  | `[static]`

evaluate the uncertanty for 'bin-by-bin'-moment

Parameters:

  | histo | histogram
  | order | the moment parameter
  | value | central value

Returns:
  the evaluated uncertanty in the moment

Definition at line 90 of file HistoStats.cpp.

    00092 {
    00093   if ( 0 == histo ) { return s_bad ; }                   // RETURN
    00094   const double n = nEff ( histo ) ;
    00095   if ( 0 >= n     ) { return 0.0   ; }                   // RETURN
    00096   const double a2o = moment ( histo , 2 * order ) ;   // a(2o)
    00097   const double ao  = moment ( histo , 2 * order ) ;   // a(o)
    00098   double result = a2o - ao*ao ;
    00099   result        /= n ;
    00100   result = std::max ( 0.0 , result ) ;
    00101   return std:: sqrt ( result ) ;                            // RETURN
    00102 }

double Gaudi::Utils::HistoStats::centralMoment | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order |
| ) |  |  | `[static]`

evaluate the 'bin-by-bin'-central moment (around the mean value)

Parameters:

  | histo | histogram
  | order | the moment parameter
  | value | central value

Returns:
  the evaluated central moment

Definition at line 112 of file HistoStats.cpp.

    00114 {
    00115   if ( 0 == histo ) { return s_bad ; }                        // RETURN
    00116   if ( 0 == order ) { return 1.0   ; }                        // RETURN
    00117   if ( 1 == order ) { return 0.0   ; }                        // RETURN
    00118   if ( 2 == order )
    00119   {
    00120     const double sigma = histo->rms() ;
    00121     return sigma * sigma ;                                    // RETURN
    00122   }
    00123   // delegate the actual evaluation to another method:
    00124   return moment ( histo , order , mean ( histo ) ) ;
    00125 }

double Gaudi::Utils::HistoStats::centralMomentErr | ( | const AIDA::IHistogram1D * | histo,
|  | const unsigned int | order |
| ) |  |  | `[static]`

evaluate the uncertanty for 'bin-by-bin'-central moment (around the mean value) ( the uncertanty is calculated with O(1/n2) precision)

Parameters:

  | histo | histogram
  | order | the moment parameter
  | value | central value

Returns:
  the evaluated uncertanty in the central moment

Definition at line 137 of file HistoStats.cpp.

    00139 {
    00140   if ( 0 == histo ) { return s_bad ; }                    // RETURN
    00141   const double n    = nEff ( histo ) ;
    00142   if ( 0 >= n     ) { return 0.0   ; }                    // RETURN
    00143   const double mu2  = centralMoment ( histo , 2             ) ; // mu(2)
    00144   const double muo  = centralMoment ( histo ,     order     ) ; // mu(o)
    00145   const double mu2o = centralMoment ( histo , 2 * order     ) ; // mu(2o)
    00146   const double muom = centralMoment ( histo ,     order - 1 ) ; // mu(o-1)
    00147   const double muop = centralMoment ( histo ,     order + 1 ) ; // mu(o+1)
    00148   double result  =  mu2o  ;
    00149   result        -=  2.0   * order * muom * muop ;
    00150   result        -=  muo   * muo   ;
    00151   result        +=  order * order * mu2  * muom * muom ;
    00152   result        /=  n     ;
    00153   result = std::max ( 0.0 , result ) ;
    00154   return std:: sqrt ( result ) ;                            // RETURN
    00155 }

double Gaudi::Utils::HistoStats::skewness | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get the skewness for the histogram

Definition at line 160 of file HistoStats.cpp.

    00161 {
    00162   if ( 0 == histo ) { return s_bad ; }                      // RETURN
    00163   const double mu3 = centralMoment ( histo , 3 ) ;
    00164   const double s3  = std::pow ( rms ( histo ) , 3 ) ;
    00165   return ( std::fabs(s3)>0 ? mu3/s3 : 0.0 );
    00166 }

double Gaudi::Utils::HistoStats::skewnessErr | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get the error in skewness for the histogram

Definition at line 171 of file HistoStats.cpp.

    00172 {
    00173   if ( 0 == histo ) { return s_bad ; }                     // RETURN
    00174   const double n = nEff ( histo ) ;
    00175   if ( 2 > n      ) { return 0.0   ; }                     // RETURN
    00176   double result = 6 ;
    00177   result *= ( n - 2 )  ;
    00178   result /= ( n + 1 ) * ( n + 3 ) ;
    00179   return std::sqrt ( result ) ;
    00180 }

double Gaudi::Utils::HistoStats::kurtosis | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get the kurtosis for the histogram

Definition at line 185 of file HistoStats.cpp.

    00186 {
    00187   if ( 0 == histo ) { return s_bad ; }                    // RETURN
    00188   const double mu4 = centralMoment ( histo , 4 ) ;
    00189   const double s4  = std::pow ( rms ( histo ) , 4 ) ;
    00190   return ( std::fabs(s4)>0 ? mu4/s4 - 3.0 : 0.0 );
    00191 }

double Gaudi::Utils::HistoStats::kurtosisErr | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get the error in kurtosis for the histogram

Definition at line 196 of file HistoStats.cpp.

    00197 {
    00198   if ( 0 == histo ) { return s_bad ; }                    // RETURN
    00199   const double n = nEff ( histo ) ;
    00200   if ( 3 > n      ) { return 0.0 ; }                      // RETURN
    00201   double result = 24 ;
    00202   result *= ( n - 2 ) * ( n - 3 ) ;
    00203   result /= ( n + 1 ) * ( n + 1 ) ;
    00204   result /= ( n + 3 ) * ( n + 5 ) ;
    00205   return std::sqrt ( result ) ;
    00206 }

double Gaudi::Utils::HistoStats::mean | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get the mean value for the histogram (just for completeness)

Definition at line 220 of file HistoStats.cpp.

    00221 {
    00222   if ( 0 == histo ) { return s_bad ; }
    00223   return histo -> mean() ;
    00224 }

double Gaudi::Utils::HistoStats::meanErr | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get an error in the mean value

Definition at line 229 of file HistoStats.cpp.

    00230 {
    00231   if ( 0 == histo ) { return s_bad ; }
    00232   const double n = nEff ( histo ) ;
    00233   return 0 >= n ? 0.0 : rms ( histo ) / std::sqrt ( n ) ;
    00234 }

double Gaudi::Utils::HistoStats::rms | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get the rms value for the histogram (just for completeness)

Definition at line 239 of file HistoStats.cpp.

    00240 {
    00241   if ( 0 == histo ) { return s_bad ; }
    00242   return histo -> rms () ;
    00243 }

double Gaudi::Utils::HistoStats::rmsErr | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get an error in the rms value

Definition at line 248 of file HistoStats.cpp.

    00249 {
    00250   if ( 0 == histo ) { return s_bad ; }
    00251   const double n = nEff ( histo ) ;
    00252   if ( 1 >=  n ) { return 0.0 ; }
    00253   double result = 2 + kurtosis ( histo ) ;
    00254   result += 2.0 /( n - 1 ) ;
    00255   result /= 4.0 * n ;
    00256   result = std::max ( result , 0.0 ) ;
    00257   return histo -> rms() * std::sqrt ( result ) ;
    00258 }

double Gaudi::Utils::HistoStats::nEff | ( | const AIDA::IHistogram1D * | histo | ) | `[static]`

get the effective entries (just for completeness)

Definition at line 211 of file HistoStats.cpp.

    00212 {
    00213   if ( 0 == histo ) { return s_bad ; }
    00214   return histo -> equivalentBinEntries () ;
    00215 }

The documentation for this class was generated from the following files:

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiUtils/GaudiUtils/HistoStats.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiUtils/src/Lib/HistoStats.cpp