[accumulator] std::chrono::duration in boost::accumulator

12 Feb 2017

      I want to build a histogram of
`std::chrono::high_resolution_clock::duration` object. For this issue i
wanted to use boost::accumulators as the framework.

As it did not compile in my project i teared it down and based it on a
running example with `double` as a data type.

My general goal on my project is to do use for everything united types.
Time and all measured stuff. I would want to avoid to use `.count()` on
the duration.

Is there any known workaround around this?

it is not dependent on the compiler as it seems. With gcc 6.3 it failes too.

It compiles when i use

    clang++-3.9 --std=c++14 -g -O0 main.cpp

But when i set the define USE_CHRONO it failes with the error:

    clang++-3.9 --std=c++14 -g -O0 -DUSE_CHRONO main.cpp
    In file included from main.cpp:7:
    /usr/include/boost/accumulators/statistics/density.hpp:75:15: error:
no matching constructor for initialization of 'array_type' (aka
'vector
...
...
')
                , samples_in_bin(num_bins + 2, 0.)
                  ^              ~~~~~~~~~~~~~~~~
and here is my teared down example. I used this site as a base and
exhanged double to data_t.
http://programmingexamples.net/wiki/CPP/Boost/Histogram

    #include <vector>
    #include <algorithm>
    #include <iostream>
    #include <chrono>

    #include 
    #include 
    #include 

    using namespace boost;
    using namespace boost::accumulators;

    using duration_t = std::chrono::high_resolution_clock::duration;
    #ifdef USE_CHRONO
    using data_t = duration_t;
    data_t construct(double d)
    {
            return std::chrono::milliseconds(0);
    }
    #else
    using data_t = double;
    data_t construct(double d)
    {
            return d;
    }

    #endif

    using acc =  accumulator_settag::density >;
    using histogram_type = iterator_range >::iterator >;

    template <typename T>
    class data_filler
    {
    public:
      data_filler(){}
      T operator()() { return rand()/(T)RAND_MAX; }
    };

    template <>
    class data_filler
    {
    public:
      data_filler(){}
      duration_t operator()() { return
std::chrono::milliseconds(rand()/RAND_MAX); }
    };

    int main(int argc, char** argv)
    {

      //create some random data
      std::vector data(100);
      std::generate(data.begin(), data.end(), data_filler());
      int c = data.size();//cache size for histogramm.

      //create an accumulator
      acc myAccumulator( tag::density::num_bins = 20,
tag::density::cache_size = 10);

      //fill accumulator
      for (int j = 0; j < c; ++j)
      {
        myAccumulator(data[j]);
      }

      auto hist = density(myAccumulator);

      data_t total = construct(0.0);

      for( int i = 0; i < hist.size(); i++ )
      {
    //    std::cout << "Bin lower bound: " << hist[i].first << ", Value: "
<< hist[i].second << std::endl;
        total += hist[i].second;
      }

      //std::cout << "Total: " << total << std::endl; //should be 1 (and
it is)

      return 0;
    }

georg＠schorsch-tech.de

tags

participants (1)