Here is an example of a class that can compute 2nd order stats that will work 
for either scalar or complex types.

It could be made slightly more efficient.  It uses abs(), relying on the 
"trick" that abs() is defined for both scalar float and complex.  It could be 
improved by defining our own "norm" function for both scalar float and 
complex.  (Unfortunately for efficiency, complex norm is defined in terms of 
abs, which uses sqrt, on at least some systems (libstdc++)).

#ifndef _Stat_H
#define _Stat_H

//! $Id: Stat.H,v 1.1 2003/03/17 13:51:03 nbecker Exp $

#include <complex>

template<typename T>
struct Stat_t {
  typedef T value_t;
};

template<typename T>
struct Stat_t< std::complex<T> > {
  typedef typename std::complex<T>::value_type value_t;
};

template<typename T, typename cnt_t = int>
class Stat {
  typedef typename Stat_t<T>::value_t value_t;

  T sumX;
  value_t sumXsqr;
  cnt_t count;
public:
  Stat() :
    sumX (0),
    sumXsqr (0),
    count (0)
    {}

  void Reset() {
    sumX = 0;
    sumXsqr = 0;
    count = 0;
  }

  template<typename in_t>
  void Compute (in_t in, in_t inend) {
    for (; in != inend; in++)
      Compute (*in);
  }

  void Compute (T x) {
    operator += (x);
  }

  void operator += (T x) {
    count++;
    sumX += x;
    sumXsqr += (abs(x) * abs(x));
  }

  void operator() (T x) {
    operator += (x);
  }

  value_t Mean() const {
    if ( count > 0)
      return (sumX / count);
    else
      return ( 0.0 );
  }

  value_t Var() const {
    if (count > 1)
      return (sumXsqr - ((abs(sumX) * abs (sumX)) /  count)) / (count - 1);
    else
      return 0.0;
  }

  value_t StdDev() const {
    if (count <= 0)
	return 0;
    else
      return sqrt (Var());
  }

  value_t RMS() const {
    return StdDev();
  }

  cnt_t Cnt() const {
    return count;
  }

  value_t XsqrBar() const {
    return (sumXsqr / count);
  }
  
};

#endif
_______________________________________________
Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost

Reply via email to