| /////////////////////////////////////////////////////////////////////////////// |
| // main.hpp |
| // |
| // Copyright 2005 Eric Niebler. Distributed under the Boost |
| // Software License, Version 1.0. (See accompanying file |
| // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| |
| #include <iostream> |
| #include <algorithm> |
| #include <boost/ref.hpp> |
| #include <boost/bind.hpp> |
| #include <boost/array.hpp> |
| #include <boost/foreach.hpp> |
| #include <boost/accumulators/accumulators.hpp> |
| #include <boost/accumulators/statistics.hpp> |
| |
| using namespace boost; |
| using namespace boost::accumulators; |
| |
| // Helper that uses BOOST_FOREACH to display a range of doubles |
| template<typename Range> |
| void output_range(Range const &rng) |
| { |
| bool first = true; |
| BOOST_FOREACH(double d, rng) |
| { |
| if(!first) std::cout << ", "; |
| std::cout << d; |
| first = false; |
| } |
| std::cout << '\n'; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // example1 |
| // |
| // Calculate some useful stats using accumulator_set<> and std::for_each() |
| // |
| void example1() |
| { |
| accumulator_set< |
| double |
| , stats<tag::min, tag::mean(immediate), tag::sum, tag::moment<2> > |
| > acc; |
| |
| boost::array<double, 4> data = {0., 1., -1., 3.14159}; |
| |
| // std::for_each pushes each sample into the accumulator one at a |
| // time, and returns a copy of the accumulator. |
| acc = std::for_each(data.begin(), data.end(), acc); |
| |
| // The following would be equivalent, and could be more efficient |
| // because it doesn't pass and return the entire accumulator set |
| // by value. |
| //std::for_each(data.begin(), data.end(), bind<void>(ref(acc), _1)); |
| |
| std::cout << " min""(acc) = " << (min)(acc) << std::endl; // Extra quotes are to prevent complaints from Boost inspect tool |
| std::cout << " mean(acc) = " << mean(acc) << std::endl; |
| |
| // since mean depends on count and sum, we can get their results, too. |
| std::cout << " count(acc) = " << count(acc) << std::endl; |
| std::cout << " sum(acc) = " << sum(acc) << std::endl; |
| std::cout << " moment<2>(acc) = " << accumulators::moment<2>(acc) << std::endl; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // example2 |
| // |
| // Calculate some tail statistics. This demonstrates how to specify |
| // constructor and accumulator parameters. Note that the tail statistics |
| // return multiple values, which are returned in an iterator_range. |
| // |
| // It pushes data in and displays the intermediate results to demonstrate |
| // how the tail statistics are updated. |
| void example2() |
| { |
| // An accumulator which tracks the right tail (largest N items) and |
| // some data that are covariate with them. N == 4. |
| accumulator_set< |
| double |
| , stats<tag::tail_variate<double, tag::covariate1, right> > |
| > acc(tag::tail<right>::cache_size = 4); |
| |
| acc(2.1, covariate1 = .21); |
| acc(1.1, covariate1 = .11); |
| acc(2.1, covariate1 = .21); |
| acc(1.1, covariate1 = .11); |
| |
| std::cout << " tail = "; output_range(tail(acc)); |
| std::cout << " tail_variate = "; output_range(tail_variate(acc)); |
| std::cout << std::endl; |
| |
| acc(21.1, covariate1 = 2.11); |
| acc(11.1, covariate1 = 1.11); |
| acc(21.1, covariate1 = 2.11); |
| acc(11.1, covariate1 = 1.11); |
| |
| std::cout << " tail = "; output_range(tail(acc)); |
| std::cout << " tail_variate = "; output_range(tail_variate(acc)); |
| std::cout << std::endl; |
| |
| acc(42.1, covariate1 = 4.21); |
| acc(41.1, covariate1 = 4.11); |
| acc(42.1, covariate1 = 4.21); |
| acc(41.1, covariate1 = 4.11); |
| |
| std::cout << " tail = "; output_range(tail(acc)); |
| std::cout << " tail_variate = "; output_range(tail_variate(acc)); |
| std::cout << std::endl; |
| |
| acc(32.1, covariate1 = 3.21); |
| acc(31.1, covariate1 = 3.11); |
| acc(32.1, covariate1 = 3.21); |
| acc(31.1, covariate1 = 3.11); |
| |
| std::cout << " tail = "; output_range(tail(acc)); |
| std::cout << " tail_variate = "; output_range(tail_variate(acc)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // example3 |
| // |
| // Demonstrate how to calculate weighted statistics. This example demonstrates |
| // both a simple weighted statistical calculation, and a more complicated |
| // calculation where the weight statistics are calculated and stored in an |
| // external weight accumulataor. |
| void example3() |
| { |
| // weight == double |
| double w = 1.; |
| |
| // Simple weighted calculation |
| { |
| // stats that depend on the weight are made external |
| accumulator_set<double, stats<tag::mean>, double> acc; |
| |
| acc(0., weight = w); |
| acc(1., weight = w); |
| acc(-1., weight = w); |
| acc(3.14159, weight = w); |
| |
| std::cout << " mean(acc) = " << mean(acc) << std::endl; |
| } |
| |
| // Weighted calculation with an external weight accumulator |
| { |
| // stats that depend on the weight are made external |
| accumulator_set<double, stats<tag::mean>, external<double> > acc; |
| |
| // Here's an external weight accumulator |
| accumulator_set<void, stats<tag::sum_of_weights>, double> weight_acc; |
| |
| weight_acc(weight = w); acc(0., weight = w); |
| weight_acc(weight = w); acc(1., weight = w); |
| weight_acc(weight = w); acc(-1., weight = w); |
| weight_acc(weight = w); acc(3.14159, weight = w); |
| |
| std::cout << " mean(acc) = " << mean(acc, weights = weight_acc) << std::endl; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // main |
| int main() |
| { |
| std::cout << "Example 1:\n"; |
| example1(); |
| |
| std::cout << "\nExample 2:\n"; |
| example2(); |
| |
| std::cout << "\nExample 3:\n"; |
| example3(); |
| |
| return 0; |
| } |