source: trunk/src/WeightedAverager.h @ 101

// $Id: WeightedAverager.h 101 2004-06-10 15:34:39Z peter $

#ifndef _theplu_cpptools_weighted_averager_
#define _theplu_cpptools_weighted_averager_

//#include <cmath>
#include "Averager.h"

namespace theplu{
namespace cpptools{
  ///
  /// Averager class with weights. 
  ///
  class WeightedAverager
  {
  public:

    ///
    /// Default constructor
    ///
    WeightedAverager(void);

    ///
    /// Constructor taking the data point, i.e. the value and its
    /// weight (default = 1)
    ///
    WeightedAverager(const double, const double=1);

    ///
    /// Copy constructor
    ///
    WeightedAverager(const WeightedAverager&);

    ///
    /// adding a data point d, with weight w (default is 1)
    ///
    inline void add(const double d,const double w=1)
    {w_.add(w); wx_.add(w*d); wwx_+=w*w*d;}

    ///
    /// Calculating the average according to: \f$ \frac{\sum
    /// w_ix_i}{\sum w_i}\f$ @return average
    ///
    inline double average(void) const {return mean();}

    ///
    ///Calculating the mean according to: \f$ \frac{\sum
    ///w_ix_i}{\sum w_i} \f$ @return average
    ///
    inline double mean(void) const { return sum_w() ? 
                                       sum_wx()/sum_w() : 0; }
  
    ///
    /// resets everything to zero
    ///
    inline void reset(void) { wx_.reset(); w_.reset(); wwx_=0;}

    ///
    /// Calculating the squared error according to: \f$ \frac{\sum
    /// w_i^2(x_i-m)^2}{(\sum w_i)^2} \f$ @return squared error
    ///
    inline double squared_error(void) const 
    { return (sum_wwxx()-2*mean()*wwx_+
              mean()*mean()*sum_ww()) / (sum_w()*sum_w()); }

    ///
    /// Calculating the sum of weights: \f$ \sum
    /// w_i \f$ @return sum of weights
    ///
    inline double sum_w(void) const 
    { return w_.sum_x(); }

    ///
    /// \f$ \sum w_i^2 \f$ @return sum of squared weights
    ///
    inline double sum_ww(void)  const 
    { return w_.sum_xsqr(); }
    
    ///
    /// \f$ \sum w_ix_i \f$ @return weighted sum of x
    ///
    inline double sum_wx(void)  const 
    { return w_.sum_xsqr(); }
    
    ///
    ///  @return \f$ \sum w_i^2x_i^2 \f$
    ///
    inline double sum_wwxx(void)  const 
    { return wx_.sum_xsqr(); }
    
    ///
    ///  @return \f$ \sum w_i^2x_i \f$
    ///
    inline double sum_wwx(void) const 
    { return wwx_; }

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

    ///
    /// operator to add a WeightedAverager
    ///
    inline WeightedAverager operator+=(WeightedAverager& a)
    { wx_+=a.wx(); w_+=a.w(); wwx_+=a.sum_wwx(); return *this; }

    ///
    /// operator to rescale object, i.e. each data point is rescaled
    /// \f$ x = d * x \f$
    ///
    inline WeightedAverager operator*=(double d)
    { wx_*=d; wwx_*=d; return *this; }


  private:
    Averager w_;
    Averager wx_;
    double wwx_;
    
    inline Averager wx(void) const {return wx_;}
    inline Averager w(void) const {return w_;}


  };


}} // of namespace cpptools and namespace theplu

#endif