Boost C++ Libraries

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

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

Reference

Accumulators Framework Reference
Statistics Library Reference
Numeric Operators Library Reference

Accumulators Framework Reference

Includes all of the Accumulators Framework


BOOST_ACCUMULATORS_MAX_FEATURES
BOOST_ACCUMULATORS_MAX_ARGS
BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)
BOOST_ACCUMULATORS_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 {
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::accumulator > const accumulator;
    namespace tag {
      struct accumulator;
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::sample > const sample;
    namespace tag {
      struct sample;
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::weight > const weight;
    namespace tag {
      struct weight;
    }
  }
}
namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::weights > const weights;
    namespace tag {
      struct weights;
    }
  }
}

Statistics Library Reference

Includes all of the Statistical Accumulators Library

Contains the stats<> template.

Numeric Operators Library Reference

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

PrevUpHomeNext