Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.
PrevUpHomeNext

Reference

Accumulators Framework Reference
Statistics Library Reference
Numeric Operators Library Reference

Accumulators Framework Reference

Includes all of the Accumulators Framework


BOOST_ACCUMULATORS_MAX_FEATURES
BOOST_ACCUMULATORS_MAX_ARGS
BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(X)
BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias)
namespace boost {
  namespace accumulators {
    template<typename Feature, typename AccumulatorSet> 
      mpl::apply< AccumulatorSet, Feature >::type::result_type 
      extract_result(AccumulatorSet const & acc);
    template<typename Feature, typename AccumulatorSet, typename A1> 
      mpl::apply< AccumulatorSet, Feature >::type::result_type 
      extract_result(AccumulatorSet const & acc, A1 const & a1);
    namespace impl {
    }
    namespace tag {
    }
  }
}
namespace boost {
  namespace accumulators {
    struct dont_care;
    struct accumulator_base;
  }
}
namespace boost {
  namespace accumulators {
    template<typename Stat> struct accumulator_concept;
  }
}
namespace boost {
  namespace accumulators {
    template<typename Sample, typename Features, typename Weight> 
      struct accumulator_set;
    template<typename Feature, typename AccumulatorSet> 
      mpl::apply< AccumulatorSet, Feature >::type & 
      find_accumulator(AccumulatorSet &acc  BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST);
  }
}
namespace boost {
  namespace accumulators {
    template<typename Accumulator> struct droppable_accumulator_base;
    template<typename Accumulator> struct droppable_accumulator;
    template<typename Accumulator> struct with_cached_result;

    template<typename Feature> struct as_feature<tag::droppable< Feature >>;
    template<typename Feature> 
      struct as_weighted_feature<tag::droppable< Feature >>;
    template<typename Feature> struct feature_of<tag::droppable< Feature >>;
    namespace tag {
      template<typename Feature> struct as_droppable;

      template<typename Feature> struct as_droppable<droppable< Feature >>;

      template<typename Feature> struct droppable;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename Feature, typename Tag, typename AccumulatorSet> 
      struct feature_of<tag::external< Feature, Tag, AccumulatorSet >>;
    namespace impl {
    }
    namespace tag {
      template<typename Feature, typename Tag, typename AccumulatorSet> 
        struct external;

