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

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

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

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

#### 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>
            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 {
        }
        namespace impl {
          template<typename Referent, typename Tag> struct reference_accumulator_impl;
        }
        namespace tag {
        }
      }
    }

#### 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 {
        }
        namespace impl {
          template<typename ValueType, typename Tag> struct value_accumulator_impl;
        }
        namespace tag {
        }
      }
    }

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

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

    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(Tag, Feature, ParamSeq)

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

#### 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/stats.hpp>

Contains the stats<> template.

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

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

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

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