Home | Libraries | People | FAQ | More |
Includes all of the Accumulators Framework
BOOST_ACCUMULATORS_MAX_FEATURES BOOST_ACCUMULATORS_MAX_ARGS BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T) BOOST_ACCUMULATORS_GCC_VERSION BOOST_ACCUMULATORS_IGNORE_GLOBAL(X)
namespace boost { namespace accumulators { struct accumulator_base; struct dont_care; } }
namespace boost { namespace accumulators { template<typename Stat> struct accumulator_concept; } }
namespace boost { namespace accumulators { template<typename Sample, typename Features, typename Weight> struct accumulator_set; // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. template<typename Feature, typename AccumulatorSet> mpl::apply< AccumulatorSet, Feature >::type const & find_accumulator(AccumulatorSet const & acc); template<typename Feature, typename AccumulatorSet> mpl::apply< AccumulatorSet, Feature >::type::result_type extract_result(AccumulatorSet const & acc); 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 Feature> struct as_feature<tag::droppable< Feature >>; template<typename Feature> struct as_weighted_feature<tag::droppable< Feature >>; template<typename Accumulator> struct droppable_accumulator; template<typename Accumulator> struct droppable_accumulator_base; template<typename Feature> struct feature_of<tag::droppable< Feature >>; template<typename Accumulator> struct with_cached_result; 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 Referent, typename Tag> struct reference; template<typename Tag> struct reference_tag; } } }
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 ValueType, typename Tag> struct value; template<typename Tag> struct value_tag; } } }
namespace boost { namespace accumulators { template<typename Feature> struct as_feature; template<typename Feature> struct as_weighted_feature; template<typename Feature1, typename Feature2, ... > struct depends_on; template<typename Feature> struct feature_of; } }
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; } }
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 as_weighted_feature<tag::covariance< VariateType, VariateTag >>; template<typename VariateType, typename VariateTag> struct feature_of<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 { struct abstract_covariance; template<typename VariateType, typename VariateTag> struct covariance; } } namespace numeric { namespace functional { 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>; template<typename Left, typename Right, typename EnableIf = void> struct outer_product_base; } 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<immediate_mean>; template<> struct error_of<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 as_weighted_feature<tag::extended_p_square_quantile>; template<> struct as_weighted_feature<tag::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 feature_of<tag::weighted_extended_p_square_quantile>; 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(immediate)>; template<> struct as_feature<tag::mean(lazy)>; template<typename VariateType, typename VariateTag> struct as_feature<tag::mean_of_variates< VariateType, VariateTag >(immediate)>; template<typename VariateType, typename VariateTag> struct as_feature<tag::mean_of_variates< VariateType, VariateTag >(lazy)>; template<> struct as_feature<tag::mean_of_weights(immediate)>; template<> struct as_feature<tag::mean_of_weights(lazy)>; template<> struct as_weighted_feature<tag::immediate_mean>; template<typename VariateType, typename VariateTag> struct as_weighted_feature<tag::immediate_mean_of_variates< VariateType, VariateTag >>; template<> struct as_weighted_feature<tag::mean>; template<typename VariateType, typename VariateTag> struct as_weighted_feature<tag::mean_of_variates< VariateType, VariateTag >>; template<> struct feature_of<tag::immediate_mean>; template<typename VariateType, typename VariateTag> struct feature_of<tag::immediate_mean_of_variates< VariateType, VariateTag >>; template<> struct feature_of<tag::immediate_mean_of_weights>; template<> struct feature_of<tag::immediate_weighted_mean>; template<typename VariateType, typename VariateTag> struct feature_of<tag::immediate_weighted_mean_of_variates< VariateType, VariateTag >>; template<> struct feature_of<tag::weighted_mean>; template<typename VariateType, typename VariateTag> struct feature_of<tag::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 Tag> struct immediate_mean_impl; template<typename Sample, typename SumFeature> struct mean_impl; } namespace tag { struct immediate_mean; template<typename VariateType, typename VariateTag> struct immediate_mean_of_variates; struct immediate_mean_of_weights; struct mean; template<typename VariateType, typename VariateTag> struct mean_of_variates; struct mean_of_weights; } } }
namespace boost { namespace accumulators { template<> struct as_feature<tag::median(with_density)>; template<> struct as_feature<tag::median(with_p_square_cumulative_distribution)>; template<> struct as_feature<tag::median(with_p_square_quantile)>; template<> struct as_weighted_feature<tag::median>; template<> struct as_weighted_feature<tag::with_density_median>; template<> struct as_weighted_feature<tag::with_p_square_cumulative_distribution_median>; template<> struct feature_of<tag::weighted_median>; template<> struct feature_of<tag::with_density_median>; template<> struct feature_of<tag::with_density_weighted_median>; template<> struct feature_of<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_probability)>; template<typename LeftRight> struct as_feature<tag::peaks_over_threshold< LeftRight >(with_threshold_value)>; template<typename LeftRight> struct as_weighted_feature<tag::peaks_over_threshold< LeftRight >>; template<typename LeftRight> struct as_weighted_feature<tag::peaks_over_threshold_prob< LeftRight >>; 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 feature_of<tag::weighted_peaks_over_threshold< 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 { struct abstract_peaks_over_threshold; template<typename LeftRight> struct peaks_over_threshold; template<typename LeftRight> struct peaks_over_threshold_prob; } } }
namespace boost { namespace accumulators { template<typename LeftRight> struct as_feature<tag::pot_quantile< LeftRight >(with_threshold_probability)>; template<typename LeftRight> struct as_feature<tag::pot_quantile< LeftRight >(with_threshold_value)>; template<typename LeftRight> struct as_feature<tag::weighted_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_weighted_feature<tag::pot_quantile< LeftRight >>; template<typename LeftRight> struct as_weighted_feature<tag::pot_quantile_prob< LeftRight >>; 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 feature_of<tag::weighted_pot_quantile< 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_probability)>; template<typename LeftRight> struct as_feature<tag::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 as_feature<tag::weighted_pot_tail_mean< LeftRight >(with_threshold_value)>; template<typename LeftRight> struct as_weighted_feature<tag::pot_tail_mean< LeftRight >>; template<typename LeftRight> struct as_weighted_feature<tag::pot_tail_mean_prob< LeftRight >>; 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 feature_of<tag::weighted_pot_tail_mean< 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 { template<> struct as_feature<tag::rolling_mean(immediate)>; template<> struct as_feature<tag::rolling_mean(lazy)>; template<> struct feature_of<tag::immediate_rolling_mean>; template<> struct feature_of<tag::lazy_rolling_mean>; namespace extract { extractor< tag::lazy_rolling_mean > const lazy_rolling_mean; extractor< tag::immediate_rolling_mean > const immediate_rolling_mean; extractor< tag::rolling_mean > const rolling_mean; } namespace impl { template<typename Sample> struct immediate_rolling_mean_impl; template<typename Sample> struct lazy_rolling_mean_impl; } namespace tag { struct immediate_rolling_mean; struct lazy_rolling_mean; struct rolling_mean; } } }
namespace boost { namespace accumulators { namespace extract { } namespace impl { template<typename N, typename Sample> struct rolling_moment_impl; } namespace tag { template<int N> struct rolling_moment; } } }
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 { template<> struct as_feature<tag::rolling_variance(immediate)>; template<> struct as_feature<tag::rolling_variance(lazy)>; template<> struct feature_of<tag::immediate_rolling_variance>; template<> struct feature_of<tag::lazy_rolling_variance>; namespace extract { extractor< tag::lazy_rolling_variance > const lazy_rolling_variance; extractor< tag::immediate_rolling_variance > const immediate_rolling_variance; extractor< tag::rolling_variance > const rolling_variance; } namespace impl { template<typename Sample> struct immediate_rolling_variance_impl; template<typename Sample> struct lazy_rolling_variance_impl; } namespace tag { struct immediate_rolling_variance; struct lazy_rolling_variance; struct rolling_variance; } } }
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_impl; template<typename Sample> struct rolling_window_plus1_impl; template<typename Args> bool is_rolling_window_plus1_full(Args const & args); } namespace tag { struct rolling_window; struct rolling_window_plus1; } } namespace serialization { template<typename Archive, typename T> void save(Archive & ar, const circular_buffer< T > & b, const unsigned int); template<typename Archive, typename T> void load(Archive & ar, circular_buffer< T > & b, const unsigned int); template<typename Archive, typename T> void serialize(Archive & ar, circular_buffer< T > & b, const unsigned int version); } }
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<typename VariateType, typename VariateTag> struct feature_of<tag::sum_of_variates< VariateType, VariateTag >>; template<> struct feature_of<tag::weighted_sum>; 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 abstract_sum_of_variates; struct sum; template<typename VariateType, typename VariateTag> struct sum_of_variates; struct sum_of_weights; } } }
namespace boost { namespace accumulators { template<> struct as_feature<tag::sum(kahan)>; template<> struct as_feature<tag::sum_of_weights(kahan)>; template<> struct as_weighted_feature<tag::sum_kahan>; template<> struct feature_of<tag::sum_kahan>; template<typename VariateType, typename VariateTag> struct feature_of<tag::sum_of_variates_kahan< VariateType, VariateTag >>; template<> struct feature_of<tag::sum_of_weights_kahan>; template<> struct feature_of<tag::weighted_sum_kahan>; namespace extract { extractor< tag::sum_kahan > const sum_kahan; extractor< tag::sum_of_weights_kahan > const sum_of_weights_kahan; extractor< tag::abstract_sum_of_variates > const sum_of_variates_kahan; } namespace impl { template<typename Sample, typename Tag> struct sum_kahan_impl; } namespace tag { struct sum_kahan; template<typename VariateType, typename VariateTag> struct sum_of_variates_kahan; struct sum_of_weights_kahan; } } }
namespace boost { namespace accumulators { template<typename LeftRight> struct feature_of<tag::tail< LeftRight >>; 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>; namespace extract { extractor< tag::abstract_tail > const tail; } namespace impl { template<typename Sample, typename LeftRight> struct tail_impl; } namespace tag { struct abstract_tail; template<typename LeftRight> struct tail; } } }
namespace boost { namespace accumulators { template<typename LeftRight> struct as_weighted_feature<tag::non_coherent_tail_mean< LeftRight >>; 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 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 { struct abstract_non_coherent_tail_mean; template<typename LeftRight> struct coherent_tail_mean; template<typename LeftRight> struct non_coherent_tail_mean; } } }
namespace boost { namespace accumulators { template<typename LeftRight> struct as_weighted_feature<tag::tail_quantile< LeftRight >>; template<typename LeftRight> struct feature_of<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 { struct abstract_tail_variate; struct abstract_tail_weights; template<typename VariateType, typename VariateTag, typename LeftRight> struct tail_variate; template<typename LeftRight> struct 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 as_weighted_feature<tag::absolute_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::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 feature_of<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; struct abstract_absolute_tail_variate_means; struct abstract_relative_tail_variate_means; template<typename LeftRight, typename VariateType, typename VariateTag> struct relative_tail_variate_means; } } }
namespace boost { namespace accumulators { template<> struct as_feature<tag::variance(immediate)>; template<> struct as_feature<tag::variance(lazy)>; template<> struct as_weighted_feature<tag::lazy_variance>; template<> struct as_weighted_feature<tag::variance>; template<> struct feature_of<tag::lazy_variance>; template<> struct feature_of<tag::lazy_weighted_variance>; template<> struct feature_of<tag::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(immediate)>; template<> struct as_feature<tag::weighted_mean(lazy)>; template<typename VariateType, typename VariateTag> struct as_feature<tag::weighted_mean_of_variates< VariateType, VariateTag >(immediate)>; template<typename VariateType, typename VariateTag> struct as_feature<tag::weighted_mean_of_variates< VariateType, VariateTag >(lazy)>; namespace extract { extractor< tag::mean > const weighted_mean; } namespace impl { template<typename Sample, typename Weight, typename Tag> struct immediate_weighted_mean_impl; template<typename Sample, typename Weight, typename Tag> struct weighted_mean_impl; } namespace tag { struct immediate_weighted_mean; template<typename VariateType, typename VariateTag> struct immediate_weighted_mean_of_variates; struct weighted_mean; template<typename VariateType, typename VariateTag> struct weighted_mean_of_variates; } } }
namespace boost { namespace accumulators { template<> struct as_feature<tag::weighted_median(with_density)>; template<> struct as_feature<tag::weighted_median(with_p_square_cumulative_distribution)>; template<> struct as_feature<tag::weighted_median(with_p_square_quantile)>; 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_probability)>; template<typename LeftRight> struct as_feature<tag::weighted_peaks_over_threshold< LeftRight >(with_threshold_value)>; 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 abstract_weighted_sum_of_variates; struct weighted_sum; template<typename VariateType, typename VariateTag> struct weighted_sum_of_variates; } } }
namespace boost { namespace accumulators { template<> struct as_feature<tag::weighted_sum(kahan)>; template<typename VariateType, typename VariateTag> struct feature_of<tag::weighted_sum_of_variates_kahan< VariateType, VariateTag >>; namespace extract { extractor< tag::weighted_sum_kahan > const weighted_sum_kahan; extractor< tag::abstract_weighted_sum_of_variates > const weighted_sum_of_variates_kahan; } namespace impl { template<typename Sample, typename Weight, typename Tag> struct weighted_sum_kahan_impl; } namespace tag { struct weighted_sum_kahan; template<typename VariateType, typename VariateTag> struct weighted_sum_of_variates_kahan; } } }
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(immediate)>; template<> struct as_feature<tag::weighted_variance(lazy)>; 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 absolute; struct for_median; struct immediate; struct kahan; struct lazy; struct left; struct linear; struct quadratic; struct regular; struct relative; struct right; struct unweighted; struct weighted; struct with_density; struct with_p_square_cumulative_distribution; struct with_p_square_quantile; struct with_threshold_probability; struct with_threshold_value; namespace extract { extractor< tag::quantile > const quantile; extractor< tag::tail_mean > const tail_mean; } namespace impl { template<typename Sample> struct rolling_mean_impl; } namespace tag { template<typename VariateType, typename VariateTag, typename LeftRight> struct left_tail_variate; struct quantile; template<typename VariateType, typename VariateTag, typename LeftRight> struct right_tail_variate; struct tail_mean; template<typename LeftRight, typename VariateType, typename VariateTag> struct tail_variate_means; template<typename LeftRight, typename VariateType, typename VariateTag> struct weighted_tail_variate_means; } } }
namespace boost { namespace numeric { template<typename T> struct default_; template<typename T> struct one; template<typename T> struct one_or_default; template<typename T> struct zero; template<typename T> struct zero_or_default; template<typename To, typename From> lazy_disable_if< is_const< From >, mpl::if_< is_same< To, From >, To &, To > >::type promote(From & from); template<typename To, typename From> mpl::if_< is_same< Toconst, Fromconst >, Toconst &, Toconst >::type promote(From const & from); namespace functional { template<typename Arg, typename Tag> struct as_max; template<typename Arg, typename EnableIf> struct as_max_base; template<typename Arg, typename Tag> struct as_min; template<typename Arg, typename EnableIf> struct as_min_base; template<typename Arg> struct as_min_base<Arg, typename enable_if< is_floating_point< Arg > >::type>; template<typename Arg, typename Tag> struct as_one; template<typename Arg, typename EnableIf> struct as_one_base; template<typename Arg, typename Tag> struct as_zero; template<typename Arg, typename EnableIf> struct as_zero_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct assign; template<typename Left, typename Right, typename EnableIf = void> struct assign_base; template<typename Arg, typename Tag = typename tag<Arg>::type> struct complement; template<typename Arg, typename EnableIf = void> struct complement_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct divides; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct divides_assign; template<typename Left, typename Right, typename EnableIf = void> struct divides_assign_base; template<typename Left, typename Right, typename EnableIf = void> struct divides_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct equal_to; template<typename Left, typename Right, typename EnableIf = void> struct equal_to_base; template<typename Left, typename Right, typename LeftTag, typename RightTag> struct fdiv; template<typename Left, typename Right, typename EnableIf> struct fdiv_base; template<typename Left, typename Right> struct fdiv_base<Left, Right, typename enable_if< are_integral< Left, Right > >::type>; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct greater; template<typename Left, typename Right, typename EnableIf = void> struct greater_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct greater_equal; template<typename Left, typename Right, typename EnableIf = void> struct greater_equal_base; template<typename Left, typename Right> struct left_ref; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct less; template<typename Left, typename Right, typename EnableIf = void> struct less_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct less_equal; template<typename Left, typename Right, typename EnableIf = void> struct less_equal_base; template<typename Arg, typename Tag = typename tag<Arg>::type> struct logical_not; template<typename Arg, typename EnableIf = void> struct logical_not_base; template<typename Left, typename Right, typename LeftTag, typename RightTag> struct max_assign; template<typename Left, typename Right, typename EnableIf> struct max_assign_base; template<typename Left, typename Right, typename LeftTag, typename RightTag> struct min_assign; template<typename Left, typename Right, typename EnableIf> struct min_assign_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct minus; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct minus_assign; template<typename Left, typename Right, typename EnableIf = void> struct minus_assign_base; template<typename Left, typename Right, typename EnableIf = void> struct minus_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct modulus; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct modulus_assign; template<typename Left, typename Right, typename EnableIf = void> struct modulus_assign_base; template<typename Left, typename Right, typename EnableIf = void> struct modulus_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct multiplies; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct multiplies_assign; template<typename Left, typename Right, typename EnableIf = void> struct multiplies_assign_base; template<typename Left, typename Right, typename EnableIf = void> struct multiplies_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct not_equal_to; template<typename Left, typename Right, typename EnableIf = void> struct not_equal_to_base; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct plus; template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> struct plus_assign; template<typename Left, typename Right, typename EnableIf = void> struct plus_assign_base; template<typename Left, typename Right, typename EnableIf = void> struct plus_base; template<typename To, typename From, typename ToTag, typename FromTag> struct promote; template<typename To, typename From, typename EnableIf> struct promote_base; template<typename ToFrom> struct promote_base<ToFrom, ToFrom, void>; template<typename Arg, typename Tag = typename tag<Arg>::type> struct unary_minus; template<typename Arg, typename EnableIf = void> struct unary_minus_base; template<typename Arg, typename Tag = typename tag<Arg>::type> struct unary_plus; template<typename Arg, typename EnableIf = void> struct unary_plus_base; } namespace op { struct as_max; struct as_min; struct as_one; struct as_zero; struct assign; struct complement; struct divides; struct divides_assign; struct equal_to; struct fdiv; struct greater; struct greater_equal; struct less; struct less_equal; struct logical_not; struct max_assign; struct min_assign; struct minus; struct minus_assign; struct modulus; struct modulus_assign; struct multiplies; struct multiplies_assign; struct not_equal_to; struct plus; struct plus_assign; template<typename To> struct promote; struct unary_minus; struct unary_plus; } } }
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 as_max<T, std_valarray_tag>; template<typename T> struct as_min<T, std_valarray_tag>; template<typename T> struct as_one<T, std_valarray_tag>; template<typename T> struct as_zero<T, std_valarray_tag>; template<typename Left, typename Right, typename RightTag> struct fdiv<Left, Right, std_valarray_tag, RightTag>; template<typename Left, typename Right> struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>; template<typename Left, typename Right> struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>; template<typename From> struct promote<bool const, From, void, std_valarray_tag>; template<typename From> struct promote<bool, From, void, std_valarray_tag>; 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 T> struct tag<std::valarray< T >>; } namespace operators { template<typename Left, typename Right> unspecified operator/(std::valarray< Left > const & left, Right const & right); template<typename Left, typename Right> unspecified operator*(std::valarray< Left > const & left, Right const & right); template<typename Left, typename Right> unspecified operator+(std::valarray< Left > const & left, std::valarray< Right > const & right); } } }
namespace boost { namespace numeric { namespace functional { template<typename T> struct as_max<T, std_vector_tag>; template<typename T> struct as_min<T, std_vector_tag>; template<typename T> struct as_one<T, std_vector_tag>; template<typename T> struct as_zero<T, std_vector_tag>; template<typename Left, typename Right> struct fdiv<Left, Right, std_vector_tag, void>; template<typename Left, typename Right> struct max_assign<Left, Right, std_vector_tag, std_vector_tag>; template<typename Left, typename Right> struct min_assign<Left, Right, std_vector_tag, std_vector_tag>; 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, typename Al> struct tag<std::vector< T, Al >>; } namespace operators { template<typename Left, typename Right> unspecified 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> unspecified operator*(std::vector< Left > const & left, Right const & right); template<typename Left, typename Right> unspecified 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); } } }