      template<typename Feature, typename Tag> 
        struct external<Feature, Tag, void>;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename ValueType, typename Tag> 
      struct feature_of<tag::reference< ValueType, Tag >>;
    namespace extract {
    }
    namespace impl {
      template<typename Referent, typename Tag> struct reference_accumulator_impl;
    }
    namespace tag {
      template<typename Tag> struct reference_tag;
      template<typename Referent, typename Tag> struct reference;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename ValueType, typename Tag> 
      struct feature_of<tag::value< ValueType, Tag >>;
    namespace extract {
    }
    namespace impl {
      template<typename ValueType, typename Tag> struct value_accumulator_impl;
    }
    namespace tag {
      template<typename Tag> struct value_tag;
      template<typename ValueType, typename Tag> struct value;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename Feature> struct as_feature;
    template<typename Feature> struct as_weighted_feature;
    template<typename Feature> struct feature_of;
    template<typename Feature1, typename Feature2, ... > struct depends_on;
  }
}

BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(Tag, Feature, ParamSeq)
namespace boost {
  namespace accumulators {
    template<typename Feature> struct extractor;
  }
}
namespace boost {
  namespace accumulators {
    template<typename Feature1, typename Feature2, ... > struct features;
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::accumulator > const accumulator;
    namespace tag {
      struct accumulator;
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::sample > const sample;
    namespace tag {
      struct sample;
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::weight > const weight;
    namespace tag {
      struct weight;
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::weights > const weights;
    namespace tag {
      struct weights;
    }
  }
}

Statistics Library Reference

Header <boost/accumulators/statistics.hpp>
Header <boost/accumulators/statistics/count.hpp>
Header <boost/accumulators/statistics/covariance.hpp>
Header <boost/accumulators/statistics/density.hpp>
Header <boost/accumulators/statistics/error_of.hpp>
Header <boost/accumulators/statistics/error_of_mean.hpp>
Header <boost/accumulators/statistics/extended_p_square.hpp>
Header <boost/accumulators/statistics/extended_p_square_quantile.hpp>
Header <boost/accumulators/statistics/kurtosis.hpp>
Header <boost/accumulators/statistics/max.hpp>
Header <boost/accumulators/statistics/mean.hpp>
Header <boost/accumulators/statistics/median.hpp>
Header <boost/accumulators/statistics/min.hpp>
Header <boost/accumulators/statistics/moment.hpp>
Header <boost/accumulators/statistics/p_square_cumulative_distribution.hpp>
Header <boost/accumulators/statistics/p_square_quantile.hpp>
Header <boost/accumulators/statistics/peaks_over_threshold.hpp>
Header <boost/accumulators/statistics/pot_quantile.hpp>
Header <boost/accumulators/statistics/pot_tail_mean.hpp>
Header <boost/accumulators/statistics/rolling_count.hpp>
Header <boost/accumulators/statistics/rolling_mean.hpp>
Header <boost/accumulators/statistics/rolling_sum.hpp>
Header <boost/accumulators/statistics/rolling_window.hpp>
Header <boost/accumulators/statistics/skewness.hpp>
Header <boost/accumulators/statistics/stats.hpp>
Header <boost/accumulators/statistics/sum.hpp>
Header <boost/accumulators/statistics/tail.hpp>
Header <boost/accumulators/statistics/tail_mean.hpp>
Header <boost/accumulators/statistics/tail_quantile.hpp>
Header <boost/accumulators/statistics/tail_variate.hpp>
Header <boost/accumulators/statistics/tail_variate_means.hpp>
Header <boost/accumulators/statistics/times2_iterator.hpp>
Header <boost/accumulators/statistics/variance.hpp>
Header <boost/accumulators/statistics/variates/covariate.hpp>
Header <boost/accumulators/statistics/weighted_covariance.hpp>
Header <boost/accumulators/statistics/weighted_density.hpp>
Header <boost/accumulators/statistics/weighted_extended_p_square.hpp>
Header <boost/accumulators/statistics/weighted_kurtosis.hpp>
Header <boost/accumulators/statistics/weighted_mean.hpp>
Header <boost/accumulators/statistics/weighted_median.hpp>
Header <boost/accumulators/statistics/weighted_moment.hpp>
Header <boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp>
Header <boost/accumulators/statistics/weighted_p_square_quantile.hpp>
Header <boost/accumulators/statistics/weighted_peaks_over_threshold.hpp>
Header <boost/accumulators/statistics/weighted_skewness.hpp>
Header <boost/accumulators/statistics/weighted_sum.hpp>
Header <boost/accumulators/statistics/weighted_tail_mean.hpp>
Header <boost/accumulators/statistics/weighted_tail_quantile.hpp>
Header <boost/accumulators/statistics/weighted_tail_variate_means.hpp>
Header <boost/accumulators/statistics/weighted_variance.hpp>
Header <boost/accumulators/statistics/with_error.hpp>
Header <boost/accumulators/statistics_fwd.hpp>

Includes all of the Statistical Accumulators Library

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::count > const count;
    }
    namespace impl {
      struct count_impl;
    }
    namespace tag {
      struct count;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::covariance< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::covariance< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::weighted_covariance< VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::abstract_covariance > const covariance;
    }
    namespace impl {
      template<typename Sample, typename VariateType, typename VariateTag> 
        struct covariance_impl;
    }
    namespace tag {
      template<typename VariateType, typename VariateTag> struct covariance;
      struct abstract_covariance;
    }
  }
  namespace numeric {
    namespace functional {
      template<typename Left, typename Right, typename EnableIf = void> 
        struct outer_product_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct outer_product;

