source: trunk/src/Averager.h @ 138

// $Id: Averager.h 138 2004-08-20 10:30:37Z peter $

#ifndef _theplu_cpptools_averager_
#define _theplu_cpptools_averager_

#include <cmath>
#include "vector.h"

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 value of first data point.
    ///
    Averager(const double);
    
    ///
    /// Constructor taking sum of x, sum of squared x and number of
    /// samples.
    ///
    Averager(const double, const double, const long);

    ///
    /// Constructor taking gslapi::vector.
    ///
    Averager(const gslapi::vector&);
    
    ///
    /// Copy constructor
    ///
    Averager(const Averager&);
    
    ///
    /// adding n(default=1) number of data point(s) with value d.
    ///
    inline void add(const double d,const long n=1)
    {n_+=n; x_+=n*d; xx_+=n*d*d;}

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

    ///
    /// @return sum of squared values \f$ \sum x_i^2 \f$
    ///
    inline double average_sqr(void) const {return mean_sqr();}
  
    ///
    /// @return average \f$ \frac{\sum x_i}{n} \f$
    ///
    inline double mean(void) const { return n_ ? x_/n_ : 0; }
  
    ///
    /// @return @return sum of squared values \f$ \sum x_i^2 \f$.
    ///
    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_=0; x_=xx_=0.0;}

    ///
    /// The standard deviation is defined as the square root of the
    /// variance. @return standard deviation
    ///
    inline double standard_deviation(void) const {  return sqrt(variance()); }

    ///
    /// The standard deviation is defined as the square root of the
    /// variance. @return standard deviation
    ///
    inline double std(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, which
    ///means it is the best unbiased estimator of the variance \f$
    ///\frac{1}{N-1}\sum_i (x_i-m)^2\f$, where \f$m\f$ is the
    ///mean@return variance
    ///
    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:
    long  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