[Boost-users] library accumulator, example sum_accumulator

From: Kim Kuen Tang (kuentang_at_[hidden])
Date: 2008-08-31 07:18:07

Hi all,

i ' ve written a piece of code to get the class sum_accumulator working 
which is described in the user's guide
http://boost-sandbox.sourceforge.net/libs/accumulators/doc/html/accumulators/user_s_guide.html#accumulators.user_s_guide.the_accumulators_framework.extending_the_accumulators_framework.

The function result must be provided with a struct dont_care.
And the constructor of dont_care must be provided with a value to get an 
instanciation.
In my opinion a default constructor taking no arguments  for the struct 
dont_care must exists so the user can write code like dont_care().

To get the example working i must write code like
sumacc.result(*dont_care(0.0)*) to get the result from my accumulator.
And this is a little bit unnecessary.

with regards,
Kim Tang

the code below is tested with visual studio 2008.

#include <iostream>
#include <boost/accumulators/framework/accumulator_base.hpp>
#include <boost/accumulators/framework/parameters/sample.hpp>

using namespace boost::accumulators;

namespace boost {                           // Putting your accumulators 
in the
namespace accumulators {                    // impl namespace has some
namespace impl {                            // advantages. See below.

template<typename Sample>
struct sum_accumulator                      // All accumulators should 
inherit from
  : accumulator_base                        // accumulator_base.
{
    typedef Sample result_type;             // The type returned by 
result() below.
    
    template<typename Args>                 // The constructor takes an 
argument pack.
    sum_accumulator(Args const & args)
      : sum(args[sample | Sample()])        // Maybe there is an initial 
value in the
    {                                       // argument pack. ('sample' 
is defined in
    }                                       // sample.hpp, included above.)
    
    template<typename Args>                 // The accumulate function 
is the function
    void operator ()(Args const & args)     // call operator, and it 
also accepts an
    {                                       // argument pack.
        this->sum += args[sample];
    }
    
    result_type result(dont_care) const     // The result function will 
also be passed
    {                                       // an argument pack, but we 
don't use it here,
        return this->sum;                   // so we use "dont_care" as 
the argument type.
    }
private:
    Sample sum;
};

}}}

int main()
{
    try
    {
        boost::accumulators::impl::sum_accumulator<double> 
sumacc(sample=0.0);
        sumacc(sample=1.2);
        std::cout<<sumacc.result(*dont_care(0.0)*)<<"\n";

        return EXIT_SUCCESS;
    }
    catch(std::exception& e)
    {
        std::cout<<"Errors with message: "<<e.what()<<"\n";
        return EXIT_FAILURE;
    }
    catch(...)
    {
        std::cout<<"Unknown Errors \n";
        return EXIT_FAILURE;
    }

}