| Home | Libraries | People | FAQ | More

## Reference

### Accumulators Framework Reference

#### Header <boost/accumulators/accumulators.hpp>

Includes all of the Accumulators Framework

#### Header <boost/accumulators/accumulators_fwd.hpp>

    BOOST_ACCUMULATORS_MAX_FEATURES
    BOOST_ACCUMULATORS_MAX_ARGS
    BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)
    BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias)

    namespace boost {
      namespace accumulators {
        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, typename A1>
          mpl::apply< AccumulatorSet, Feature >::type::result_type
          extract_result(AccumulatorSet const & acc, A1 const & a1);
        namespace impl {
        }
        namespace tag {
        }
      }
    }

#### Header <boost/accumulators/framework/accumulator_base.hpp>

    namespace boost {
      namespace accumulators {
        struct dont_care;
        struct accumulator_base;
      }
    }

#### Header <boost/accumulators/framework/accumulator_concept.hpp>

    namespace boost {
      namespace accumulators {
        template<typename Stat> struct accumulator_concept;
      }
    }

#### Header <boost/accumulators/framework/accumulator_set.hpp>

    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);
      }
    }

#### Header <boost/accumulators/framework/accumulators/droppable_accumulator.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/framework/accumulators/external_accumulator.hpp>

    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>;
        }
      }
    }

#### Header <boost/accumulators/framework/accumulators/reference_accumulator.hpp>

    namespace boost {
      namespace accumulators {
        template<typename ValueType, typename Tag>
          struct feature_of<tag::reference< ValueType, Tag >>;
        namespace extract {
           reference_tag;
           BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, reference,
                                               (typename)(typename));
        }
        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;
        }
      }
    }

#### Header <boost/accumulators/framework/accumulators/value_accumulator.hpp>

    namespace boost {
      namespace accumulators {
        template<typename ValueType, typename Tag>
          struct feature_of<tag::value< ValueType, Tag >>;
        namespace extract {
           value_tag;
           BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, value, (typename)(typename));
        }
        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;
        }
      }
    }

#### Header <boost/accumulators/framework/depends_on.hpp>

    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;
      }
    }

#### Header <boost/accumulators/framework/extractor.hpp>

    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(Tag, Feature, ParamSeq)

    namespace boost {
      namespace accumulators {
        template<typename Feature> struct extractor;
      }
    }

#### Header <boost/accumulators/framework/features.hpp>

    namespace boost {
      namespace accumulators {
        template<typename Feature1, typename Feature2, ... > struct features;
      }
    }

#### Header <boost/accumulators/framework/parameters/accumulator.hpp>

    namespace boost {
      namespace accumulators {
        boost::parameter::keyword< tag::accumulator > const accumulator;
        namespace tag {
          struct accumulator;
        }
      }
    }

#### Header <boost/accumulators/framework/parameters/sample.hpp>

    namespace boost {
      namespace accumulators {
        boost::parameter::keyword< tag::sample > const sample;
        namespace tag {
          struct sample;
        }
      }
    }

#### Header <boost/accumulators/framework/parameters/weight.hpp>

    namespace boost {
      namespace accumulators {
        boost::parameter::keyword< tag::weight > const weight;
        namespace tag {
          struct weight;
        }
      }
    }

#### Header <boost/accumulators/framework/parameters/weights.hpp>

    namespace boost {
      namespace accumulators {
        boost::parameter::keyword< tag::weights > const weights;
        namespace tag {
          struct weights;
        }
      }
    }

### Statistics Library Reference

#### Header <boost/accumulators/statistics.hpp>

Includes all of the Statistical Accumulators Library

#### Header <boost/accumulators/statistics/count.hpp>

    namespace boost {
      namespace accumulators {
        namespace extract {
          extractor< tag::count > const count;
        }
        namespace impl {
          struct count_impl;
        }
        namespace tag {
          struct count;
        }
      }
    }

