#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/moment.hpp>
#include <complex>
using namespace boost::accumulators;

typedef std::complex<double> complex_t;
template<typename flt_t>
inline std::complex<flt_t> operator/ (std::complex<flt_t> const& a, unsigned long int b) {
  return std::complex<flt_t> (real (a)/b, imag (a)/b);
}

namespace boost { namespace accumulators { namespace impl {
      template<typename Sample>
      struct abs_sqr_accumulator
	: accumulator_base {
	typedef typename Sample::value_type result_type;

	template<typename Args>
	abs_sqr_accumulator (Args const& args) {}

	template<typename Args>
	void operator () (Args const& args) {
	  this->sum += real (args[sample] * conj (args[sample]));
	}

	template<typename Args>
	result_type result (Args const& args) const {
	  return numeric::average (this->sum, count (args));
	}

	result_type sum;
      };
    }}}
namespace boost { namespace accumulators { namespace tag {
      struct abs_sqr
	: depends_on< count >        // depends_on<> to specify dependencies
      {
	// Define a nested typedef called 'impl' that specifies which
	// accumulator implements this feature. 
	typedef accumulators::impl::abs_sqr_accumulator< mpl::_1 > impl;
      };
    }}}

template<typename result_t, typename acc_t>
inline result_t get_abs_sqr (acc_t const& acc) {
  return abs_sqr (acc);
}

int main () {
  typedef std::complex<double> value_t;
  typedef accumulator_set<value_t, stats<tag::mean, tag::abs_sqr > > acc_t;

  acc_t acc;

  typedef value_t::value_type scalar_t;
  double result = get_abs_sqr<scalar_t, acc_t> (acc);
}