      template<typename Left, typename Right> 
        struct outer_product<Left, Right, std_vector_tag, std_vector_tag>;
    }
    namespace op {
      struct outer_product;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::density>;
    template<> struct feature_of<tag::weighted_density>;
    namespace extract {
      extractor< tag::density > const density;
    }
    namespace impl {
      template<typename Sample> struct density_impl;
    }
    namespace tag {
      struct density;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename Feature> struct as_feature<tag::error_of< Feature >>;
    template<typename Feature> 
      struct as_weighted_feature<tag::error_of< Feature >>;
    namespace extract {
    }
    namespace impl {
    }
    namespace tag {
      template<typename Feature> struct error_of;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace impl {
      template<typename Sample, typename Variance> struct error_of_mean_impl;
    }
    namespace tag {
      template<> struct error_of<mean>;
      template<> struct error_of<immediate_mean>;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::extended_p_square>;
    template<> struct feature_of<tag::weighted_extended_p_square>;
    namespace extract {
      extractor< tag::extended_p_square > const extended_p_square;
    }
    namespace impl {
      template<typename Sample> struct extended_p_square_impl;
    }
    namespace tag {
      struct extended_p_square;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::extended_p_square_quantile(linear)>;
    template<> struct as_feature<tag::extended_p_square_quantile(quadratic)>;
    template<> 
      struct as_feature<tag::weighted_extended_p_square_quantile(linear)>;
    template<> 
      struct as_feature<tag::weighted_extended_p_square_quantile(quadratic)>;
    template<> struct feature_of<tag::extended_p_square_quantile>;
    template<> struct feature_of<tag::extended_p_square_quantile_quadratic>;
    template<> struct as_weighted_feature<tag::extended_p_square_quantile>;
    template<> struct feature_of<tag::weighted_extended_p_square_quantile>;
    template<> 
      struct as_weighted_feature<tag::extended_p_square_quantile_quadratic>;
    template<> 
      struct feature_of<tag::weighted_extended_p_square_quantile_quadratic>;
    namespace extract {
      extractor< tag::extended_p_square_quantile > const extended_p_square_quantile;
      extractor< tag::extended_p_square_quantile_quadratic > const extended_p_square_quantile_quadratic;
      extractor< tag::weighted_extended_p_square_quantile > const weighted_extended_p_square_quantile;
      extractor< tag::weighted_extended_p_square_quantile_quadratic > const weighted_extended_p_square_quantile_quadratic;
    }
    namespace impl {
      template<typename Sample, typename Impl1, typename Impl2> 
        struct extended_p_square_quantile_impl;
    }
    namespace tag {
      struct extended_p_square_quantile;
      struct extended_p_square_quantile_quadratic;
      struct weighted_extended_p_square_quantile;
      struct weighted_extended_p_square_quantile_quadratic;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::kurtosis>;
    template<> struct feature_of<tag::weighted_kurtosis>;
    namespace extract {
      extractor< tag::kurtosis > const kurtosis;
    }
    namespace impl {
      template<typename Sample> struct kurtosis_impl;
    }
    namespace tag {
      struct kurtosis;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::max > const max;
    }
    namespace impl {
      template<typename Sample> struct max_impl;
    }
    namespace tag {
      struct max;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::mean(lazy)>;
    template<> struct as_feature<tag::mean(immediate)>;
    template<> struct as_feature<tag::mean_of_weights(lazy)>;
    template<> struct as_feature<tag::mean_of_weights(immediate)>;
    template<typename VariateType, typename VariateTag> 
      struct as_feature<tag::mean_of_variates< VariateType, VariateTag >(lazy)>;
    template<typename VariateType, typename VariateTag> 
      struct as_feature<tag::mean_of_variates< VariateType, VariateTag >(immediate)>;
    template<> struct feature_of<tag::immediate_mean>;
    template<> struct feature_of<tag::immediate_mean_of_weights>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::immediate_mean_of_variates< VariateType, VariateTag >>;
    template<> struct as_weighted_feature<tag::mean>;
    template<> struct feature_of<tag::weighted_mean>;
    template<> struct as_weighted_feature<tag::immediate_mean>;
    template<> struct feature_of<tag::immediate_weighted_mean>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::mean_of_variates< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::weighted_mean_of_variates< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::immediate_mean_of_variates< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::immediate_weighted_mean_of_variates< VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::mean > const mean;
      extractor< tag::mean_of_weights > const mean_of_weights;
    }
    namespace impl {
      template<typename Sample, typename SumFeature> struct mean_impl;
      template<typename Sample, typename Tag> struct immediate_mean_impl;
    }
    namespace tag {
      struct mean;
      struct immediate_mean;
      struct mean_of_weights;
      struct immediate_mean_of_weights;
      template<typename VariateType, typename VariateTag> struct mean_of_variates;
      template<typename VariateType, typename VariateTag> 
        struct immediate_mean_of_variates;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::median(with_p_square_quantile)>;
    template<> struct as_feature<tag::median(with_density)>;
    template<> 
      struct as_feature<tag::median(with_p_square_cumulative_distribution)>;
    template<> struct feature_of<tag::with_density_median>;
    template<> 
      struct feature_of<tag::with_p_square_cumulative_distribution_median>;
    template<> struct as_weighted_feature<tag::median>;
    template<> struct feature_of<tag::weighted_median>;
    template<> struct as_weighted_feature<tag::with_density_median>;
    template<> struct feature_of<tag::with_density_weighted_median>;
    template<> 
      struct as_weighted_feature<tag::with_p_square_cumulative_distribution_median>;
    template<> 
      struct feature_of<tag::with_p_square_cumulative_distribution_weighted_median>;
    namespace extract {
      extractor< tag::median > const median;
      extractor< tag::with_density_median > const with_density_median;
      extractor< tag::with_p_square_cumulative_distribution_median > const with_p_square_cumulative_distribution_median;
    }
    namespace impl {
      template<typename Sample> struct median_impl;
      template<typename Sample> struct with_density_median_impl;
      template<typename Sample> 
        struct with_p_square_cumulative_distribution_median_impl;
    }
    namespace tag {
      struct median;
      struct with_density_median;
      struct with_p_square_cumulative_distribution_median;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::min > const min;
    }
    namespace impl {
      template<typename Sample> struct min_impl;
    }
    namespace tag {
      struct min;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<int N> struct as_weighted_feature<tag::moment< N >>;
    template<int N> struct feature_of<tag::weighted_moment< N >>;
    namespace extract {
    }
    namespace impl {
      template<typename N, typename Sample> struct moment_impl;
    }
    namespace tag {
      template<int N> struct moment;
    }
  }
  namespace numeric {
  }
}
namespace boost {
  namespace accumulators {
    template<> 
      struct as_weighted_feature<tag::p_square_cumulative_distribution>;
    template<> 
      struct feature_of<tag::weighted_p_square_cumulative_distribution>;
    namespace extract {
      extractor< tag::p_square_cumulative_distribution > const p_square_cumulative_distribution;
    }
    namespace impl {
      template<typename Sample> struct p_square_cumulative_distribution_impl;
    }
    namespace tag {
      struct p_square_cumulative_distribution;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::p_square_quantile>;
    template<> struct feature_of<tag::weighted_p_square_quantile>;
    namespace extract {
      extractor< tag::p_square_quantile > const p_square_quantile;
      extractor< tag::p_square_quantile_for_median > const p_square_quantile_for_median;
    }
    namespace impl {
      template<typename Sample, typename Impl> struct p_square_quantile_impl;
    }
    namespace tag {
      struct p_square_quantile;
      struct p_square_quantile_for_median;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct as_feature<tag::peaks_over_threshold< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::peaks_over_threshold< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct feature_of<tag::peaks_over_threshold< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::peaks_over_threshold_prob< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::peaks_over_threshold< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_peaks_over_threshold< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::peaks_over_threshold_prob< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_peaks_over_threshold_prob< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_peaks_over_threshold > const peaks_over_threshold;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> 
        struct peaks_over_threshold_impl;
      template<typename Sample, typename LeftRight> 
        struct peaks_over_threshold_prob_impl;
    }
    namespace tag {
      template<typename LeftRight> struct peaks_over_threshold;
      template<typename LeftRight> struct peaks_over_threshold_prob;
      struct abstract_peaks_over_threshold;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct as_feature<tag::pot_quantile< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::pot_quantile< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_quantile< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_quantile< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_quantile_prob< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_quantile_prob< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_quantile_prob< LeftRight >>;
    namespace impl {
      template<typename Sample, typename Impl, typename LeftRight> 
        struct pot_quantile_impl;
    }
    namespace tag {
      template<typename LeftRight> struct pot_quantile;
      template<typename LeftRight> struct pot_quantile_prob;
      template<typename LeftRight> struct weighted_pot_quantile;
      template<typename LeftRight> struct weighted_pot_quantile_prob;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct as_feature<tag::pot_tail_mean< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::pot_tail_mean< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_tail_mean< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_tail_mean< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_tail_mean_prob< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_tail_mean_prob< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_tail_mean_prob< LeftRight >>;
    namespace impl {
      template<typename Sample, typename Impl, typename LeftRight> 
        struct pot_tail_mean_impl;
    }
    namespace tag {
      template<typename LeftRight> struct pot_tail_mean;
      template<typename LeftRight> struct pot_tail_mean_prob;
      template<typename LeftRight> struct weighted_pot_tail_mean;
      template<typename LeftRight> struct weighted_pot_tail_mean_prob;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::rolling_count > const rolling_count;
    }
    namespace impl {
      template<typename Sample> struct rolling_count_impl;
    }
    namespace tag {
      struct rolling_count;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::rolling_mean > const rolling_mean;
    }
    namespace impl {
      template<typename Sample> struct rolling_mean_impl;
    }
    namespace tag {
      struct rolling_mean;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::rolling_sum > const rolling_sum;
    }
    namespace impl {
      template<typename Sample> struct rolling_sum_impl;
    }
    namespace tag {
      struct rolling_sum;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::rolling_window_plus1 > const rolling_window_plus1;
      extractor< tag::rolling_window > const rolling_window;
    }
    namespace impl {
      template<typename Sample> struct rolling_window_plus1_impl;
      template<typename Sample> struct rolling_window_impl;
      template<typename Args> 
        bool is_rolling_window_plus1_full(Args const & args);
    }
    namespace tag {
      struct rolling_window_plus1;
      struct rolling_window;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::skewness>;
    template<> struct feature_of<tag::weighted_skewness>;
    namespace extract {
      extractor< tag::skewness > const skewness;
    }
    namespace impl {
      template<typename Sample> struct skewness_impl;
    }
    namespace tag {
      struct skewness;
    }
  }
}

Contains the stats<> template.

namespace boost {
  namespace accumulators {
    template<typename Stat1, typename Stat2, ... > struct stats;
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::sum>;
    template<> struct feature_of<tag::weighted_sum>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::sum_of_variates< VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::sum > const sum;
      extractor< tag::sum_of_weights > const sum_of_weights;
      extractor< tag::abstract_sum_of_variates > const sum_of_variates;
    }
    namespace impl {
      template<typename Sample, typename Tag> struct sum_impl;
    }
    namespace tag {
      struct sum;
      struct sum_of_weights;
      template<typename VariateType, typename VariateTag> struct sum_of_variates;
      struct abstract_sum_of_variates;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename T> struct tail_cache_size_named_arg;