#### Header <boost/accumulators/statistics/covariance.hpp>

    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 {
        static op::outer_product const & outer_product;
        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;
        }
      }
    }

#### Header <boost/accumulators/statistics/density.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/error_of.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/error_of_mean.hpp>

    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>;
        }
      }
    }

#### Header <boost/accumulators/statistics/extended_p_square.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/extended_p_square_quantile.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/kurtosis.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/max.hpp>

    namespace boost {
      namespace accumulators {
        namespace extract {
          extractor< tag::max > const max;
        }
        namespace impl {
          template<typename Sample> struct max_impl;
        }
        namespace tag {
          struct max;
        }
      }
    }

#### Header <boost/accumulators/statistics/mean.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/median.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/min.hpp>

    namespace boost {
      namespace accumulators {
        namespace extract {
          extractor< tag::min > const min;
        }
        namespace impl {
          template<typename Sample> struct min_impl;
        }
        namespace tag {
          struct min;
        }
      }
    }

#### Header <boost/accumulators/statistics/moment.hpp>

    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 {
      }
    }

#### Header <boost/accumulators/statistics/p_square_cumulative_distribution.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/p_square_quantile.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/peaks_over_threshold.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/pot_quantile.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/pot_tail_mean.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/rolling_count.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/rolling_mean.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/rolling_sum.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/rolling_window.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/skewness.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/stats.hpp>

Contains the stats<> template.

    namespace boost {
      namespace accumulators {
        template<typename Stat1, typename Stat2, ... > struct stats;
      }
    }

#### Header <boost/accumulators/statistics/sum.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/tail.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/tail_mean.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/tail_quantile.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/tail_variate.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/tail_variate_means.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/times2_iterator.hpp>

#### Header <boost/accumulators/statistics/variance.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/variates/covariate.hpp>

    namespace boost {
      namespace accumulators {
        boost::parameter::keyword< tag::covariate1 > const covariate1;
        boost::parameter::keyword< tag::covariate2 > const covariate2;
        namespace tag {
          struct covariate1;
          struct covariate2;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_covariance.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_density.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_extended_p_square.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_kurtosis.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_mean.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_median.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_moment.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_p_square_quantile.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_peaks_over_threshold.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_skewness.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_sum.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_tail_mean.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_tail_quantile.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_tail_variate_means.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/weighted_variance.hpp>

    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;
        }
      }
    }

#### Header <boost/accumulators/statistics/with_error.hpp>

    namespace boost {
      namespace accumulators {
        template<typename Feature1, typename Feature2, ... > struct with_error;
      }
    }

#### Header <boost/accumulators/statistics_fwd.hpp>

    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

