boost/accumulators/statistics/mean.hpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // mean.hpp
   3 //
   4 //  Copyright 2005 Eric Niebler. Distributed under the Boost
   5 //  Software License, Version 1.0. (See accompanying file
   6 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7
   8 #ifndef BOOST_ACCUMULATORS_STATISTICS_MEAN_HPP_EAN_28_10_2005
   9 #define BOOST_ACCUMULATORS_STATISTICS_MEAN_HPP_EAN_28_10_2005
  10
  11 #include <boost/mpl/placeholders.hpp>
  12 #include <boost/accumulators/framework/accumulator_base.hpp>
  13 #include <boost/accumulators/framework/extractor.hpp>
  14 #include <boost/accumulators/numeric/functional.hpp>
  15 #include <boost/accumulators/framework/parameters/sample.hpp>
  16 #include <boost/accumulators/framework/depends_on.hpp>
  17 #include <boost/accumulators/statistics_fwd.hpp>
  18 #include <boost/accumulators/statistics/count.hpp>
  19 #include <boost/accumulators/statistics/sum.hpp>
  20
  21 namespace boost { namespace accumulators
  22 {
  23
  24 namespace impl
  25 {
  26     ///////////////////////////////////////////////////////////////////////////////
  27     // mean_impl
  28     //      lazy, by default
  29     template<typename Sample, typename SumFeature>
  30     struct mean_impl
  31       : accumulator_base
  32     {
  33         // for boost::result_of
  34         typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
  35
  36         mean_impl(dont_care) {}
  37
  38         template<typename Args>
  39         result_type result(Args const &args) const
  40         {
  41             extractor<SumFeature> sum;
  42             return numeric::average(sum(args), count(args));
  43         }
  44     };
  45
  46     template<typename Sample, typename Tag>
  47     struct immediate_mean_impl
  48       : accumulator_base
  49     {
  50         // for boost::result_of
  51         typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
  52
  53         template<typename Args>
  54         immediate_mean_impl(Args const &args)
  55           : mean(numeric::average(args[sample | Sample()], numeric::one<std::size_t>::value))
  56         {
  57         }
  58
  59         template<typename Args>
  60         void operator ()(Args const &args)
  61         {
  62             std::size_t cnt = count(args);
  63             this->mean = numeric::average(
  64                 (this->mean * (cnt - 1)) + args[parameter::keyword<Tag>::get()]
  65               , cnt
  66             );
  67         }
  68
  69         result_type result(dont_care) const
  70         {
  71             return this->mean;
  72         }
  73
  74     private:
  75         result_type mean;
  76     };
  77
  78 } // namespace impl
  79
  80 ///////////////////////////////////////////////////////////////////////////////
  81 // tag::mean
  82 // tag::immediate_mean
  83 // tag::mean_of_weights
  84 // tag::immediate_mean_of_weights
  85 // tag::mean_of_variates
  86 // tag::immediate_mean_of_variates
  87 //
  88 namespace tag
  89 {
  90     struct mean
  91       : depends_on<count, sum>
  92     {
  93         /// INTERNAL ONLY
  94         ///
  95         typedef accumulators::impl::mean_impl<mpl::_1, sum> impl;
  96     };
  97     struct immediate_mean
  98       : depends_on<count>
  99     {
 100         /// INTERNAL ONLY
 101         ///
 102         typedef accumulators::impl::immediate_mean_impl<mpl::_1, tag::sample> impl;
 103     };
 104     struct mean_of_weights
 105       : depends_on<count, sum_of_weights>
 106     {
 107         typedef mpl::true_ is_weight_accumulator;
 108         /// INTERNAL ONLY
 109         ///
 110         typedef accumulators::impl::mean_impl<mpl::_2, sum_of_weights> impl;
 111     };
 112     struct immediate_mean_of_weights
 113       : depends_on<count>
 114     {
 115         typedef mpl::true_ is_weight_accumulator;
 116         /// INTERNAL ONLY
 117         ///
 118         typedef accumulators::impl::immediate_mean_impl<mpl::_2, tag::weight> impl;
 119     };
 120     template<typename VariateType, typename VariateTag>
 121     struct mean_of_variates
 122       : depends_on<count, sum_of_variates<VariateType, VariateTag> >
 123     {
 124         /// INTERNAL ONLY
 125         ///
 126         typedef mpl::always<accumulators::impl::mean_impl<VariateType, sum_of_variates<VariateType, VariateTag> > > impl;
 127     };
 128     template<typename VariateType, typename VariateTag>
 129     struct immediate_mean_of_variates
 130       : depends_on<count>
 131     {
 132         /// INTERNAL ONLY
 133         ///
 134         typedef mpl::always<accumulators::impl::immediate_mean_impl<VariateType, VariateTag> > impl;
 135     };
 136 }
 137
 138 ///////////////////////////////////////////////////////////////////////////////
 139 // extract::mean
 140 // extract::mean_of_weights
 141 // extract::mean_of_variates
 142 //
 143 namespace extract
 144 {
 145     extractor<tag::mean> const mean = {};
 146     extractor<tag::mean_of_weights> const mean_of_weights = {};
 147     BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, mean_of_variates, (typename)(typename))
 148 }
 149
 150 using extract::mean;
 151 using extract::mean_of_weights;
 152 using extract::mean_of_variates;
 153
 154 // mean(lazy) -> mean
 155 template<>
 156 struct as_feature<tag::mean(lazy)>
 157 {
 158     typedef tag::mean type;
 159 };
 160
 161 // mean(immediate) -> immediate_mean
 162 template<>
 163 struct as_feature<tag::mean(immediate)>
 164 {
 165     typedef tag::immediate_mean type;
 166 };
 167
 168 // mean_of_weights(lazy) -> mean_of_weights
 169 template<>
 170 struct as_feature<tag::mean_of_weights(lazy)>
 171 {
 172     typedef tag::mean_of_weights type;
 173 };
 174
 175 // mean_of_weights(immediate) -> immediate_mean_of_weights
 176 template<>
 177 struct as_feature<tag::mean_of_weights(immediate)>
 178 {
 179     typedef tag::immediate_mean_of_weights type;
 180 };
 181
 182 // mean_of_variates<VariateType, VariateTag>(lazy) -> mean_of_variates<VariateType, VariateTag>
 183 template<typename VariateType, typename VariateTag>
 184 struct as_feature<tag::mean_of_variates<VariateType, VariateTag>(lazy)>
 185 {
 186     typedef tag::mean_of_variates<VariateType, VariateTag> type;
 187 };
 188
 189 // mean_of_variates<VariateType, VariateTag>(immediate) -> immediate_mean_of_variates<VariateType, VariateTag>
 190 template<typename VariateType, typename VariateTag>
 191 struct as_feature<tag::mean_of_variates<VariateType, VariateTag>(immediate)>
 192 {
 193     typedef tag::immediate_mean_of_variates<VariateType, VariateTag> type;
 194 };
 195
 196 // for the purposes of feature-based dependency resolution,
 197 // immediate_mean provides the same feature as mean
 198 template<>
 199 struct feature_of<tag::immediate_mean>
 200   : feature_of<tag::mean>
 201 {
 202 };
 203
 204 // for the purposes of feature-based dependency resolution,
 205 // immediate_mean provides the same feature as mean
 206 template<>
 207 struct feature_of<tag::immediate_mean_of_weights>
 208   : feature_of<tag::mean_of_weights>
 209 {
 210 };
 211
 212 // for the purposes of feature-based dependency resolution,
 213 // immediate_mean provides the same feature as mean
 214 template<typename VariateType, typename VariateTag>
 215 struct feature_of<tag::immediate_mean_of_variates<VariateType, VariateTag> >
 216   : feature_of<tag::mean_of_variates<VariateType, VariateTag> >
 217 {
 218 };
 219
 220 // So that mean can be automatically substituted with
 221 // weighted_mean when the weight parameter is non-void.
 222 template<>
 223 struct as_weighted_feature<tag::mean>
 224 {
 225     typedef tag::weighted_mean type;
 226 };
 227
 228 template<>
 229 struct feature_of<tag::weighted_mean>
 230   : feature_of<tag::mean>
 231 {};
 232
 233 // So that immediate_mean can be automatically substituted with
 234 // immediate_weighted_mean when the weight parameter is non-void.
 235 template<>
 236 struct as_weighted_feature<tag::immediate_mean>
 237 {
 238     typedef tag::immediate_weighted_mean type;
 239 };
 240
 241 template<>
 242 struct feature_of<tag::immediate_weighted_mean>
 243   : feature_of<tag::immediate_mean>
 244 {};
 245
 246 // So that mean_of_weights<> can be automatically substituted with
 247 // weighted_mean_of_variates<> when the weight parameter is non-void.
 248 template<typename VariateType, typename VariateTag>
 249 struct as_weighted_feature<tag::mean_of_variates<VariateType, VariateTag> >
 250 {
 251     typedef tag::weighted_mean_of_variates<VariateType, VariateTag> type;
 252 };
 253
 254 template<typename VariateType, typename VariateTag>
 255 struct feature_of<tag::weighted_mean_of_variates<VariateType, VariateTag> >
 256   : feature_of<tag::mean_of_variates<VariateType, VariateTag> >
 257 {
 258 };
 259
 260 // So that immediate_mean_of_weights<> can be automatically substituted with
 261 // immediate_weighted_mean_of_variates<> when the weight parameter is non-void.
 262 template<typename VariateType, typename VariateTag>
 263 struct as_weighted_feature<tag::immediate_mean_of_variates<VariateType, VariateTag> >
 264 {
 265     typedef tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> type;
 266 };
 267
 268 template<typename VariateType, typename VariateTag>
 269 struct feature_of<tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> >
 270   : feature_of<tag::immediate_mean_of_variates<VariateType, VariateTag> >
 271 {
 272 };
 273
 274 ////////////////////////////////////////////////////////////////////////////
 275 //// droppable_accumulator<mean_impl>
 276 ////  need to specialize droppable lazy mean to cache the result at the
 277 ////  point the accumulator is dropped.
 278 ///// INTERNAL ONLY
 279 /////
 280 //template<typename Sample, typename SumFeature>
 281 //struct droppable_accumulator<impl::mean_impl<Sample, SumFeature> >
 282 //  : droppable_accumulator_base<
 283 //        with_cached_result<impl::mean_impl<Sample, SumFeature> >
 284 //    >
 285 //{
 286 //    template<typename Args>
 287 //    droppable_accumulator(Args const &args)
 288 //      : droppable_accumulator::base(args)
 289 //    {
 290 //    }
 291 //};
 292
 293 }} // namespace boost::accumulators
 294
 295 #endif