...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
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) BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias)
namespace boost { namespace accumulators { template<typename Sample, typename Features, typename Weight> struct accumulator_set; template<typename Feature> struct as_feature; template<typename Feature> struct as_weighted_feature; template<typename Feature1, typename Feature2, ... > struct depends_on; template<typename Accumulator> struct droppable_accumulator; template<typename Accumulator> struct droppable_accumulator_base; template<typename Feature> struct extractor; template<typename Feature> struct feature_of; template<typename Feature1, typename Feature2, ... > struct features; template<typename Accumulator> struct with_cached_result; 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 { template<typename Feature> struct droppable; template<typename Feature, typename Tag, typename AccumulatorSet> struct external; template<typename Referent, typename Tag> struct reference; template<typename Tag> struct reference_tag; template<typename ValueType, typename Tag> struct value; template<typename Tag> struct value_tag; } } }
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 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 Feature> struct feature_of<tag::droppable< Feature >>; namespace tag { template<typename Feature> struct as_droppable; template<typename Feature> struct as_droppable<droppable< Feature >>; } } }
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> 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 { } } }
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 { } } }
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(Tag, Feature, ParamSeq)
namespace boost { namespace accumulators { boost::parameter::keyword< tag::accumulator > const accumulator; namespace tag { struct accumulator; } } }
namespace boost { namespace accumulators { boost::parameter::keyword< tag::sample > const sample; namespace tag { struct sample; } } }
namespace boost { namespace accumulators { boost::parameter::keyword< tag::weight > const weight; namespace tag { struct weight; } } }
namespace boost { namespace accumulators { boost::parameter::keyword< tag::weights > const weights; namespace tag { struct weights; } } }
Includes all of the Statistical Accumulators Library
Contains the stats<> template.
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< To const, From const >, To const &, To const >::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); } } }