#### Header <boost/accumulators/numeric/functional.hpp>

    namespace boost {
      namespace numeric {
        template<typename T> struct default_;
        template<typename T> struct one;
        template<typename T> struct zero;
        template<typename T> struct one_or_default;
        template<typename T> struct zero_or_default;

        static op::plus const & plus;
        static op::minus const & minus;
        static op::multiplies const & multiplies;
        static op::divides const & divides;
        static op::modulus const & modulus;
        static op::greater const & greater;
        static op::greater_equal const & greater_equal;
        static op::less const & less;
        static op::less_equal const & less_equal;
        static op::equal_to const & equal_to;
        static op::not_equal_to const & not_equal_to;
        static op::assign const & assign;
        static op::plus_assign const & plus_assign;
        static op::minus_assign const & minus_assign;
        static op::multiplies_assign const & multiplies_assign;
        static op::divides_assign const & divides_assign;
        static op::modulus_assign const & modulus_assign;
        static op::unary_plus const & unary_plus;
        static op::unary_minus const & unary_minus;
        static op::complement const & complement;
        static op::logical_not const & logical_not;
        static op::min_assign const & min_assign;
        static op::max_assign const & max_assign;
        static op::average const & average;
        static op::as_min const & as_min;
        static op::as_max const & as_max;
        static op::as_zero const & as_zero;
        static op::as_one const & as_one;
        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< To const, From const  >, To const &, To const  >::type
          promote(From const & from);
        namespace functional {
          template<typename Left, typename Right> struct left_ref;
          template<typename Left, typename Right, typename EnableIf = void>
            struct plus_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 EnableIf = void>
            struct minus_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 EnableIf = void>
            struct multiplies_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 EnableIf = void>
            struct divides_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 EnableIf = void>
            struct modulus_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 EnableIf = void>
            struct greater_base;
          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_equal_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 less_base;
          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_equal_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 equal_to_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 not_equal_to_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 assign_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 plus_assign_base;
          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 minus_assign_base;
          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 multiplies_assign_base;
          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 divides_assign_base;
          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 modulus_assign_base;
          template<typename Left, typename Right,
                   typename LeftTag = typename tag<Left>::type,
                   typename RightTag = typename tag<Right>::type>
            struct modulus_assign;
          template<typename Arg, typename EnableIf = void> struct unary_plus_base;
          template<typename Arg, typename Tag = typename tag<Arg>::type>
            struct unary_plus;
          template<typename Arg, typename EnableIf = void> struct unary_minus_base;
          template<typename Arg, typename Tag = typename tag<Arg>::type>
            struct unary_minus;
          template<typename Arg, typename EnableIf = void> struct complement_base;
          template<typename Arg, typename Tag = typename tag<Arg>::type>
            struct complement;
          template<typename Arg, typename EnableIf = void> struct logical_not_base;
          template<typename Arg, typename Tag = typename tag<Arg>::type>
            struct logical_not;
          template<typename Left, typename Right, typename EnableIf>
            struct min_assign_base;
          template<typename Left, typename Right, typename EnableIf>
            struct max_assign_base;
          template<typename Left, typename Right, typename EnableIf>
            struct average_base;

          template<typename Left, typename Right>
            struct average_base<Left, Right, typename enable_if< are_integral< Left, Right > >::type>;

          template<typename To, typename From, typename EnableIf> struct promote_base;

          template<typename ToFrom> struct promote_base<ToFrom, ToFrom, void>;

          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 EnableIf> struct as_max_base;
          template<typename Arg, typename EnableIf> struct as_zero_base;
          template<typename Arg, typename EnableIf> struct as_one_base;
          template<typename To, typename From, typename ToTag, typename FromTag>
            struct promote;
          template<typename Left, typename Right, typename LeftTag,
                   typename RightTag>
            struct min_assign;
          template<typename Left, typename Right, typename LeftTag,
                   typename RightTag>
            struct max_assign;
          template<typename Left, typename Right, typename LeftTag,
                   typename RightTag>
            struct average;
          template<typename Arg, typename Tag> struct as_min;
          template<typename Arg, typename Tag> struct as_max;
          template<typename Arg, typename Tag> struct as_zero;
          template<typename Arg, typename Tag> struct as_one;
        }
        namespace op {
          struct plus;
          struct minus;
          struct multiplies;
          struct divides;
          struct modulus;
          struct greater;
          struct greater_equal;
          struct less;
          struct less_equal;
          struct equal_to;
          struct not_equal_to;
          struct assign;
          struct plus_assign;
          struct minus_assign;
          struct multiplies_assign;
          struct divides_assign;
          struct modulus_assign;
          struct unary_plus;
          struct unary_minus;
          struct complement;
          struct logical_not;
          template<typename To> struct promote;
          struct min_assign;
          struct max_assign;
          struct average;
          struct as_min;
          struct as_max;
          struct as_zero;
          struct as_one;
        }
      }
    }

#### Header <boost/accumulators/numeric/functional/complex.hpp>

    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);
        }
      }
    }

#### Header <boost/accumulators/numeric/functional/valarray.hpp>

    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);
        }
      }
    }

#### Header <boost/accumulators/numeric/functional/vector.hpp>

    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);
        }
      }
    }