    template<> struct tail_cache_size_named_arg<left>;
    template<> struct tail_cache_size_named_arg<right>;
    template<typename LeftRight> struct feature_of<tag::tail< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_tail > const tail;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> struct tail_impl;
    }
    namespace tag {
      template<typename LeftRight> struct tail;
      struct abstract_tail;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct feature_of<tag::coherent_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::non_coherent_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::non_coherent_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::non_coherent_weighted_tail_mean< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_non_coherent_tail_mean > const non_coherent_tail_mean;
      extractor< tag::tail_mean > const coherent_tail_mean;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> 
        struct coherent_tail_mean_impl;
      template<typename Sample, typename LeftRight> 
        struct non_coherent_tail_mean_impl;
    }
    namespace tag {
      template<typename LeftRight> struct coherent_tail_mean;
      template<typename LeftRight> struct non_coherent_tail_mean;
      struct abstract_non_coherent_tail_mean;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct feature_of<tag::tail_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::tail_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_tail_quantile< LeftRight >>;
    namespace extract {
      extractor< tag::quantile > const tail_quantile;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> struct tail_quantile_impl;
    }
    namespace tag {
      template<typename LeftRight> struct tail_quantile;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename VariateType, typename VariateTag, typename LeftRight> 
      struct feature_of<tag::tail_variate< VariateType, VariateTag, LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::tail_weights< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_tail_variate > const tail_variate;
      extractor< tag::abstract_tail_weights > const tail_weights;
    }
    namespace impl {
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct tail_variate_impl;
    }
    namespace tag {
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct tail_variate;
      struct abstract_tail_variate;
      template<typename LeftRight> struct tail_weights;
      struct abstract_tail_weights;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<tag::tail_variate_means< LeftRight, VariateType, VariateTag >(absolute)>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<tag::tail_variate_means< LeftRight, VariateType, VariateTag >(relative)>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::absolute_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::relative_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::absolute_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::absolute_weighted_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::relative_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::relative_weighted_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::abstract_absolute_tail_variate_means > const tail_variate_means;
      extractor< tag::abstract_relative_tail_variate_means > const relative_tail_variate_means;
    }
    namespace impl {
      template<typename Sample, typename Impl, typename LeftRight, 
               typename VariateTag> 
        struct tail_variate_means_impl;
    }
    namespace tag {
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct absolute_tail_variate_means;
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct relative_tail_variate_means;
      struct abstract_absolute_tail_variate_means;
      struct abstract_relative_tail_variate_means;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::variance(lazy)>;
    template<> struct as_feature<tag::variance(immediate)>;
    template<> struct feature_of<tag::lazy_variance>;
    template<> struct as_weighted_feature<tag::variance>;
    template<> struct feature_of<tag::weighted_variance>;
    template<> struct as_weighted_feature<tag::lazy_variance>;
    template<> struct feature_of<tag::lazy_weighted_variance>;
    namespace extract {
      extractor< tag::lazy_variance > const lazy_variance;
      extractor< tag::variance > const variance;
    }
    namespace impl {
      template<typename Sample, typename MeanFeature> struct lazy_variance_impl;
      template<typename Sample, typename MeanFeature, typename Tag> 
        struct variance_impl;
    }
    namespace tag {
      struct lazy_variance;
      struct variance;
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::covariate1 > const covariate1;
    boost::parameter::keyword< tag::covariate2 > const covariate2;
    namespace tag {
      struct covariate1;
      struct covariate2;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::abstract_covariance > const weighted_covariance;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename VariateType, 
               typename VariateTag> 
        struct weighted_covariance_impl;
    }
    namespace tag {
      template<typename VariateType, typename VariateTag> 
        struct weighted_covariance;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::density > const weighted_density;
    }
    namespace impl {
      template<typename Sample, typename Weight> struct weighted_density_impl;
    }
    namespace tag {
      struct weighted_density;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::weighted_extended_p_square > const weighted_extended_p_square;
    }
    namespace impl {
      template<typename Sample, typename Weight> 
        struct weighted_extended_p_square_impl;
    }
    namespace tag {
      struct weighted_extended_p_square;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::weighted_kurtosis > const weighted_kurtosis;
    }
    namespace impl {
      template<typename Sample, typename Weight> struct weighted_kurtosis_impl;
    }
    namespace tag {
      struct weighted_kurtosis;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::weighted_mean(lazy)>;
    template<> struct as_feature<tag::weighted_mean(immediate)>;
    template<typename VariateType, typename VariateTag> 
      struct as_feature<tag::weighted_mean_of_variates< VariateType, VariateTag >(lazy)>;
    template<typename VariateType, typename VariateTag> 
      struct as_feature<tag::weighted_mean_of_variates< VariateType, VariateTag >(immediate)>;
    namespace extract {
      extractor< tag::mean > const weighted_mean;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename Tag> 
        struct weighted_mean_impl;
      template<typename Sample, typename Weight, typename Tag> 
        struct immediate_weighted_mean_impl;
    }
    namespace tag {
      struct weighted_mean;
      struct immediate_weighted_mean;
      template<typename VariateType, typename VariateTag> 
        struct weighted_mean_of_variates;
      template<typename VariateType, typename VariateTag> 
        struct immediate_weighted_mean_of_variates;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::weighted_median(with_p_square_quantile)>;
    template<> struct as_feature<tag::weighted_median(with_density)>;
    template<> 
      struct as_feature<tag::weighted_median(with_p_square_cumulative_distribution)>;
    namespace extract {
      extractor< tag::median > const weighted_median;
    }
    namespace impl {
      template<typename Sample> struct weighted_median_impl;
      template<typename Sample> struct with_density_weighted_median_impl;
      template<typename Sample, typename Weight> 
        struct with_p_square_cumulative_distribution_weighted_median_impl;
    }
    namespace tag {
      struct weighted_median;
      struct with_density_weighted_median;
      struct with_p_square_cumulative_distribution_weighted_median;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
    }
    namespace impl {
      template<typename N, typename Sample, typename Weight> 
        struct weighted_moment_impl;
    }
    namespace tag {
      template<int N> struct weighted_moment;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::weighted_p_square_cumulative_distribution > const weighted_p_square_cumulative_distribution;
    }
    namespace impl {
      template<typename Sample, typename Weight> 
        struct weighted_p_square_cumulative_distribution_impl;
    }
    namespace tag {
      struct weighted_p_square_cumulative_distribution;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::weighted_p_square_quantile > const weighted_p_square_quantile;
      extractor< tag::weighted_p_square_quantile_for_median > const weighted_p_square_quantile_for_median;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename Impl> 
        struct weighted_p_square_quantile_impl;
    }
    namespace tag {
      struct weighted_p_square_quantile;
      struct weighted_p_square_quantile_for_median;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct as_feature<tag::weighted_peaks_over_threshold< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_peaks_over_threshold< LeftRight >(with_threshold_probability)>;
    namespace extract {
      extractor< tag::abstract_peaks_over_threshold > const weighted_peaks_over_threshold;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename LeftRight> 
        struct weighted_peaks_over_threshold_impl;
      template<typename Sample, typename Weight, typename LeftRight> 
        struct weighted_peaks_over_threshold_prob_impl;
    }
    namespace tag {
      template<typename LeftRight> struct weighted_peaks_over_threshold;
      template<typename LeftRight> struct weighted_peaks_over_threshold_prob;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::weighted_skewness > const weighted_skewness;
    }
    namespace impl {
      template<typename Sample, typename Weight> struct weighted_skewness_impl;
    }
    namespace tag {
      struct weighted_skewness;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::weighted_sum_of_variates< VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::weighted_sum > const weighted_sum;
      extractor< tag::abstract_weighted_sum_of_variates > const weighted_sum_of_variates;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename Tag> 
        struct weighted_sum_impl;
    }
    namespace tag {
      struct weighted_sum;
      template<typename VariateType, typename VariateTag> 
        struct weighted_sum_of_variates;
      struct abstract_weighted_sum_of_variates;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::abstract_non_coherent_tail_mean > const non_coherent_weighted_tail_mean;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename LeftRight> 
        struct non_coherent_weighted_tail_mean_impl;
    }
    namespace tag {
      template<typename LeftRight> struct non_coherent_weighted_tail_mean;
    }
  }
}
namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::quantile > const weighted_tail_quantile;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename LeftRight> 
        struct weighted_tail_quantile_impl;
    }
    namespace tag {
      template<typename LeftRight> struct weighted_tail_quantile;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<tag::weighted_tail_variate_means< LeftRight, VariateType, VariateTag >(absolute)>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<tag::weighted_tail_variate_means< LeftRight, VariateType, VariateTag >(relative)>;
    namespace extract {
      extractor< tag::abstract_absolute_tail_variate_means > const weighted_tail_variate_means;
      extractor< tag::abstract_relative_tail_variate_means > const relative_weighted_tail_variate_means;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename Impl, 
               typename LeftRight, typename VariateType> 
        struct weighted_tail_variate_means_impl;
    }
    namespace tag {
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct absolute_weighted_tail_variate_means;
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct relative_weighted_tail_variate_means;
    }
  }
  namespace numeric {
    namespace functional {
      template<typename T, typename U> struct multiply_and_promote_to_double;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::weighted_variance(lazy)>;
    template<> struct as_feature<tag::weighted_variance(immediate)>;
    namespace extract {
      extractor< tag::lazy_weighted_variance > const lazy_weighted_variance;
      extractor< tag::weighted_variance > const weighted_variance;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename MeanFeature> 
        struct lazy_weighted_variance_impl;
      template<typename Sample, typename Weight, typename MeanFeature, 
               typename Tag> 
        struct weighted_variance_impl;
    }
    namespace tag {
      struct lazy_weighted_variance;
      struct weighted_variance;
    }
  }
}
namespace boost {
  namespace accumulators {
    template<typename Feature1, typename Feature2, ... > struct with_error;
  }
}
namespace boost {
  namespace accumulators {
    struct lazy;
    struct immediate;
    struct right;
    struct left;
    struct absolute;
    struct relative;
    struct with_density;
    struct with_p_square_cumulative_distribution;
    struct with_p_square_quantile;
    struct with_threshold_value;
    struct with_threshold_probability;
    struct weighted;
    struct unweighted;
    struct linear;
    struct quadratic;
    struct regular;
    struct for_median;
    namespace extract {
      extractor< tag::quantile > const quantile;
      extractor< tag::tail_mean > const tail_mean;
    }
    namespace impl {
    }
    namespace tag {
      struct quantile;
      struct tail_mean;
    }
  }
}

Numeric Operators Library Reference

namespace boost {
  namespace numeric {
     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus, +, 
                                               BOOST_NUMERIC_FUNCTIONAL_DEDUCED);
    BOOST_NUMERIC_FUNCTIONAL_DEDUCED 
    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies, *, 
                                              BOOST_NUMERIC_FUNCTIONAL_DEDUCED);
    BOOST_NUMERIC_FUNCTIONAL_DEDUCED BOOST_NUMERIC_FUNCTIONAL_DEDUCED 
    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus, %, 
                                              BOOST_NUMERIC_FUNCTIONAL_DEDUCED);
    BOOST_NUMERIC_FUNCTIONAL_DEDUCED BOOST_NUMERIC_FUNCTIONAL_DEDUCED BOOST_NUMERIC_FUNCTIONAL_DEDUCED 
    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater_equal,  >=, 
                                              BOOST_NUMERIC_FUNCTIONAL_DEDUCED);
    namespace functional {
      template<typename Left, typename Right> struct left_ref;
    }
  }
}
namespace boost {
  namespace numeric {
    namespace operators {
      template<typename T, typename U> 
        disable_if< mpl::or_< is_same< T, U >, is_same< std::complex< T >, U > >, std::complex< T > >::type 
        operator*(std::complex< T > ri, U const & u);
      template<typename T, typename U> 
        disable_if< mpl::or_< is_same< T, U >, is_same< std::complex< T >, U > >, std::complex< T > >::type 
        operator/(std::complex< T > ri, U const & u);
    }
  }
}
namespace boost {
  namespace numeric {
    namespace functional {
      template<typename T> struct tag<std::valarray< T >>;
      template<typename Left, typename Right> 
        struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>;
      template<typename Left, typename Right> 
        struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>;
      template<typename Left, typename Right, typename RightTag> 
        struct average<Left, Right, std_valarray_tag, RightTag>;
      template<typename To, typename From> 
        struct promote<To, From, std_valarray_tag, std_valarray_tag>;
      template<typename ToFrom> 
        struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>;
      template<typename From> struct promote<bool, From, void, std_valarray_tag>;
      template<typename From> 
        struct promote<bool const, From, void, std_valarray_tag>;
      template<typename T> struct as_min<T, std_valarray_tag>;
      template<typename T> struct as_max<T, std_valarray_tag>;
      template<typename T> struct as_zero<T, std_valarray_tag>;
      template<typename T> struct as_one<T, std_valarray_tag>;
    }
    namespace operators {
      template<typename Left, typename Right> 
        enable_if< mpl::and_< is_scalar< Right >, mpl::not_< is_same< Left, Right > > >, std::valarray< typename functional::divides< Left, Right >::result_type > >::type 
        operator/(std::valarray< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        enable_if< mpl::and_< is_scalar< Right >, mpl::not_< is_same< Left, Right > > >, std::valarray< typename functional::multiplies< Left, Right >::result_type > >::type 
        operator*(std::valarray< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        disable_if< is_same< Left, Right >, std::valarray< typename functional::plus< Left, Right >::result_type > >::type 
        operator+(std::valarray< Left > const & left, 
                  std::valarray< Right > const & right);
    }
  }
}
namespace boost {
  namespace numeric {
    namespace functional {
      template<typename T, typename Al> struct tag<std::vector< T, Al >>;
      template<typename Left, typename Right> 
        struct min_assign<Left, Right, std_vector_tag, std_vector_tag>;
      template<typename Left, typename Right> 
        struct max_assign<Left, Right, std_vector_tag, std_vector_tag>;
      template<typename Left, typename Right> 
        struct average<Left, Right, std_vector_tag, void>;
      template<typename To, typename From> 
        struct promote<To, From, std_vector_tag, std_vector_tag>;
      template<typename ToFrom> 
        struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>;
      template<typename T> struct as_min<T, std_vector_tag>;
      template<typename T> struct as_max<T, std_vector_tag>;
      template<typename T> struct as_zero<T, std_vector_tag>;
      template<typename T> struct as_one<T, std_vector_tag>;
    }
    namespace operators {
      template<typename Left, typename Right> 
        enable_if< is_scalar< Right >, std::vector< typename functional::divides< Left, Right >::result_type > >::type 
        operator/(std::vector< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::divides< Left, Right >::result_type > 
        operator/(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left, typename Right> 
        enable_if< is_scalar< Right >, std::vector< typename functional::multiplies< Left, Right >::result_type > >::type 
        operator*(std::vector< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        enable_if< is_scalar< Left >, std::vector< typename functional::multiplies< Left, Right >::result_type > >::type 
        operator*(Left const & left, std::vector< Right > const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::multiplies< Left, Right >::result_type > 
        operator*(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::plus< Left, Right >::result_type > 
        operator+(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::minus< Left, Right >::result_type > 
        operator-(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left> 
        std::vector< Left > & 
        operator+=(std::vector< Left > & left, 
                   std::vector< Left > const & right);
      template<typename Arg> 
        std::vector< typename functional::unary_minus< Arg >::result_type > 
        operator-(std::vector< Arg > const & arg);
    }
  }
}

PrevUpHomeNext