source: trunk/src/Averager.h @ 95

// $Id: Averager.h 95 2004-06-09 16:01:43Z peter $

#ifndef _theplu_cpptools_averager_
#define _theplu_cpptools_averager_

#include <cmath>

namespace theplu{
namespace cpptools{
  class ostream;
  ///
  /// Modified version of the Averager class written by Patrik Eden,
  /// Dept. Theoretical Physic, Lund University, Sweden
  ///
  class Averager
  {
  public:

    ///
    /// Default constructor
    ///
    Averager(void);
    
    ///
    /// Constructor taking the first value.
    ///
    Averager(double);
    
    ///
    /// Constructor taking sum of x, sum of squared x and number of
    /// samples.
    ///
    Averager(double, double, long);
    
    ///
    /// Copy constructor
    ///
    Averager(const Averager&);
    
    ///
    /// adding a data point d, with weight w (default is 1)
    ///
    inline void add(const double d,const double w=1)
    {n_+=w; x_+=d*w; xx_+=d*d*w;}

    ///
    /// @return average
    ///
    inline double average(void) const {return mean();}

    ///
    /// @return second moment (mean of squares)
    ///
    inline double average_sqr(void) const {return mean_sqr();}
  
    ///
    /// @return average
    ///
    inline double mean(void) const { return n_ ? x_/n_ : 0; }
  
    ///
    /// @return second moment (mean of squares)
    ///
    inline double mean_sqr(void) const { return n_ ? xx_/n_ : 0; }

    ///
    /// @return number of data points
    ///
    inline double n(void) const { return n_; }

    ///
    /// resets everything to zero
    ///
    inline void reset(void) { n_=x_=xx_=0;}

    ///
    /// @return standard deviation
    ///
    inline double standard_deviation(void) const {  return sqrt(variance()); }

    ///
    /// @return standard error, i.e. standard deviation of the mean
    ///
    inline double standard_error(void) const { return sqrt(variance()/n_); }

    ///
    /// @return the sum of x
    ///
    inline double sum_x(void) const { return x_; }

    ///
    /// @return the sum of squares
    ///
    inline double sum_xsqr(void) const { return xx_; }

    ///
    ///The variance is calculated using the (n-1) correction so the
    ///expectation value is unbiased @return variance of mean
    ///
    inline double variance(void) const 
    { return (n_>1) ? (xx_-x_*x_/n_)/(n_-1) : 0; }

    ///
    /// equality operator
    ///
    inline Averager operator=(const Averager& a)
    { n_=a.n_; x_=a.x_; xx_=a.xx_; return *this; }

    ///
    /// operator to add a double to the object
    ///
    inline Averager operator+=(double d)
    { add(d); return *this; }

    ///
    /// operator to add a "one"
    ///
    inline Averager operator++(void)
    { add(1); return *this; }

    ///
    /// Operator to rescale the object
    ///
    inline Averager operator*=(double d)
    { x_*=d; xx_*=d*d; return *this; }

    ///
    /// Operator to rescale the object
    ///
    inline Averager operator/=(double d)
    { return (*this)*=(1/d); }

    ///
    /// operator to add another Averager
    ///
    const Averager& operator+=(const Averager&);

    ///
    /// operator to multiply with an Averager. See code for details.
    ///
    const Averager& operator*=(const Averager&);

    ///
    /// operator to multiply with an Averager. See code for details.
    ///
    const Averager& operator/=(const Averager&);

  private:
    double  n_;
    double  x_, xx_;
  };

  Averager operator*(double,const Averager&);
  
  ///
  /// The output operator 
  ///
  std::ostream& operator<<( std::ostream&, const Averager&);


}} // of namespace cpptools and namespace theplu

#endif