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

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