Removed Boost

test/external/boost/accumulators/accumulators.hpp

@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file accumulators.hpp
-/// Includes all of the Accumulators Framework
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_ACCUMULATORS_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_ACCUMULATORS_HPP_EAN_28_10_2005
-
-#include <boost/accumulators/framework/accumulator_set.hpp>
-#include <boost/accumulators/framework/accumulator_concept.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/external.hpp>
-#include <boost/accumulators/framework/features.hpp>
-#include <boost/accumulators/framework/parameters/accumulator.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/parameters/weight.hpp>
-#include <boost/accumulators/framework/parameters/weights.hpp>
-#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
-#include <boost/accumulators/framework/accumulators/droppable_accumulator.hpp>
-#include <boost/accumulators/framework/accumulators/reference_accumulator.hpp>
-#include <boost/accumulators/framework/accumulators/value_accumulator.hpp>
-
-#endif

test/external/boost/accumulators/accumulators_fwd.hpp

@@ -1,219 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// accumulators_fwd.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_ACCUMULATORS_FWD_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_ACCUMULATORS_FWD_HPP_EAN_28_10_2005
-
-#include <boost/config.hpp>
-#include <boost/mpl/apply_fwd.hpp> // for mpl::na
-#include <boost/mpl/limits/vector.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/accumulators/numeric/functional_fwd.hpp>
-
-#ifndef BOOST_ACCUMULATORS_MAX_FEATURES
-  /// The maximum number of accumulators that may be put in an accumulator_set.
-  /// Defaults to BOOST_MPL_LIMIT_VECTOR_SIZE (which defaults to 20).
-# define BOOST_ACCUMULATORS_MAX_FEATURES BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#if BOOST_ACCUMULATORS_MAX_FEATURES > BOOST_MPL_LIMIT_VECTOR_SIZE
-# error BOOST_ACCUMULATORS_MAX_FEATURES cannot be larger than BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#ifndef BOOST_ACCUMULATORS_MAX_ARGS
-  /// The maximum number of arguments that may be specified to an accumulator_set's
-  /// accumulation function. Defaults to 15.
-# define BOOST_ACCUMULATORS_MAX_ARGS 15
-#endif
-
-#if BOOST_WORKAROUND(__GNUC__, == 3) \
- || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(306))
-# define BOOST_ACCUMULATORS_BROKEN_CONST_OVERLOADS
-#endif
-
-#ifdef BOOST_ACCUMULATORS_BROKEN_CONST_OVERLOADS
-# include <boost/utility/enable_if.hpp>
-# include <boost/type_traits/is_const.hpp>
-# define BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)\
-    , typename boost::disable_if<boost::is_const<T> >::type * = 0
-#else
-# define BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)
-#endif
-
-#define BOOST_ACCUMULATORS_GCC_VERSION                                                              \
-  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-
-namespace boost { namespace accumulators
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// Named parameters tags
-//
-namespace tag
-{
-    struct sample;
-    struct weight;
-    struct accumulator;
-    struct weights;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// User-level features
-//
-namespace tag
-{
-    template<typename ValueType, typename Tag>
-    struct value;
-
-    template<typename Tag>
-    struct value_tag;
-
-    template<typename Referent, typename Tag>
-    struct reference;
-
-    template<typename Tag>
-    struct reference_tag;
-
-    template<typename Type, typename Tag = void, typename AccumulatorSet = void>
-    struct external;
-
-    template<typename Feature>
-    struct droppable;
-}
-
-template<typename Accumulator>
-struct droppable_accumulator_base;
-
-template<typename Accumulator>
-struct droppable_accumulator;
-
-template<typename Accumulator>
-struct with_cached_result;
-
-template<typename Sample, typename Features, typename Weight = void>
-struct accumulator_set;
-
-template<typename Feature>
-struct extractor;
-
-template<typename Feature>
-struct feature_of;
-
-template<typename Feature>
-struct as_feature;
-
-template<typename Feature>
-struct as_weighted_feature;
-
-template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature, mpl::na)>
-struct depends_on;
-
-template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature, mpl::na)>
-struct features;
-
-template<typename Feature, typename AccumulatorSet>
-typename mpl::apply<AccumulatorSet, Feature>::type const &
-find_accumulator(AccumulatorSet const &acc);
-
-template<typename Feature, typename AccumulatorSet>
-typename mpl::apply<AccumulatorSet, Feature>::type::result_type
-extract_result(AccumulatorSet const &acc);
-
-template<typename Feature, typename AccumulatorSet, typename A1>
-typename mpl::apply<AccumulatorSet, Feature>::type::result_type
-extract_result(AccumulatorSet const &acc, A1 const &a1);
-
-// ... other overloads generated by Boost.Preprocessor:
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_EXTRACT_RESULT_FWD(z, n, _)                      \
-    template<                                                               \
-        typename Feature                                                    \
-      , typename AccumulatorSet                                             \
-        BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A)                   \
-    >                                                                       \
-    typename mpl::apply<AccumulatorSet, Feature>::type::result_type         \
-    extract_result(                                                         \
-        AccumulatorSet const &acc                                           \
-        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a)           \
-    );
-
-/// INTERNAL ONLY
-///
-BOOST_PP_REPEAT_FROM_TO(
-    2
-  , BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
-  , BOOST_ACCUMULATORS_EXTRACT_RESULT_FWD
-  , _
-)
-
-#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-template<typename Feature, typename AccumulatorSet, typename A1, typename A2 ...>
-typename mpl::apply<AccumulatorSet, Feature>::type::result_type
-extract_result(AccumulatorSet const &acc, A1 const &a1, A2 const &a2 ...);
-#endif
-
-namespace impl
-{
-    using namespace numeric::operators;
-
-    template<typename Accumulator, typename Tag>
-    struct external_impl;
-}
-
-namespace detail
-{
-    template<typename Accumulator>
-    struct feature_tag;
-
-    template<typename Feature, typename Sample, typename Weight>
-    struct to_accumulator;
-
-    struct accumulator_set_base;
-
-    template<typename T>
-    struct is_accumulator_set;
-
-    inline void ignore_variable(void const *) {}
-
-  #define BOOST_ACCUMULATORS_IGNORE_GLOBAL(X)\
-    namespace detail { inline void BOOST_PP_CAT(ignore_, X)() { boost::accumulators::detail::ignore_variable(&X); } }
-}
-
-}} // namespace boost::accumulators
-
-// For defining boost::parameter keywords that can be inherited from to
-// get a nested, class-scoped keyword with the requested alias
-#define BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias)                                  \
-    namespace tag_namespace                                                                         \
-    {                                                                                               \
-        template<int Dummy = 0>                                                                     \
-        struct name ## _                                                                            \
-        {                                                                                           \
-            static char const* keyword_name()                                                       \
-            {                                                                                       \
-                return #name;                                                                       \
-            }                                                                                       \
-            static ::boost::parameter::keyword<name ## _<Dummy> > &alias;                           \
-        };                                                                                          \
-        template<int Dummy>                                                                         \
-        ::boost::parameter::keyword<name ## _<Dummy> > &name ## _<Dummy>::alias =                   \
-        ::boost::parameter::keyword<name ## _<Dummy> >::get();                                      \
-        typedef name ## _ <> name;                                                                  \
-    }                                                                                               \
-    namespace                                                                                       \
-    {                                                                                               \
-        ::boost::parameter::keyword<tag_namespace::name> &name =                                    \
-        ::boost::parameter::keyword<tag_namespace::name>::get();                                    \
-    }
-
-#endif

test/external/boost/accumulators/framework/accumulator_base.hpp

@@ -1,65 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// accumulator_base.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_BASE_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_BASE_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/joint_view.hpp>
-#include <boost/mpl/single_view.hpp>
-#include <boost/mpl/fold.hpp>
-#include <boost/mpl/contains.hpp>
-#include <boost/mpl/empty_sequence.hpp>
-#include <boost/accumulators/framework/accumulator_concept.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace detail
-{
-    typedef void void_;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// dont_care
-//
-struct dont_care
-{
-    template<typename Args>
-    dont_care(Args const &)
-    {
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// accumulator_base
-//
-struct accumulator_base
-{
-    // hidden if defined in derived classes
-    detail::void_ operator ()(dont_care)
-    {
-    }
-
-    typedef mpl::false_ is_droppable;
-
-    detail::void_ add_ref(dont_care)
-    {
-    }
-
-    detail::void_ drop(dont_care)
-    {
-    }
-
-    detail::void_ on_drop(dont_care)
-    {
-    }
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/accumulator_concept.hpp

@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// accumulator_concept.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATOR_CONCEPT_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATOR_CONCEPT_HPP_EAN_28_10_2005
-
-#include <boost/concept_check.hpp>
-
-namespace boost { namespace accumulators
-{
-
-template<typename Stat>
-struct accumulator_concept
-{
-    void constraints()
-    {
-        // TODO: define the stat concept
-    }
-
-    Stat stat;
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/accumulator_set.hpp

@@ -1,401 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// accumulator_set.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATOR_SET_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATOR_SET_HPP_EAN_28_10_2005
-
-#include <boost/version.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/protect.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/is_sequence.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/parameter/parameters.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/accumulators/accumulators_fwd.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/framework/accumulator_concept.hpp>
-#include <boost/accumulators/framework/parameters/accumulator.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
-#include <boost/accumulators/framework/accumulators/droppable_accumulator.hpp>
-#include <boost/fusion/include/any.hpp>
-#include <boost/fusion/include/find_if.hpp>
-#include <boost/fusion/include/for_each.hpp>
-#include <boost/fusion/include/filter_view.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace detail
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // accumulator_visitor
-    //   wrap a boost::parameter argument pack in a Fusion extractor object
-    template<typename Args>
-    struct accumulator_visitor
-    {
-        explicit accumulator_visitor(Args const &a)
-          : args(a)
-        {
-        }
-
-        template<typename Accumulator>
-        void operator ()(Accumulator &accumulator) const
-        {
-            accumulator(this->args);
-        }
-
-    private:
-        accumulator_visitor &operator =(accumulator_visitor const &);
-        Args const &args;
-    };
-
-    template<typename Args>
-    inline accumulator_visitor<Args> const make_accumulator_visitor(Args const &args)
-    {
-        return accumulator_visitor<Args>(args);
-    }
-
-    typedef
-        parameter::parameters<
-            parameter::required<tag::accumulator>
-          , parameter::optional<tag::sample>
-          // ... and others which are not specified here...
-        >
-    accumulator_params;
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // accumulator_set_base
-    struct accumulator_set_base
-    {
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // is_accumulator_set
-    template<typename T>
-    struct is_accumulator_set
-      : is_base_and_derived<accumulator_set_base, T>
-    {
-    };
-
-} // namespace detail
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4355) // warning C4355: 'this' : used in base member initializer list
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// \brief A set of accumulators.
-///
-/// accumulator_set resolves the dependencies between features and ensures that
-/// the accumulators in the set are updated in the proper order.
-///
-/// acccumulator_set provides a general mechanism to visit the accumulators
-/// in the set in order, with or without a filter. You can also fetch a reference
-/// to an accumulator that corresponds to a feature.
-///
-template<typename Sample, typename Features, typename Weight>
-struct accumulator_set
-  : detail::accumulator_set_base
-{
-    typedef Sample sample_type;     ///< The type of the samples that will be accumulated
-    typedef Features features_type; ///< An MPL sequence of the features that should be accumulated.
-    typedef Weight weight_type;     ///< The type of the weight parameter. Must be a scalar. Defaults to void.
-
-    /// INTERNAL ONLY
-    ///
-    typedef
-        typename detail::make_accumulator_tuple<
-            Features
-          , Sample
-          , Weight
-        >::type
-    accumulators_mpl_vector;
-
-    // generate a fusion::list of accumulators
-    /// INTERNAL ONLY
-    ///
-    typedef
-        typename detail::meta::make_acc_list<
-            accumulators_mpl_vector
-        >::type
-    accumulators_type;
-
-    /// INTERNAL ONLY
-    ///
-    //BOOST_MPL_ASSERT((mpl::is_sequence<accumulators_type>));
-
-    ///////////////////////////////////////////////////////////////////////////////
-    /// default-construct all contained accumulators
-    accumulator_set()
-      : accumulators(
-            detail::make_acc_list(
-                accumulators_mpl_vector()
-              , detail::accumulator_params()(*this)
-            )
-        )
-    {
-        // Add-ref the Features that the user has specified
-        this->template visit_if<detail::contains_feature_of_<Features> >(
-            detail::make_add_ref_visitor(detail::accumulator_params()(*this))
-        );
-    }
-
-    /// \overload
-    ///
-    /// \param a1 Optional named parameter to be passed to all the accumulators
-    template<typename A1>
-    explicit accumulator_set(A1 const &a1)
-      : accumulators(
-            detail::make_acc_list(
-                accumulators_mpl_vector()
-              , detail::accumulator_params()(*this, a1)
-            )
-        )
-    {
-        // Add-ref the Features that the user has specified
-        this->template visit_if<detail::contains_feature_of_<Features> >(
-            detail::make_add_ref_visitor(detail::accumulator_params()(*this))
-        );
-    }
-
-    // ... other overloads generated by Boost.Preprocessor:
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_ACCUMULATORS_ACCUMULATOR_SET_CTOR(z, n, _)                                \
-    template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                                  \
-    accumulator_set(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a))                   \
-      : accumulators(                                                                   \
-            detail::make_acc_list(                                                      \
-                accumulators_mpl_vector()                                               \
-              , detail::accumulator_params()(                                           \
-                    *this BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a)                      \
-                )                                                                       \
-            )                                                                           \
-        )                                                                               \
-    {                                                                                   \
-        /* Add-ref the Features that the user has specified */                          \
-        this->template visit_if<detail::contains_feature_of_<Features> >(               \
-            detail::make_add_ref_visitor(detail::accumulator_params()(*this))           \
-        );                                                                              \
-    }
-
-    /// INTERNAL ONLY
-    ///
-    BOOST_PP_REPEAT_FROM_TO(
-        2
-      , BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
-      , BOOST_ACCUMULATORS_ACCUMULATOR_SET_CTOR
-      , _
-    )
-
-    #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-    /// \overload
-    ///
-    template<typename A1, typename A2, ...>
-    accumulator_set(A1 const &a1, A2 const &a2, ...);
-    #endif
-
-    // ... other overloads generated by Boost.Preprocessor below ...
-
-    ///////////////////////////////////////////////////////////////////////////////
-    /// Visitation
-    /// \param func UnaryFunction which is invoked with each accumulator in turn.
-    template<typename UnaryFunction>
-    void visit(UnaryFunction const &func)
-    {
-        fusion::for_each(this->accumulators, func);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    /// Conditional visitation
-    /// \param func UnaryFunction which is invoked with each accumulator in turn,
-    ///     provided the accumulator satisfies the MPL predicate FilterPred.
-    template<typename FilterPred, typename UnaryFunction>
-    void visit_if(UnaryFunction const &func)
-    {
-        fusion::filter_view<accumulators_type, FilterPred> filtered_accs(this->accumulators);
-        fusion::for_each(filtered_accs, func);
-    }
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    /// The return type of the operator() overloads is void.
-    typedef void result_type;
-
-    ///////////////////////////////////////////////////////////////////////////////
-    /// Accumulation
-    /// \param a1 Optional named parameter to be passed to all the accumulators
-    void operator ()()
-    {
-        this->visit(
-            detail::make_accumulator_visitor(
-                detail::accumulator_params()(*this)
-            )
-        );
-    }
-
-    template<typename A1>
-    void operator ()(A1 const &a1)
-    {
-        this->visit(
-            detail::make_accumulator_visitor(
-                detail::accumulator_params()(*this, a1)
-            )
-        );
-    }
-
-    // ... other overloads generated by Boost.Preprocessor:
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_ACCUMULATORS_ACCUMULATOR_SET_FUN_OP(z, n, _)                              \
-    template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                                  \
-    void operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a))                  \
-    {                                                                                   \
-        this->visit(                                                                    \
-            detail::make_accumulator_visitor(                                           \
-                detail::accumulator_params()(                                           \
-                    *this BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a)                      \
-                )                                                                       \
-            )                                                                           \
-        );                                                                              \
-    }
-
-    /// INTERNAL ONLY
-    ///
-    BOOST_PP_REPEAT_FROM_TO(
-        2
-      , BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
-      , BOOST_ACCUMULATORS_ACCUMULATOR_SET_FUN_OP
-      , _
-    )
-
-    #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-    /// \overload
-    ///
-    template<typename A1, typename A2, ...>
-    void operator ()(A1 const &a1, A2 const &a2, ...);
-    #endif
-
-    ///////////////////////////////////////////////////////////////////////////////
-    /// Extraction
-    template<typename Feature>
-    struct apply
-      : fusion::result_of::value_of<
-            typename fusion::result_of::find_if<
-                accumulators_type
-              , detail::matches_feature<Feature>
-            >::type
-        >
-    {
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    /// Extraction
-    template<typename Feature>
-    typename apply<Feature>::type &extract()
-    {
-        return *fusion::find_if<detail::matches_feature<Feature> >(this->accumulators);
-    }
-
-    /// \overload
-    template<typename Feature>
-    typename apply<Feature>::type const &extract() const
-    {
-        return *fusion::find_if<detail::matches_feature<Feature> >(this->accumulators);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    /// Drop
-    template<typename Feature>
-    void drop()
-    {
-        // You can only drop the features that you have specified explicitly
-        typedef typename apply<Feature>::type the_accumulator;
-        BOOST_MPL_ASSERT((detail::contains_feature_of<Features, the_accumulator>));
-
-        typedef
-            typename feature_of<typename as_feature<Feature>::type>::type
-        the_feature;
-
-        (*fusion::find_if<detail::matches_feature<Feature> >(this->accumulators))
-            .drop(detail::accumulator_params()(*this));
-
-        // Also drop accumulators that this feature depends on
-        typedef typename the_feature::dependencies dependencies;
-        this->template visit_if<detail::contains_feature_of_<dependencies> >(
-            detail::make_drop_visitor(detail::accumulator_params()(*this))
-        );
-    }
-
-private:
-
-    accumulators_type accumulators;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// find_accumulator
-//   find an accumulator in an accumulator_set corresponding to a feature
-template<typename Feature, typename AccumulatorSet>
-typename mpl::apply<AccumulatorSet, Feature>::type &
-find_accumulator(AccumulatorSet &acc BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(AccumulatorSet))
-{
-    return acc.template extract<Feature>();
-}
-
-/// \overload
-template<typename Feature, typename AccumulatorSet>
-typename mpl::apply<AccumulatorSet, Feature>::type const &
-find_accumulator(AccumulatorSet const &acc)
-{
-    return acc.template extract<Feature>();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract_result
-//   extract a result from an accumulator set
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_EXTRACT_RESULT_FUN(z, n, _)                      \
-    template<                                                               \
-        typename Feature                                                    \
-      , typename AccumulatorSet                                             \
-        BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A)                   \
-    >                                                                       \
-    typename mpl::apply<AccumulatorSet, Feature>::type::result_type         \
-    extract_result(                                                         \
-        AccumulatorSet const &acc                                           \
-        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a)           \
-    )                                                                       \
-    {                                                                       \
-        return find_accumulator<Feature>(acc).result(                       \
-            detail::accumulator_params()(                                   \
-                acc                                                         \
-                BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a)                    \
-            )                                                               \
-        );                                                                  \
-    }
-
-BOOST_PP_REPEAT(
-    BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
-  , BOOST_ACCUMULATORS_EXTRACT_RESULT_FUN
-  , _
-)
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/accumulators/droppable_accumulator.hpp

@@ -1,317 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// droppable_accumulator.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_DROPPABLE_ACCUMULATOR_HPP_EAN_13_12_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_DROPPABLE_ACCUMULATOR_HPP_EAN_13_12_2005
-
-#include <new>
-#include <boost/assert.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/aligned_storage.hpp>
-#include <boost/accumulators/framework/depends_on.hpp> // for feature_of
-#include <boost/accumulators/framework/parameters/accumulator.hpp> // for accumulator
-
-namespace boost { namespace accumulators
-{
-
-    template<typename Accumulator>
-    struct droppable_accumulator;
-
-    namespace detail
-    {
-        ///////////////////////////////////////////////////////////////////////////////
-        // add_ref_visitor
-        //   a fusion function object for add_ref'ing accumulators
-        template<typename Args>
-        struct add_ref_visitor
-        {
-            explicit add_ref_visitor(Args const &args)
-              : args_(args)
-            {
-            }
-
-            template<typename Accumulator>
-            void operator ()(Accumulator &acc) const
-            {
-                typedef typename Accumulator::feature_tag::dependencies dependencies;
-
-                acc.add_ref(this->args_);
-
-                // Also add_ref accumulators that this feature depends on
-                this->args_[accumulator].template
-                    visit_if<detail::contains_feature_of_<dependencies> >(
-                        *this
-                );
-            }
-
-        private:
-            add_ref_visitor &operator =(add_ref_visitor const &);
-            Args const &args_;
-        };
-
-        template<typename Args>
-        add_ref_visitor<Args> make_add_ref_visitor(Args const &args)
-        {
-            return add_ref_visitor<Args>(args);
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // drop_visitor
-        //   a fusion function object for dropping accumulators
-        template<typename Args>
-        struct drop_visitor
-        {
-            explicit drop_visitor(Args const &args)
-              : args_(args)
-            {
-            }
-
-            template<typename Accumulator>
-            void operator ()(Accumulator &acc) const
-            {
-                if(typename Accumulator::is_droppable())
-                {
-                    typedef typename Accumulator::feature_tag::dependencies dependencies;
-
-                    acc.drop(this->args_);
-                    // Also drop accumulators that this feature depends on
-                    this->args_[accumulator].template
-                        visit_if<detail::contains_feature_of_<dependencies> >(
-                            *this
-                    );
-                }
-            }
-
-        private:
-            drop_visitor &operator =(drop_visitor const &);
-            Args const &args_;
-        };
-
-        template<typename Args>
-        drop_visitor<Args> make_drop_visitor(Args const &args)
-        {
-            return drop_visitor<Args>(args);
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // droppable_accumulator_base
-    template<typename Accumulator>
-    struct droppable_accumulator_base
-      : Accumulator
-    {
-        typedef droppable_accumulator_base base;
-        typedef mpl::true_ is_droppable;
-        typedef typename Accumulator::result_type result_type;
-
-        template<typename Args>
-        droppable_accumulator_base(Args const &args)
-          : Accumulator(args)
-          , ref_count_(0)
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            if(!this->is_dropped())
-            {
-                this->Accumulator::operator ()(args);
-            }
-        }
-
-        template<typename Args>
-        void add_ref(Args const &)
-        {
-            ++this->ref_count_;
-        }
-
-        template<typename Args>
-        void drop(Args const &args)
-        {
-            BOOST_ASSERT(0 < this->ref_count_);
-            if(1 == this->ref_count_)
-            {
-                static_cast<droppable_accumulator<Accumulator> *>(this)->on_drop(args);
-            }
-            --this->ref_count_;
-        }
-
-        bool is_dropped() const
-        {
-            return 0 == this->ref_count_;
-        }
-
-    private:
-        int ref_count_;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // droppable_accumulator
-    //   this can be specialized for any type that needs special handling
-    template<typename Accumulator>
-    struct droppable_accumulator
-      : droppable_accumulator_base<Accumulator>
-    {
-        template<typename Args>
-        droppable_accumulator(Args const &args)
-          : droppable_accumulator::base(args)
-        {
-        }
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // with_cached_result
-    template<typename Accumulator>
-    struct with_cached_result
-      : Accumulator
-    {
-        typedef typename Accumulator::result_type result_type;
-
-        template<typename Args>
-        with_cached_result(Args const &args)
-          : Accumulator(args)
-          , cache()
-        {
-        }
-
-        with_cached_result(with_cached_result const &that)
-          : Accumulator(*static_cast<Accumulator const *>(&that))
-          , cache()
-        {
-            if(that.has_result())
-            {
-                this->set(that.get());
-            }
-        }
-
-        ~with_cached_result()
-        {
-            // Since this is a base class of droppable_accumulator_base,
-            // this destructor is called before any of droppable_accumulator_base's
-            // members get cleaned up, including is_dropped, so the following
-            // call to has_result() is valid.
-            if(this->has_result())
-            {
-                this->get().~result_type();
-            }
-        }
-
-        template<typename Args>
-        void on_drop(Args const &args)
-        {
-            // cache the result at the point this calcuation was dropped
-            BOOST_ASSERT(!this->has_result());
-            this->set(this->Accumulator::result(args));
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return this->has_result() ? this->get() : this->Accumulator::result(args);
-        }
-
-    private:
-        with_cached_result &operator =(with_cached_result const &);
-
-        void set(result_type const &r)
-        {
-            ::new(this->cache.address()) result_type(r);
-        }
-
-        result_type const &get() const
-        {
-            return *static_cast<result_type const *>(this->cache.address());
-        }
-
-        bool has_result() const
-        {
-            typedef with_cached_result<Accumulator> this_type;
-            typedef droppable_accumulator_base<this_type> derived_type;
-            return static_cast<derived_type const *>(this)->is_dropped();
-        }
-
-        aligned_storage<sizeof(result_type)> cache;
-    };
-
-    namespace tag
-    {
-        template<typename Feature>
-        struct as_droppable
-        {
-            typedef droppable<Feature> type;
-        };
-
-        template<typename Feature>
-        struct as_droppable<droppable<Feature> >
-        {
-            typedef droppable<Feature> type;
-        };
-
-        //////////////////////////////////////////////////////////////////////////
-        // droppable
-        template<typename Feature>
-        struct droppable
-          : as_feature<Feature>::type
-        {
-            typedef typename as_feature<Feature>::type feature_type;
-            typedef typename feature_type::dependencies tmp_dependencies_;
-
-            typedef
-                typename mpl::transform<
-                    typename feature_type::dependencies
-                  , as_droppable<mpl::_1>
-                >::type
-            dependencies;
-
-            struct impl
-            {
-                template<typename Sample, typename Weight>
-                struct apply
-                {
-                    typedef
-                        droppable_accumulator<
-                            typename mpl::apply2<typename feature_type::impl, Sample, Weight>::type
-                        >
-                    type;
-                };
-            };
-        };
-    }
-
-    // make droppable<tag::feature(modifier)> work
-    template<typename Feature>
-    struct as_feature<tag::droppable<Feature> >
-    {
-        typedef tag::droppable<typename as_feature<Feature>::type> type;
-    };
-
-    // make droppable<tag::mean> work with non-void weights (should become
-    // droppable<tag::weighted_mean>
-    template<typename Feature>
-    struct as_weighted_feature<tag::droppable<Feature> >
-    {
-        typedef tag::droppable<typename as_weighted_feature<Feature>::type> type;
-    };
-
-    // for the purposes of feature-based dependency resolution,
-    // droppable<Foo> provides the same feature as Foo
-    template<typename Feature>
-    struct feature_of<tag::droppable<Feature> >
-      : feature_of<Feature>
-    {
-    };
-
-    // Note: Usually, the extractor is pulled into the accumulators namespace with
-    // a using directive, not the tag. But the droppable<> feature doesn't have an
-    // extractor, so we can put the droppable tag in the accumulators namespace
-    // without fear of a name conflict.
-    using tag::droppable;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/accumulators/external_accumulator.hpp

@@ -1,108 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// external_accumulator.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_EXTERNAL_ACCUMULATOR_HPP_EAN_01_12_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_EXTERNAL_ACCUMULATOR_HPP_EAN_01_12_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/accumulators/reference_accumulator.hpp>
-
-namespace boost { namespace accumulators { namespace impl
-{
-
-    //////////////////////////////////////////////////////////////////////////
-    // external_impl
-    /// INTERNAL ONLY
-    ///
-    template<typename Accumulator, typename Tag>
-    struct external_impl
-      : accumulator_base
-    {
-        typedef typename Accumulator::result_type result_type;
-        typedef typename detail::feature_tag<Accumulator>::type feature_tag;
-
-        external_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return this->extract_(args, args[parameter::keyword<Tag>::get() | 0]);
-        }
-
-    private:
-
-        template<typename Args>
-        static result_type extract_(Args const &args, int)
-        {
-            // No named parameter passed to the extractor. Maybe the external
-            // feature is held by reference<>.
-            extractor<feature_tag> extract;
-            return extract(accumulators::reference_tag<Tag>(args));
-        }
-
-        template<typename Args, typename AccumulatorSet>
-        static result_type extract_(Args const &, AccumulatorSet const &acc)
-        {
-            // OK, a named parameter for this external feature was passed to the
-            // extractor, so use that.
-            extractor<feature_tag> extract;
-            return extract(acc);
-        }
-    };
-
-} // namespace impl
-
-namespace tag
-{
-    //////////////////////////////////////////////////////////////////////////
-    // external
-    template<typename Feature, typename Tag, typename AccumulatorSet>
-    struct external
-      : depends_on<reference<AccumulatorSet, Tag> >
-    {
-        typedef
-            accumulators::impl::external_impl<
-                detail::to_accumulator<Feature, mpl::_1, mpl::_2>
-              , Tag
-            >
-        impl;
-    };
-
-    template<typename Feature, typename Tag>
-    struct external<Feature, Tag, void>
-      : depends_on<>
-    {
-        typedef
-            accumulators::impl::external_impl<
-                detail::to_accumulator<Feature, mpl::_1, mpl::_2>
-              , Tag
-            >
-        impl;
-    };
-}
-
-// for the purposes of feature-based dependency resolution,
-// external_accumulator<Feature, Tag> provides the same feature as Feature
-template<typename Feature, typename Tag, typename AccumulatorSet>
-struct feature_of<tag::external<Feature, Tag, AccumulatorSet> >
-  : feature_of<Feature>
-{
-};
-
-// Note: Usually, the extractor is pulled into the accumulators namespace with
-// a using directive, not the tag. But the external<> feature doesn't have an
-// extractor, so we can put the external tag in the accumulators namespace
-// without fear of a name conflict.
-using tag::external;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/accumulators/reference_accumulator.hpp

@@ -1,89 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// reference_accumulator.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_REFERENCE_ACCUMULATOR_HPP_EAN_03_23_2006
-#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_REFERENCE_ACCUMULATOR_HPP_EAN_03_23_2006
-
-#include <boost/ref.hpp>
-#include <boost/mpl/always.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    //////////////////////////////////////////////////////////////////////////
-    // reference_accumulator_impl
-    //
-    template<typename Referent, typename Tag>
-    struct reference_accumulator_impl
-      : accumulator_base
-    {
-        typedef Referent &result_type;
-
-        template<typename Args>
-        reference_accumulator_impl(Args const &args)
-          : ref(args[parameter::keyword<Tag>::get()])
-        {
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->ref;
-        }
-
-    private:
-        reference_wrapper<Referent> ref;
-    };
-} // namespace impl
-
-namespace tag
-{
-    //////////////////////////////////////////////////////////////////////////
-    // reference_tag
-    template<typename Tag>
-    struct reference_tag
-    {
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // reference
-    template<typename Referent, typename Tag>
-    struct reference
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::reference_accumulator_impl<Referent, Tag> > impl;
-    };
-}
-
-namespace extract
-{
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, reference, (typename)(typename))
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, reference_tag, (typename))
-}
-
-using extract::reference;
-using extract::reference_tag;
-
-// Map all reference<V,T> features to reference_tag<T> so
-// that references can be extracted using reference_tag<T>
-// without specifying the referent type.
-template<typename ValueType, typename Tag>
-struct feature_of<tag::reference<ValueType, Tag> >
-  : feature_of<tag::reference_tag<Tag> >
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/accumulators/value_accumulator.hpp

@@ -1,89 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// value_accumulator.hpp
-//
-//  Copyright 2005 Eric Niebler, Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_VALUE_ACCUMULATOR_HPP_EAN_03_23_2006
-#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_VALUE_ACCUMULATOR_HPP_EAN_03_23_2006
-
-#include <boost/mpl/always.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-    //////////////////////////////////////////////////////////////////////////
-    // value_accumulator_impl
-    template<typename ValueType, typename Tag>
-    struct value_accumulator_impl
-      : accumulator_base
-    {
-        typedef ValueType result_type;
-
-        template<typename Args>
-        value_accumulator_impl(Args const &args)
-          : val(args[parameter::keyword<Tag>::get()])
-        {
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->val;
-        }
-
-    private:
-        ValueType val;
-    };
-
-} // namespace impl
-
-namespace tag
-{
-    //////////////////////////////////////////////////////////////////////////
-    // value_tag
-    template<typename Tag>
-    struct value_tag
-    {
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // value
-    template<typename ValueType, typename Tag>
-    struct value
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::value_accumulator_impl<ValueType, Tag> > impl;
-    };
-}
-
-namespace extract
-{
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, value, (typename)(typename))
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, value_tag, (typename))
-}
-
-using extract::value;
-using extract::value_tag;
-
-// Map all value<V,T> features to value_tag<T> so
-// that values can be extracted using value_tag<T>
-// without specifying the value type.
-template<typename ValueType, typename Tag>
-struct feature_of<tag::value<ValueType, Tag> >
-  : feature_of<tag::value_tag<Tag> >
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/depends_on.hpp

@@ -1,411 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// depends_on.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_DEPENDS_ON_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_DEPENDS_ON_HPP_EAN_28_10_2005
-
-#include <boost/version.hpp>
-#include <boost/mpl/end.hpp>
-#include <boost/mpl/map.hpp>
-#include <boost/mpl/fold.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/sort.hpp>
-#include <boost/mpl/insert.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/remove.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/inherit.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/contains.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/is_sequence.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/insert_range.hpp>
-#include <boost/mpl/transform_view.hpp>
-#include <boost/mpl/inherit_linearly.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp>
-#include <boost/accumulators/accumulators_fwd.hpp>
-#include <boost/fusion/include/next.hpp>
-#include <boost/fusion/include/equal_to.hpp>
-#include <boost/fusion/include/value_of.hpp>
-#include <boost/fusion/include/mpl.hpp>
-#include <boost/fusion/include/end.hpp>
-#include <boost/fusion/include/begin.hpp>
-#include <boost/fusion/include/cons.hpp>
-
-namespace boost { namespace accumulators
-{
-    ///////////////////////////////////////////////////////////////////////////
-    // as_feature
-    template<typename Feature>
-    struct as_feature
-    {
-        typedef Feature type;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    // weighted_feature
-    template<typename Feature>
-    struct as_weighted_feature
-    {
-        typedef Feature type;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    // feature_of
-    template<typename Feature>
-    struct feature_of
-    {
-        typedef Feature type;
-    };
-
-    namespace detail
-    {
-        ///////////////////////////////////////////////////////////////////////////
-        // feature_tag
-        template<typename Accumulator>
-        struct feature_tag
-        {
-            typedef typename Accumulator::feature_tag type;
-        };
-
-        template<typename Feature>
-        struct undroppable
-        {
-            typedef Feature type;
-        };
-
-        template<typename Feature>
-        struct undroppable<tag::droppable<Feature> >
-        {
-            typedef Feature type;
-        };
-
-        // For the purpose of determining whether one feature depends on another,
-        // disregard whether the feature is droppable or not.
-        template<typename A, typename B>
-        struct is_dependent_on
-          : is_base_and_derived<
-                typename undroppable<B>::type
-              , typename undroppable<A>::type
-            >
-        {};
-
-        template<typename Features>
-        struct depends_on_base
-          : mpl::inherit_linearly<
-                typename mpl::sort<Features, is_dependent_on<mpl::_1, mpl::_2> >::type
-                // Don't inherit multiply from a feature
-              , mpl::if_<
-                    is_dependent_on<mpl::_1, mpl::_2>
-                  , mpl::_1
-                  , mpl::inherit<mpl::_1, mpl::_2>
-                >
-            >::type
-        {
-        };
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    /// depends_on
-    template<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature)>
-    struct depends_on
-      : detail::depends_on_base<
-            typename mpl::transform<
-                mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)>
-              , as_feature<mpl::_1>
-            >::type
-        >
-    {
-        typedef mpl::false_ is_weight_accumulator;
-        typedef
-            typename mpl::transform<
-                mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)>
-              , as_feature<mpl::_1>
-            >::type
-        dependencies;
-    };
-
-    namespace detail
-    {
-        template<typename Feature>
-        struct matches_feature
-        {
-            template<typename Accumulator>
-            struct apply
-              : is_same<
-                    typename feature_of<typename as_feature<Feature>::type>::type
-                  , typename feature_of<typename as_feature<typename feature_tag<Accumulator>::type>::type>::type
-                >
-            {};
-        };
-
-        template<typename Features, typename Accumulator>
-        struct contains_feature_of
-        {
-            typedef
-                mpl::transform_view<Features, feature_of<as_feature<mpl::_> > >
-            features_list;
-
-            typedef
-                typename feature_of<typename feature_tag<Accumulator>::type>::type
-            the_feature;
-
-            typedef
-                typename mpl::contains<features_list, the_feature>::type
-            type;
-        };
-
-        // This is to work around a bug in early versions of Fusion which caused
-        // a compile error if contains_feature_of<List, mpl::_> is used as a
-        // predicate to fusion::find_if
-        template<typename Features>
-        struct contains_feature_of_
-        {
-            template<typename Accumulator>
-            struct apply
-              : contains_feature_of<Features, Accumulator>
-            {};
-        };
-
-        template<
-            typename First
-          , typename Last
-          , bool is_empty = fusion::result_of::equal_to<First, Last>::value
-        >
-        struct build_acc_list;
-
-        template<typename First, typename Last>
-        struct build_acc_list<First, Last, true>
-        {
-            typedef fusion::nil type;
-
-            template<typename Args>
-            static fusion::nil
-            call(Args const &, First const&, Last const&)
-            {
-                return fusion::nil();
-            }
-        };
-
-        template<typename First, typename Last>
-        struct build_acc_list<First, Last, false>
-        {
-            typedef
-                build_acc_list<typename fusion::result_of::next<First>::type, Last>
-            next_build_acc_list;
-
-            typedef fusion::cons<
-                typename fusion::result_of::value_of<First>::type
-              , typename next_build_acc_list::type>
-            type;
-
-            template<typename Args>
-            static type
-            call(Args const &args, First const& f, Last const& l)
-            {
-                return type(args, next_build_acc_list::call(args, fusion::next(f), l));
-            }
-        };
-
-        namespace meta
-        {
-            template<typename Sequence>
-            struct make_acc_list
-              : build_acc_list<
-                    typename fusion::result_of::begin<Sequence>::type
-                  , typename fusion::result_of::end<Sequence>::type
-                >
-            {};
-        }
-
-        template<typename Sequence, typename Args>
-        typename meta::make_acc_list<Sequence>::type
-        make_acc_list(Sequence const &seq, Args const &args)
-        {
-            return meta::make_acc_list<Sequence>::call(args, fusion::begin(seq), fusion::end(seq));
-        }
-
-        ///////////////////////////////////////////////////////////////////////////
-        // checked_as_weighted_feature
-        template<typename Feature>
-        struct checked_as_weighted_feature
-        {
-            typedef typename as_feature<Feature>::type feature_type;
-            typedef typename as_weighted_feature<feature_type>::type type;
-            // weighted and non-weighted flavors should provide the same feature.
-            BOOST_MPL_ASSERT((
-                is_same<
-                    typename feature_of<feature_type>::type
-                  , typename feature_of<type>::type
-                >
-            ));
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-        // as_feature_list
-        template<typename Features, typename Weight>
-        struct as_feature_list
-          : mpl::transform_view<Features, checked_as_weighted_feature<mpl::_1> >
-        {
-        };
-
-        template<typename Features>
-        struct as_feature_list<Features, void>
-          : mpl::transform_view<Features, as_feature<mpl::_1> >
-        {
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-        // accumulator_wrapper
-        template<typename Accumulator, typename Feature>
-        struct accumulator_wrapper
-          : Accumulator
-        {
-            typedef Feature feature_tag;
-
-            accumulator_wrapper(accumulator_wrapper const &that)
-              : Accumulator(*static_cast<Accumulator const *>(&that))
-            {
-            }
-
-            template<typename Args>
-            accumulator_wrapper(Args const &args)
-              : Accumulator(args)
-            {
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-        // to_accumulator
-        template<typename Feature, typename Sample, typename Weight>
-        struct to_accumulator
-        {
-            typedef
-                accumulator_wrapper<
-                    typename mpl::apply2<typename Feature::impl, Sample, Weight>::type
-                  , Feature
-                >
-            type;
-        };
-
-        template<typename Feature, typename Sample, typename Weight, typename Tag, typename AccumulatorSet>
-        struct to_accumulator<Feature, Sample, tag::external<Weight, Tag, AccumulatorSet> >
-        {
-            BOOST_MPL_ASSERT((is_same<Tag, void>));
-            BOOST_MPL_ASSERT((is_same<AccumulatorSet, void>));
-
-            typedef
-                accumulator_wrapper<
-                    typename mpl::apply2<typename Feature::impl, Sample, Weight>::type
-                  , Feature
-                >
-            accumulator_type;
-
-            typedef
-                typename mpl::if_<
-                    typename Feature::is_weight_accumulator
-                  , accumulator_wrapper<impl::external_impl<accumulator_type, tag::weights>, Feature>
-                  , accumulator_type
-                >::type
-            type;
-        };
-
-        // BUGBUG work around a MPL bug wrt map insertion
-        template<typename FeatureMap, typename Feature>
-        struct insert_feature
-          : mpl::eval_if<
-                mpl::has_key<FeatureMap, typename feature_of<Feature>::type>
-              , mpl::identity<FeatureMap>
-              , mpl::insert<FeatureMap, mpl::pair<typename feature_of<Feature>::type, Feature> >
-            >
-        {
-        };
-
-        template<typename FeatureMap, typename Feature, typename Weight>
-        struct insert_dependencies
-          : mpl::fold<
-                as_feature_list<typename Feature::dependencies, Weight>
-              , FeatureMap
-              , insert_dependencies<
-                    insert_feature<mpl::_1, mpl::_2>
-                  , mpl::_2
-                  , Weight
-                >
-            >
-        {
-        };
-
-        template<typename FeatureMap, typename Features, typename Weight>
-        struct insert_sequence
-          : mpl::fold< // BUGBUG should use insert_range, but doesn't seem to work for maps
-                as_feature_list<Features, Weight>
-              , FeatureMap
-              , insert_feature<mpl::_1, mpl::_2>
-            >
-        {
-        };
-
-        template<typename Features, typename Sample, typename Weight>
-        struct make_accumulator_tuple
-        {
-            typedef
-                typename mpl::fold<
-                    as_feature_list<Features, Weight>
-                  , mpl::map0<>
-                  , mpl::if_<
-                        mpl::is_sequence<mpl::_2>
-                      , insert_sequence<mpl::_1, mpl::_2, Weight>
-                      , insert_feature<mpl::_1, mpl::_2>
-                    >
-                >::type
-            feature_map;
-
-            // for each element in the map, add its dependencies also
-            typedef
-                typename mpl::fold<
-                    feature_map
-                  , feature_map
-                  , insert_dependencies<mpl::_1, mpl::second<mpl::_2>, Weight>
-                >::type
-            feature_map_with_dependencies;
-
-            // turn the map into a vector so we can sort it
-            typedef
-                typename mpl::insert_range<
-                    mpl::vector<>
-                  , mpl::end<mpl::vector<> >::type
-                  , mpl::transform_view<feature_map_with_dependencies, mpl::second<mpl::_1> >
-                >::type
-            feature_vector_with_dependencies;
-
-            // sort the features according to which is derived from which
-            typedef
-                typename mpl::sort<
-                    feature_vector_with_dependencies
-                  , is_dependent_on<mpl::_2, mpl::_1>
-                >::type
-            sorted_feature_vector;
-
-            // From the vector of features, construct a vector of accumulators
-            typedef
-                typename mpl::transform<
-                    sorted_feature_vector
-                  , to_accumulator<mpl::_1, Sample, Weight>
-                >::type
-            type;
-        };
-
-    } // namespace detail
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/external.hpp

@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// external.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_EXTERNAL_HPP_EAN_01_12_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_EXTERNAL_HPP_EAN_01_12_2005
-
-#include <boost/mpl/apply.hpp>
-#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
-
-//namespace boost { namespace accumulators
-//{
-//
-/////////////////////////////////////////////////////////////////////////////////
-//// external
-////
-//template<typename Type>
-//struct external
-//{
-//};
-//
-//}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/extractor.hpp

@@ -1,229 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// extractor.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_EXTRACTOR_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_EXTRACTOR_HPP_EAN_28_10_2005
-
-#include <boost/preprocessor/tuple/rem.hpp>
-#include <boost/preprocessor/array/size.hpp>
-#include <boost/preprocessor/array/data.hpp>
-#include <boost/preprocessor/array/elem.hpp>
-#include <boost/preprocessor/seq/to_array.hpp>
-#include <boost/preprocessor/seq/transform.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#include <boost/parameter/binding.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/accumulators/accumulators_fwd.hpp>
-#include <boost/accumulators/framework/parameters/accumulator.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace detail
-{
-    template<typename AccumulatorSet, typename Feature>
-    struct accumulator_set_result
-    {
-        typedef typename as_feature<Feature>::type feature_type;
-        typedef typename mpl::apply<AccumulatorSet, feature_type>::type::result_type type;
-    };
-
-    template<typename Args, typename Feature>
-    struct argument_pack_result
-      : accumulator_set_result<
-            typename remove_reference<
-                typename parameter::binding<Args, tag::accumulator>::type
-            >::type
-          , Feature
-        >
-    {
-    };
-
-    template<typename A, typename Feature>
-    struct extractor_result
-      : mpl::eval_if<
-            detail::is_accumulator_set<A>
-          , accumulator_set_result<A, Feature>
-          , argument_pack_result<A, Feature>
-        >
-    {
-    };
-
-    template<typename Feature, typename AccumulatorSet>
-    typename extractor_result<AccumulatorSet, Feature>::type
-    do_extract(AccumulatorSet const &acc, mpl::true_)
-    {
-        typedef typename as_feature<Feature>::type feature_type;
-        return extract_result<feature_type>(acc);
-    }
-
-    template<typename Feature, typename Args>
-    typename extractor_result<Args, Feature>::type
-    do_extract(Args const &args, mpl::false_)
-    {
-        typedef typename as_feature<Feature>::type feature_type;
-        return find_accumulator<feature_type>(args[accumulator]).result(args);
-    }
-
-} // namespace detail
-
-
-///////////////////////////////////////////////////////////////////////////////
-/// Extracts the result associated with Feature from the specified accumulator_set.
-template<typename Feature>
-struct extractor
-{
-    typedef extractor<Feature> this_type;
-
-    /// The result meta-function for determining the return type of the extractor
-    template<typename F>
-    struct result;
-
-    template<typename A1>
-    struct result<this_type(A1)>
-      : detail::extractor_result<A1, Feature>
-    {
-    };
-
-    /// Extract the result associated with Feature from the accumulator set
-    /// \param acc The accumulator set object from which to extract the result
-    template<typename Arg1>
-    typename detail::extractor_result<Arg1, Feature>::type
-    operator ()(Arg1 const &arg1) const
-    {
-        // Arg1 could be an accumulator_set or an argument pack containing
-        // an accumulator_set. Dispatch accordingly.
-        return detail::do_extract<Feature>(arg1, detail::is_accumulator_set<Arg1>());
-    }
-
-    /// \overload
-    ///
-    /// \param a1 Optional named parameter to be passed to the accumulator's result() function.
-    template<typename AccumulatorSet, typename A1>
-    typename detail::extractor_result<AccumulatorSet, Feature>::type
-    operator ()(AccumulatorSet const &acc, A1 const &a1) const
-    {
-        BOOST_MPL_ASSERT((detail::is_accumulator_set<AccumulatorSet>));
-        typedef typename as_feature<Feature>::type feature_type;
-        return extract_result<feature_type>(acc, a1);
-    }
-
-    // ... other overloads generated by Boost.Preprocessor:
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_ACCUMULATORS_EXTRACTOR_FUN_OP(z, n, _)                                    \
-    template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                                  \
-    struct result<this_type(BOOST_PP_ENUM_PARAMS_Z(z, n, A))>                           \
-      : detail::extractor_result<A1, Feature>                                           \
-    {};                                                                                 \
-    template<                                                                           \
-        typename AccumulatorSet                                                         \
-        BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A)                               \
-    >                                                                                   \
-    typename detail::extractor_result<AccumulatorSet, Feature>::type                    \
-    operator ()(                                                                        \
-        AccumulatorSet const &acc                                                       \
-        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a)                       \
-    ) const                                                                             \
-    {                                                                                   \
-        BOOST_MPL_ASSERT((detail::is_accumulator_set<AccumulatorSet>));                 \
-        typedef typename as_feature<Feature>::type feature_type;                        \
-        return extract_result<feature_type>(acc BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a));\
-    }
-
-    BOOST_PP_REPEAT_FROM_TO(
-        2
-      , BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
-      , BOOST_ACCUMULATORS_EXTRACTOR_FUN_OP
-      , _
-    )
-
-    #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-    /// \overload
-    ///
-    template<typename AccumulatorSet, typename A1, typename A2, ...>
-    typename detail::extractor_result<AccumulatorSet, Feature>::type
-    operator ()(AccumulatorSet const &acc, A1 const &a1, A2 const &a2, ...);
-    #endif
-};
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_ARRAY_REM(Array)                                                         \
-    BOOST_PP_TUPLE_REM_CTOR(BOOST_PP_ARRAY_SIZE(Array), BOOST_PP_ARRAY_DATA(Array))
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_SEQ_REM(Seq)                                                             \
-    BOOST_ACCUMULATORS_ARRAY_REM(BOOST_PP_SEQ_TO_ARRAY(Seq))
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_ARGS_OP(s, data, elem)                                                   \
-    T ## s
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_PARAMS_OP(s, data, elem)                                                 \
-    elem T ## s
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_MAKE_FEATURE(Tag, Feature, ParamsSeq)                                    \
-    Tag::Feature<                                                                                   \
-        BOOST_ACCUMULATORS_SEQ_REM(                                                                 \
-            BOOST_PP_SEQ_TRANSFORM(BOOST_ACCUMULATORS_ARGS_OP, ~, ParamsSeq)                        \
-        )                                                                                           \
-    >
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN_IMPL(z, n, Tag, Feature, ParamsSeq)                 \
-    template<                                                                                       \
-        BOOST_ACCUMULATORS_SEQ_REM(                                                                 \
-            BOOST_PP_SEQ_TRANSFORM(BOOST_ACCUMULATORS_PARAMS_OP, ~, ParamsSeq)                      \
-        )                                                                                           \
-      , typename Arg1                                                                               \
-        BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A)                                           \
-    >                                                                                               \
-    typename boost::accumulators::detail::extractor_result<                                         \
-        Arg1                                                                                        \
-      , BOOST_ACCUMULATORS_MAKE_FEATURE(Tag, Feature, ParamsSeq)                                    \
-    >::type                                                                                         \
-    Feature(Arg1 const &arg1 BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a) )            \
-    {                                                                                               \
-        typedef BOOST_ACCUMULATORS_MAKE_FEATURE(Tag, Feature, ParamsSeq) feature_type;              \
-        return boost::accumulators::extractor<feature_type>()(                                      \
-            arg1 BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a));                                         \
-    }
-
-/// INTERNAL ONLY
-///
-#define BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN(z, n, _)                                            \
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN_IMPL(                                                   \
-        z                                                                                           \
-      , n                                                                                           \
-      , BOOST_PP_ARRAY_ELEM(0, _)                                                                   \
-      , BOOST_PP_ARRAY_ELEM(1, _)                                                                   \
-      , BOOST_PP_ARRAY_ELEM(2, _)                                                                   \
-    )
-
-#define BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(Tag, Feature, ParamSeq)                                 \
-    BOOST_PP_REPEAT(                                                                                \
-        BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)                                                   \
-      , BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN                                                     \
-      , (3, (Tag, Feature, ParamSeq))                                                               \
-    )
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/features.hpp

@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// features.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_STATS_HPP_EAN_08_12_2005
-#define BOOST_ACCUMULATORS_STATISTICS_STATS_HPP_EAN_08_12_2005
-
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/accumulators/accumulators_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// features
-//
-template<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature)>
-struct features
-  : mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/parameters/accumulator.hpp

@@ -1,20 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// accumulator.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_ACCUMULATOR_HPP_EAN_31_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_ACCUMULATOR_HPP_EAN_31_10_2005
-
-#include <boost/parameter/keyword.hpp>
-
-namespace boost { namespace accumulators
-{
-
-BOOST_PARAMETER_KEYWORD(tag, accumulator)
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/parameters/sample.hpp

@@ -1,20 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// sample.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_SAMPLE_HPP_EAN_31_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_SAMPLE_HPP_EAN_31_10_2005
-
-#include <boost/parameter/keyword.hpp>
-
-namespace boost { namespace accumulators
-{
-
-BOOST_PARAMETER_KEYWORD(tag, sample)
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/parameters/weight.hpp

@@ -1,21 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weight.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHT_HPP_EAN_31_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHT_HPP_EAN_31_10_2005
-
-#include <boost/parameter/keyword.hpp>
-
-namespace boost { namespace accumulators
-{
-
-// The weight of a single sample
-BOOST_PARAMETER_KEYWORD(tag, weight)
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/framework/parameters/weights.hpp

@@ -1,21 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weights.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHTS_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHTS_HPP_EAN_28_10_2005
-
-#include <boost/parameter/keyword.hpp>
-
-namespace boost { namespace accumulators
-{
-
-// The weight accumulator
-BOOST_PARAMETER_KEYWORD(tag, weights)
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/numeric/detail/function1.hpp

@@ -1,75 +0,0 @@
-// Copyright David Abrahams 2006. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_DETAIL_FUNCTION1_DWA200655_HPP
-# define BOOST_DETAIL_FUNCTION1_DWA200655_HPP
-
-# include <boost/concept_check.hpp>
-# include <boost/type_traits/remove_reference.hpp>
-# include <boost/type_traits/add_const.hpp>
-# include <boost/mpl/apply.hpp>
-
-namespace boost { namespace detail {
-
-// A utility for creating unary function objects that play nicely with
-// boost::result_of and that handle the forwarding problem.
-//
-// mpl::apply<F, A0>::type is expected to be a stateless function
-// object that accepts an argument of type A0&.  It is also expected
-// to have a nested ::result_type identical to its return type.
-template<typename F>
-struct function1
-{
-    template<typename Signature>
-    struct result
-    {};
-
-    template<typename This, typename A0>
-    struct result<This(A0)>
-    {
-        // How adding const to arguments handles rvalues.
-        //
-        // if A0 is     arg0 is       represents actual argument
-        // --------     -------       --------------------------
-        // T const &    T const       const T lvalue
-        // T &          T             non-const T lvalue
-        // T const      T const       const T rvalue
-        // T            T const       non-const T rvalue
-        typedef typename remove_reference<
-            typename add_const< A0 >::type
-        >::type arg0;
-
-        typedef typename mpl::apply1<F, arg0>::type impl;
-        typedef typename impl::result_type type;
-    };
-
-    // Handles mutable lvalues
-    template<typename A0>
-    typename result<function1(A0 &)>::type
-    operator ()(A0 &a0) const
-    {
-        typedef typename result<function1(A0 &)>::impl impl;
-        typedef typename result<function1(A0 &)>::type type;
-        typedef A0 &arg0;
-        BOOST_CONCEPT_ASSERT((UnaryFunction<impl, type, arg0>));
-        //boost::function_requires<UnaryFunctionConcept<impl, type, arg0> >();
-        return impl()(a0);
-    }
-
-    // Handles const lvalues and all rvalues
-    template<typename A0>
-    typename result<function1(A0 const &)>::type
-    operator ()(A0 const &a0) const
-    {
-        typedef typename result<function1(A0 const &)>::impl impl;
-        typedef typename result<function1(A0 const &)>::type type;
-        typedef A0 const &arg0;
-        BOOST_CONCEPT_ASSERT((UnaryFunction<impl, type, arg0>));
-        //boost::function_requires<UnaryFunctionConcept<impl, type, arg0> >();
-        return impl()(a0);
-    }
-};
-
-}} // namespace boost::detail
-
-#endif // BOOST_DETAIL_FUNCTION1_DWA200655_HPP

test/external/boost/accumulators/numeric/detail/function2.hpp

@@ -1,10 +0,0 @@
-// Copyright David Abrahams 2006. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_DETAIL_FUNCTION2_DWA200655_HPP
-# define BOOST_DETAIL_FUNCTION2_DWA200655_HPP
-
-# define args (2)
-# include <boost/accumulators/numeric/detail/function_n.hpp>
-
-#endif // BOOST_DETAIL_FUNCTION2_DWA200655_HPP

test/external/boost/accumulators/numeric/detail/function3.hpp

@@ -1,10 +0,0 @@
-// Copyright David Abrahams 2006. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_DETAIL_FUNCTION3_DWA2006514_HPP
-# define BOOST_DETAIL_FUNCTION3_DWA2006514_HPP
-
-# define args (3)
-# include <boost/accumulators/numeric/detail/function_n.hpp>
-
-#endif // BOOST_DETAIL_FUNCTION3_DWA2006514_HPP

test/external/boost/accumulators/numeric/detail/function4.hpp

@@ -1,10 +0,0 @@
-// Copyright David Abrahams 2006. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_DETAIL_FUNCTION4_DWA2006514_HPP
-# define BOOST_DETAIL_FUNCTION4_DWA2006514_HPP
-
-# define args (4)
-# include <boost/accumulators/numeric/detail/function_n.hpp>
-
-#endif // BOOST_DETAIL_FUNCTION4_DWA2006514_HPP

test/external/boost/accumulators/numeric/detail/function_n.hpp

@@ -1,148 +0,0 @@
-// Copyright David Abrahams 2006. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// #include guards intentionally disabled.
-// #ifndef BOOST_DETAIL_FUNCTION_N_DWA2006514_HPP
-// # define BOOST_DETAIL_FUNCTION_N_DWA2006514_HPP
-
-#include <boost/mpl/void.hpp>
-#include <boost/mpl/apply.hpp>
-
-#include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/seq/fold_left.hpp>
-#include <boost/preprocessor/seq/seq.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/seq/for_each_product.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-namespace boost { namespace detail {
-
-# define BOOST_DETAIL_default_arg(z, n, _)                                      \
-    typedef mpl::void_ BOOST_PP_CAT(arg, n);
-
-# define BOOST_DETAIL_function_arg(z, n, _)                                     \
-    typedef typename remove_reference<                                          \
-        typename add_const< BOOST_PP_CAT(A, n) >::type                          \
-    >::type BOOST_PP_CAT(arg, n);
-
-#define BOOST_DETAIL_cat_arg_counts(s, state, n)                                \
-    BOOST_PP_IF(                                                                \
-        n                                                                       \
-      , BOOST_PP_CAT(state, BOOST_PP_CAT(_, n))                                 \
-      , state                                                                   \
-    )                                                                           \
-    /**/
-
-#define function_name                                                           \
-    BOOST_PP_SEQ_FOLD_LEFT(                                                     \
-        BOOST_DETAIL_cat_arg_counts                                             \
-      , BOOST_PP_CAT(function, BOOST_PP_SEQ_HEAD(args))                         \
-      , BOOST_PP_SEQ_TAIL(args)(0)                                              \
-    )                                                                           \
-    /**/
-
-template<typename F>
-struct function_name
-{
-    BOOST_PP_REPEAT(
-        BOOST_MPL_LIMIT_METAFUNCTION_ARITY
-      , BOOST_DETAIL_default_arg
-      , ~
-    )
-
-    template<typename Signature>
-    struct result {};
-
-#define BOOST_DETAIL_function_result(r, _, n)                                   \
-    template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(n, typename A)>        \
-    struct result<This(BOOST_PP_ENUM_PARAMS(n, A))>                             \
-    {                                                                           \
-        BOOST_PP_REPEAT(n, BOOST_DETAIL_function_arg, ~)                        \
-        typedef                                                                 \
-            typename BOOST_PP_CAT(mpl::apply, BOOST_MPL_LIMIT_METAFUNCTION_ARITY)<\
-                F                                                               \
-                BOOST_PP_ENUM_TRAILING_PARAMS(                                  \
-                    BOOST_MPL_LIMIT_METAFUNCTION_ARITY                          \
-                  , arg                                                         \
-                )                                                               \
-            >::type                                                             \
-        impl;                                                                   \
-        typedef typename impl::result_type type;                                \
-    };                                                                          \
-    /**/
-
-    BOOST_PP_SEQ_FOR_EACH(BOOST_DETAIL_function_result, _, args)
-
-# define arg_type(r, _, i, is_const)                                            \
-    BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(A, i) BOOST_PP_CAT(const_if, is_const) &
-
-# define result_(r, n, constness)                                               \
-    typename result<                                                            \
-        function_name(                                                          \
-            BOOST_PP_SEQ_FOR_EACH_I_R(r, arg_type, ~, constness)                \
-        )                                                                       \
-    >                                                                           \
-    /**/
-
-# define param(r, _, i, is_const) BOOST_PP_COMMA_IF(i)                          \
-    BOOST_PP_CAT(A, i) BOOST_PP_CAT(const_if, is_const) & BOOST_PP_CAT(x, i)
-
-# define param_list(r, n, constness)                                            \
-    BOOST_PP_SEQ_FOR_EACH_I_R(r, param, ~, constness)
-
-# define call_operator(r, constness)                                            \
-    template<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(constness), typename A)>    \
-        result_(r, BOOST_PP_SEQ_SIZE(constness), constness)::type               \
-    operator ()( param_list(r, BOOST_PP_SEQ_SIZE(constness), constness) ) const \
-    {                                                                           \
-        typedef result_(r, BOOST_PP_SEQ_SIZE(constness), constness)::impl impl; \
-        return impl()(BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(constness), x));   \
-    }                                                                           \
-    /**/
-
-# define const_if0
-# define const_if1 const
-
-# define bits(z, n, _) ((0)(1))
-
-# define gen_operator(r, _, n)                                                  \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT_R(                                            \
-        r                                                                       \
-      , call_operator                                                           \
-      , BOOST_PP_REPEAT(n, bits, ~)                                             \
-    )                                                                           \
-    /**/
-
-    BOOST_PP_SEQ_FOR_EACH(
-        gen_operator
-      , ~
-      , args
-    )
-
-# undef bits
-# undef const_if1
-# undef const_if0
-# undef call_operator
-# undef param_list
-# undef param
-# undef result_
-# undef default_
-# undef arg_type
-# undef gen_operator
-# undef function_name
-
-# undef args
-};
-
-}} // namespace boost::detail
-
-//#endif // BOOST_DETAIL_FUNCTION_N_DWA2006514_HPP

test/external/boost/accumulators/numeric/detail/pod_singleton.hpp

@@ -1,20 +0,0 @@
-// Copyright David Abrahams 2006. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_DETAIL_POD_SINGLETON_DWA200655_HPP
-# define BOOST_DETAIL_POD_SINGLETON_DWA200655_HPP
-
-namespace boost { namespace detail {
-
-template<typename T>
-struct pod_singleton
-{
-    static T instance;
-};
-
-template<typename T>
-T pod_singleton<T>::instance;
-
-}} // namespace boost::detail
-
-#endif // BOOST_DETAIL_POD_SINGLETON_DWA200655_HPP

test/external/boost/accumulators/numeric/functional.hpp

@@ -1,497 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file functional.hpp
-///
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_NUMERIC_FUNCTIONAL_HPP_EAN_08_12_2005
-#define BOOST_NUMERIC_FUNCTIONAL_HPP_EAN_08_12_2005
-
-#include <limits>
-#include <functional>
-#include <boost/static_assert.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_empty.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/typeof/typeof.hpp>
-#include <boost/accumulators/numeric/functional_fwd.hpp>
-#include <boost/accumulators/numeric/detail/function1.hpp>
-#include <boost/accumulators/numeric/detail/function2.hpp>
-#include <boost/accumulators/numeric/detail/pod_singleton.hpp>
-
-#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT
-# include <boost/accumulators/numeric/functional/vector.hpp>
-#endif
-
-#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT
-# include <boost/accumulators/numeric/functional/valarray.hpp>
-#endif
-
-#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT
-# include <boost/accumulators/numeric/functional/complex.hpp>
-#endif
-
-/// INTERNAL ONLY
-///
-#define BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
-
-#ifdef BOOST_NUMERIC_FUNCTIONAL_DOXYGEN_INVOKED
-// Hack to make Doxygen show the inheritance relationships
-/// INTERNAL ONLY
-///
-namespace std
-{
-    /// INTERNAL ONLY
-    ///
-    template<class Arg, class Ret> struct unary_function {};
-    /// INTERNAL ONLY
-    ///
-    template<class Left, class Right, class Ret> struct binary_function {};
-}
-#endif
-
-namespace boost { namespace numeric
-{
-    namespace functional
-    {
-        /// INTERNAL ONLY
-        ///
-        template<typename A0, typename A1>
-        struct are_integral
-          : mpl::and_<is_integral<A0>, is_integral<A1> >
-        {};
-
-        template<typename Left, typename Right>
-        struct left_ref
-        {
-            typedef Left &type;
-        };
-
-        namespace detail
-        {
-            template<typename T>
-            T &lvalue_of();
-        }
-    }
-
-    // TODO: handle complex weight, valarray, MTL vectors
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(Name, Op)                                      \
-    namespace functional                                                                        \
-    {                                                                                           \
-        template<typename Arg>                                                                  \
-        struct result_of_ ## Name                                                               \
-        {                                                                                       \
-            BOOST_TYPEOF_NESTED_TYPEDEF_TPL(                                                    \
-                nested                                                                          \
-              , Op boost::numeric::functional::detail::lvalue_of<Arg>()                         \
-            )                                                                                   \
-            typedef typename nested::type type;                                                 \
-        };                                                                                      \
-        template<typename Arg, typename EnableIf>                                               \
-        struct Name ## _base                                                                    \
-          : std::unary_function<                                                                \
-                typename remove_const<Arg>::type                                                \
-              , typename result_of_ ## Name<Arg>::type                                          \
-            >                                                                                   \
-        {                                                                                       \
-            typename result_of_ ## Name<Arg>::type operator ()(Arg &arg) const                  \
-            {                                                                                   \
-                return Op arg;                                                                  \
-            }                                                                                   \
-        };                                                                                      \
-        template<typename Arg, typename ArgTag>                                                 \
-        struct Name                                                                             \
-          : Name ## _base<Arg, void>                                                            \
-        {};                                                                                     \
-    }                                                                                           \
-    namespace op                                                                                \
-    {                                                                                           \
-        struct Name                                                                             \
-          : boost::detail::function1<functional::Name<_, functional::tag<_> > >                 \
-        {};                                                                                     \
-    }                                                                                           \
-    namespace                                                                                   \
-    {                                                                                           \
-        op::Name const &Name = boost::detail::pod_singleton<op::Name>::instance;                \
-    }                                                                                           \
-    /**/
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(Name, Op, RetType)                            \
-    namespace functional                                                                        \
-    {                                                                                           \
-        template<typename Left, typename Right, typename EnableIf>                              \
-        struct result_of_ ## Name                                                               \
-        {                                                                                       \
-            RetType(Left, Op, Right)                                                            \
-        };                                                                                      \
-        template<typename Left, typename Right, typename EnableIf>                              \
-        struct Name ## _base                                                                    \
-          : std::binary_function<                                                               \
-                typename remove_const<Left>::type                                               \
-              , typename remove_const<Right>::type                                              \
-              , typename result_of_ ## Name<Left, Right>::type                                  \
-            >                                                                                   \
-        {                                                                                       \
-            typename result_of_ ## Name<Left, Right>::type                                      \
-            operator ()(Left &left, Right &right) const                                         \
-            {                                                                                   \
-                return left Op right;                                                           \
-            }                                                                                   \
-        };                                                                                      \
-        template<typename Left, typename Right, typename LeftTag, typename RightTag>            \
-        struct Name                                                                             \
-          : Name ## _base<Left, Right, void>                                                    \
-        {};                                                                                     \
-    }                                                                                           \
-    namespace op                                                                                \
-    {                                                                                           \
-        struct Name                                                                             \
-          : boost::detail::function2<                                                           \
-                functional::Name<_1, _2, functional::tag<_1>, functional::tag<_2> >             \
-            >                                                                                   \
-        {};                                                                                     \
-    }                                                                                           \
-    namespace                                                                                   \
-    {                                                                                           \
-        op::Name const &Name = boost::detail::pod_singleton<op::Name>::instance;                \
-    }                                                                                           \
-    /**/
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_NUMERIC_FUNCTIONAL_DEDUCED(Left, Op, Right)                                       \
-    BOOST_TYPEOF_NESTED_TYPEDEF_TPL(                                                            \
-        nested                                                                                  \
-      , boost::numeric::functional::detail::lvalue_of<Left>() Op                                \
-        boost::numeric::functional::detail::lvalue_of<Right>()                                  \
-    )                                                                                           \
-    typedef typename nested::type type;                                                         \
-    /**/
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_NUMERIC_FUNCTIONAL_LEFT(Left, Op, Right)                                          \
-    typedef Left &type;                                                                         \
-    /**/
-
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus, +, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus, -, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies, *, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides, /, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus, %, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater, >, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater_equal, >=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less, <, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less_equal, <=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(equal_to, ==, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(not_equal_to, !=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
-
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(assign, =, BOOST_NUMERIC_FUNCTIONAL_LEFT)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus_assign, +=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus_assign, -=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies_assign, *=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides_assign, /=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus_assign, %=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
-
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_plus, +)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_minus, -)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(complement, ~)
-    BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(logical_not, !)
-
-#undef BOOST_NUMERIC_FUNCTIONAL_LEFT
-#undef BOOST_NUMERIC_FUNCTIONAL_DEDUCED
-#undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP
-#undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP
-
-    namespace functional
-    {
-        template<typename Left, typename Right, typename EnableIf>
-        struct min_assign_base
-          : std::binary_function<Left, Right, void>
-        {
-            void operator ()(Left &left, Right &right) const
-            {
-                if(numeric::less(right, left))
-                {
-                    left = right;
-                }
-            }
-        };
-
-        template<typename Left, typename Right, typename EnableIf>
-        struct max_assign_base
-          : std::binary_function<Left, Right, void>
-        {
-            void operator ()(Left &left, Right &right) const
-            {
-                if(numeric::greater(right, left))
-                {
-                    left = right;
-                }
-            }
-        };
-
-        template<typename Left, typename Right, typename EnableIf>
-        struct average_base
-          : functional::divides<Left, Right>
-        {};
-
-        // partial specialization that promotes the arguments to double for
-        // integral division.
-        template<typename Left, typename Right>
-        struct average_base<Left, Right, typename enable_if<are_integral<Left, Right> >::type>
-          : functional::divides<double const, double const>
-        {};
-
-        template<typename To, typename From, typename EnableIf>
-        struct promote_base
-          : std::unary_function<From, To>
-        {
-            To operator ()(From &from) const
-            {
-                return from;
-            }
-        };
-
-        template<typename ToFrom>
-        struct promote_base<ToFrom, ToFrom, void>
-          : std::unary_function<ToFrom, ToFrom>
-        {
-            ToFrom &operator ()(ToFrom &tofrom)
-            {
-                return tofrom;
-            }
-        };
-
-        template<typename Arg, typename EnableIf>
-        struct as_min_base
-          : std::unary_function<Arg, typename remove_const<Arg>::type>
-        {
-            BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
-
-            typename remove_const<Arg>::type operator ()(Arg &) const
-            {
-                return (std::numeric_limits<typename remove_const<Arg>::type>::min)();
-            }
-        };
-
-        template<typename Arg>
-        struct as_min_base<Arg, typename enable_if<is_floating_point<Arg> >::type>
-          : std::unary_function<Arg, typename remove_const<Arg>::type>
-        {
-            BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
-
-            typename remove_const<Arg>::type operator ()(Arg &) const
-            {
-                return -(std::numeric_limits<typename remove_const<Arg>::type>::max)();
-            }
-        };
-
-        template<typename Arg, typename EnableIf>
-        struct as_max_base
-          : std::unary_function<Arg, typename remove_const<Arg>::type>
-        {
-            BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
-
-            typename remove_const<Arg>::type operator ()(Arg &) const
-            {
-                return (std::numeric_limits<typename remove_const<Arg>::type>::max)();
-            }
-        };
-
-        template<typename Arg, typename EnableIf>
-        struct as_zero_base
-          : std::unary_function<Arg, typename remove_const<Arg>::type>
-        {
-            typename remove_const<Arg>::type operator ()(Arg &) const
-            {
-                return numeric::zero<typename remove_const<Arg>::type>::value;
-            }
-        };
-
-        template<typename Arg, typename EnableIf>
-        struct as_one_base
-          : std::unary_function<Arg, typename remove_const<Arg>::type>
-        {
-            typename remove_const<Arg>::type operator ()(Arg &) const
-            {
-                return numeric::one<typename remove_const<Arg>::type>::value;
-            }
-        };
-
-        template<typename To, typename From, typename ToTag, typename FromTag>
-        struct promote
-          : promote_base<To, From, void>
-        {};
-
-        template<typename Left, typename Right, typename LeftTag, typename RightTag>
-        struct min_assign
-          : min_assign_base<Left, Right, void>
-        {};
-
-        template<typename Left, typename Right, typename LeftTag, typename RightTag>
-        struct max_assign
-          : max_assign_base<Left, Right, void>
-        {};
-
-        template<typename Left, typename Right, typename LeftTag, typename RightTag>
-        struct average
-          : average_base<Left, Right, void>
-        {};
-
-        template<typename Arg, typename Tag>
-        struct as_min
-          : as_min_base<Arg, void>
-        {};
-
-        template<typename Arg, typename Tag>
-        struct as_max
-          : as_max_base<Arg, void>
-        {};
-
-        template<typename Arg, typename Tag>
-        struct as_zero
-          : as_zero_base<Arg, void>
-        {};
-
-        template<typename Arg, typename Tag>
-        struct as_one
-          : as_one_base<Arg, void>
-        {};
-    }
-
-    namespace op
-    {
-        template<typename To>
-        struct promote
-          : boost::detail::function1<functional::promote<To, _, typename functional::tag<To>::type, functional::tag<_> > >
-        {};
-
-        struct min_assign
-          : boost::detail::function2<functional::min_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > >
-        {};
-
-        struct max_assign
-          : boost::detail::function2<functional::max_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > >
-        {};
-
-        struct average
-          : boost::detail::function2<functional::average<_1, _2, functional::tag<_1>, functional::tag<_2> > >
-        {};
-
-        struct as_min
-          : boost::detail::function1<functional::as_min<_, functional::tag<_> > >
-        {};
-
-        struct as_max
-          : boost::detail::function1<functional::as_max<_, functional::tag<_> > >
-        {};
-
-        struct as_zero
-          : boost::detail::function1<functional::as_zero<_, functional::tag<_> > >
-        {};
-
-        struct as_one
-          : boost::detail::function1<functional::as_one<_, functional::tag<_> > >
-        {};
-    }
-
-    namespace
-    {
-        op::min_assign const &min_assign = boost::detail::pod_singleton<op::min_assign>::instance;
-        op::max_assign const &max_assign = boost::detail::pod_singleton<op::max_assign>::instance;
-        op::average const &average = boost::detail::pod_singleton<op::average>::instance;
-        op::as_min const &as_min = boost::detail::pod_singleton<op::as_min>::instance;
-        op::as_max const &as_max = boost::detail::pod_singleton<op::as_max>::instance;
-        op::as_zero const &as_zero = boost::detail::pod_singleton<op::as_zero>::instance;
-        op::as_one const &as_one = boost::detail::pod_singleton<op::as_one>::instance;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // promote
-    template<typename To, typename From>
-    typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type
-    promote(From &from)
-    {
-        return functional::promote<To, From>()(from);
-    }
-
-    template<typename To, typename From>
-    typename mpl::if_<is_same<To const, From const>, To const &, To const>::type
-    promote(From const &from)
-    {
-        return functional::promote<To const, From const>()(from);
-    }
-
-    template<typename T>
-    struct default_
-    {
-        typedef default_ type;
-        typedef T value_type;
-        static T const value;
-
-        operator T const & () const
-        {
-            return default_::value;
-        }
-    };
-
-    template<typename T>
-    T const default_<T>::value = T();
-
-    template<typename T>
-    struct one
-    {
-        typedef one type;
-        typedef T value_type;
-        static T const value;
-
-        operator T const & () const
-        {
-            return one::value;
-        }
-    };
-
-    template<typename T>
-    T const one<T>::value = T(1);
-
-    template<typename T>
-    struct zero
-    {
-        typedef zero type;
-        typedef T value_type;
-        static T const value;
-
-        operator T const & () const
-        {
-            return zero::value;
-        }
-    };
-
-    template<typename T>
-    T const zero<T>::value = T();
-
-    template<typename T>
-    struct one_or_default
-      : mpl::if_<is_empty<T>, default_<T>, one<T> >::type
-    {};
-
-    template<typename T>
-    struct zero_or_default
-      : mpl::if_<is_empty<T>, default_<T>, zero<T> >::type
-    {};
-
-}} // namespace boost::numeric
-
-#endif

test/external/boost/accumulators/numeric/functional/complex.hpp

@@ -1,82 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file complex.hpp
-///
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006
-#define BOOST_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006
-
-#ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
-# error Include this file before boost/accumulators/numeric/functional.hpp
-#endif
-
-#include <complex>
-#include <boost/mpl/or.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/typeof/std/complex.hpp>
-#include <boost/accumulators/numeric/functional_fwd.hpp>
-
-namespace boost { namespace numeric { namespace operators
-{
-    // So that the stats compile when Sample type is std::complex
-    template<typename T, typename U>
-    typename
-        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)
-    {
-        // BUGBUG promote result to typeof(T()*u) ?
-        return ri *= static_cast<T>(u);
-    }
-
-    template<typename T, typename U>
-    typename
-        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)
-    {
-        // BUGBUG promote result to typeof(T()*u) ?
-        return ri /= static_cast<T>(u);
-    }
-
-}}} // namespace boost::numeric::operators
-
-namespace boost { namespace numeric
-{
-    namespace detail
-    {
-        template<typename T>
-        struct one_complex
-        {
-            static std::complex<T> const value;
-        };
-
-        template<typename T>
-        std::complex<T> const one_complex<T>::value
-          = std::complex<T>(numeric::one<T>::value, numeric::one<T>::value);
-    }
-
-    /// INTERNAL ONLY
-    ///
-    template<typename T>
-    struct one<std::complex<T> >
-      : detail::one_complex<T>
-    {
-        typedef one type;
-        typedef std::complex<T> value_type;
-        operator value_type const & () const
-        {
-            return detail::one_complex<T>::value;
-        }
-    };
-
-}} // namespace boost::numeric
-
-#endif

test/external/boost/accumulators/numeric/functional/valarray.hpp

@@ -1,360 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file valarray.hpp
-///
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
-#define BOOST_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
-
-#ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
-# error Include this file before boost/accumulators/numeric/functional.hpp
-#endif
-
-#include <valarray>
-#include <functional>
-#include <boost/assert.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/typeof/std/valarray.hpp>
-#include <boost/accumulators/numeric/functional_fwd.hpp>
-
-namespace boost { namespace numeric
-{
-    namespace operators
-    {
-        namespace acc_detail
-        {
-            template<typename Fun>
-            struct make_valarray
-            {
-                typedef std::valarray<typename Fun::result_type> type;
-            };
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle valarray<Left> / Right where Right is a scalar and Right != Left.
-        template<typename Left, typename Right>
-        typename lazy_enable_if<
-            mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
-          , acc_detail::make_valarray<functional::divides<Left, Right> >
-        >::type
-        operator /(std::valarray<Left> const &left, Right const &right)
-        {
-            typedef typename functional::divides<Left, Right>::result_type value_type;
-            std::valarray<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::divides(left[i], right);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle valarray<Left> * Right where Right is a scalar and Right != Left.
-        template<typename Left, typename Right>
-        typename lazy_enable_if<
-            mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
-          , acc_detail::make_valarray<functional::multiplies<Left, Right> >
-        >::type
-        operator *(std::valarray<Left> const &left, Right const &right)
-        {
-            typedef typename functional::multiplies<Left, Right>::result_type value_type;
-            std::valarray<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::multiplies(left[i], right);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle valarray<Left> + valarray<Right> where Right != Left.
-        template<typename Left, typename Right>
-        typename lazy_disable_if<
-            is_same<Left, Right>
-          , acc_detail::make_valarray<functional::plus<Left, Right> >
-        >::type
-        operator +(std::valarray<Left> const &left, std::valarray<Right> const &right)
-        {
-            typedef typename functional::plus<Left, Right>::result_type value_type;
-            std::valarray<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::plus(left[i], right[i]);
-            }
-            return result;
-        }
-    }
-
-    namespace functional
-    {
-        struct std_valarray_tag;
-
-        template<typename T>
-        struct tag<std::valarray<T> >
-        {
-            typedef std_valarray_tag type;
-        };
-
-    #ifdef __GLIBCXX__
-        template<typename T, typename U>
-        struct tag<std::_Expr<T, U> >
-        {
-            typedef std_valarray_tag type;
-        };
-    #endif
-
-        /// INTERNAL ONLY
-        ///
-        // This is necessary because the GCC stdlib uses expression templates, and
-        // typeof(som-valarray-expression) is not an instance of std::valarray
-    #define BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(Name, Op)                   \
-        template<typename Left, typename Right>                                         \
-        struct Name<Left, Right, std_valarray_tag, std_valarray_tag>                    \
-          : std::binary_function<                                                       \
-                Left                                                                    \
-              , Right                                                                   \
-              , std::valarray<                                                          \
-                    typename Name<                                                      \
-                        typename Left::value_type                                       \
-                      , typename Right::value_type                                      \
-                    >::result_type                                                      \
-                >                                                                       \
-            >                                                                           \
-        {                                                                               \
-            typedef typename Left::value_type left_value_type;                          \
-            typedef typename Right::value_type right_value_type;                        \
-            typedef                                                                     \
-                std::valarray<                                                          \
-                    typename Name<left_value_type, right_value_type>::result_type       \
-                >                                                                       \
-            result_type;                                                                \
-            result_type                                                                 \
-            operator ()(Left &left, Right &right) const                                 \
-            {                                                                           \
-                return numeric::promote<std::valarray<left_value_type> >(left)          \
-                    Op numeric::promote<std::valarray<right_value_type> >(right);       \
-            }                                                                           \
-        };                                                                              \
-        template<typename Left, typename Right>                                         \
-        struct Name<Left, Right, std_valarray_tag, void>                                \
-          : std::binary_function<                                                       \
-                Left                                                                    \
-              , Right                                                                   \
-              , std::valarray<                                                          \
-                    typename Name<typename Left::value_type, Right>::result_type        \
-                >                                                                       \
-            >                                                                           \
-        {                                                                               \
-            typedef typename Left::value_type left_value_type;                          \
-            typedef                                                                     \
-                std::valarray<                                                          \
-                    typename Name<left_value_type, Right>::result_type                  \
-                >                                                                       \
-            result_type;                                                                \
-            result_type                                                                 \
-            operator ()(Left &left, Right &right) const                                 \
-            {                                                                           \
-                return numeric::promote<std::valarray<left_value_type> >(left) Op right;\
-            }                                                                           \
-        };                                                                              \
-        template<typename Left, typename Right>                                         \
-        struct Name<Left, Right, void, std_valarray_tag>                                \
-          : std::binary_function<                                                       \
-                Left                                                                    \
-              , Right                                                                   \
-              , std::valarray<                                                          \
-                    typename Name<Left, typename Right::value_type>::result_type        \
-                >                                                                       \
-            >                                                                           \
-        {                                                                               \
-            typedef typename Right::value_type right_value_type;                        \
-            typedef                                                                     \
-                std::valarray<                                                          \
-                    typename Name<Left, right_value_type>::result_type                  \
-                >                                                                       \
-            result_type;                                                                \
-            result_type                                                                 \
-            operator ()(Left &left, Right &right) const                                 \
-            {                                                                           \
-                return left Op numeric::promote<std::valarray<right_value_type> >(right);\
-            }                                                                           \
-        };
-
-        BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(plus, +)
-        BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(minus, -)
-        BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(multiplies, *)
-        BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(divides, /)
-        BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(modulus, %)
-
-    #undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // element-wise min of std::valarray
-        template<typename Left, typename Right>
-        struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>
-          : std::binary_function<Left, Right, void>
-        {
-            void operator ()(Left &left, Right &right) const
-            {
-                BOOST_ASSERT(left.size() == right.size());
-                for(std::size_t i = 0, size = left.size(); i != size; ++i)
-                {
-                    if(numeric::less(right[i], left[i]))
-                    {
-                        left[i] = right[i];
-                    }
-                }
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // element-wise max of std::valarray
-        template<typename Left, typename Right>
-        struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>
-          : std::binary_function<Left, Right, void>
-        {
-            void operator ()(Left &left, Right &right) const
-            {
-                BOOST_ASSERT(left.size() == right.size());
-                for(std::size_t i = 0, size = left.size(); i != size; ++i)
-                {
-                    if(numeric::greater(right[i], left[i]))
-                    {
-                        left[i] = right[i];
-                    }
-                }
-            }
-        };
-
-        // partial specialization of numeric::average<> for std::valarray.
-        template<typename Left, typename Right, typename RightTag>
-        struct average<Left, Right, std_valarray_tag, RightTag>
-          : mpl::if_<
-                are_integral<typename Left::value_type, Right>
-              , divides<Left, double const>
-              , divides<Left, Right>
-            >::type
-        {};
-
-        // promote
-        template<typename To, typename From>
-        struct promote<To, From, std_valarray_tag, std_valarray_tag>
-          : std::unary_function<From, To>
-        {
-            To operator ()(From &arr) const
-            {
-                typename remove_const<To>::type res(arr.size());
-                for(std::size_t i = 0, size = arr.size(); i != size; ++i)
-                {
-                    res[i] = numeric::promote<typename To::value_type>(arr[i]);
-                }
-                return res;
-            }
-        };
-
-        template<typename ToFrom>
-        struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>
-          : std::unary_function<ToFrom, ToFrom>
-        {
-            ToFrom &operator ()(ToFrom &tofrom) const
-            {
-                return tofrom;
-            }
-        };
-
-        // for "promoting" a std::valarray<bool> to a bool, useful for
-        // comparing 2 valarrays for equality:
-        //   if(numeric::promote<bool>(a == b))
-        template<typename From>
-        struct promote<bool, From, void, std_valarray_tag>
-          : std::unary_function<From, bool>
-        {
-            bool operator ()(From &arr) const
-            {
-                BOOST_MPL_ASSERT((is_same<bool, typename From::value_type>));
-                for(std::size_t i = 0, size = arr.size(); i != size; ++i)
-                {
-                    if(!arr[i])
-                    {
-                        return false;
-                    }
-                }
-                return true;
-            }
-        };
-
-        template<typename From>
-        struct promote<bool const, From, void, std_valarray_tag>
-          : promote<bool, From, void, std_valarray_tag>
-        {};
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_min
-        template<typename T>
-        struct as_min<T, std_valarray_tag>
-            : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(numeric::as_min(arr[0]), arr.size());
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_max
-        template<typename T>
-        struct as_max<T, std_valarray_tag>
-          : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(numeric::as_max(arr[0]), arr.size());
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_zero
-        template<typename T>
-        struct as_zero<T, std_valarray_tag>
-          : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(numeric::as_zero(arr[0]), arr.size());
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_one
-        template<typename T>
-        struct as_one<T, std_valarray_tag>
-          : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(numeric::as_one(arr[0]), arr.size());
-            }
-        };
-
-    } // namespace functional
-
-}} // namespace boost::numeric
-
-#endif
-

test/external/boost/accumulators/numeric/functional/vector.hpp

@@ -1,329 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file vector.hpp
-///
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_NUMERIC_FUNCTIONAL_VECTOR_HPP_EAN_12_12_2005
-#define BOOST_NUMERIC_FUNCTIONAL_VECTOR_HPP_EAN_12_12_2005
-
-#ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
-# error Include this file before boost/accumulators/numeric/functional.hpp
-#endif
-
-#include <vector>
-#include <functional>
-#include <boost/assert.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/typeof/std/vector.hpp>
-#include <boost/accumulators/numeric/functional_fwd.hpp>
-
-namespace boost { namespace numeric
-{
-    namespace operators
-    {
-        namespace acc_detail
-        {
-            template<typename Fun>
-            struct make_vector
-            {
-                typedef std::vector<typename Fun::result_type> type;
-            };
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> / Right where Right is a scalar.
-        template<typename Left, typename Right>
-        typename lazy_enable_if<
-            is_scalar<Right>
-          , acc_detail::make_vector<functional::divides<Left, Right> >
-        >::type
-        operator /(std::vector<Left> const &left, Right const &right)
-        {
-            typedef typename functional::divides<Left, Right>::result_type value_type;
-            std::vector<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::divides(left[i], right);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> / vector<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)
-        {
-            typedef typename functional::divides<Left, Right>::result_type value_type;
-            std::vector<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::divides(left[i], right[i]);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> * Right where Right is a scalar.
-        template<typename Left, typename Right>
-        typename lazy_enable_if<
-            is_scalar<Right>
-          , acc_detail::make_vector<functional::multiplies<Left, Right> >
-        >::type
-        operator *(std::vector<Left> const &left, Right const &right)
-        {
-            typedef typename functional::multiplies<Left, Right>::result_type value_type;
-            std::vector<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::multiplies(left[i], right);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle Left * vector<Right> where Left is a scalar.
-        template<typename Left, typename Right>
-        typename lazy_enable_if<
-            is_scalar<Left>
-          , acc_detail::make_vector<functional::multiplies<Left, Right> >
-        >::type
-        operator *(Left const &left, std::vector<Right> const &right)
-        {
-            typedef typename functional::multiplies<Left, Right>::result_type value_type;
-            std::vector<value_type> result(right.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::multiplies(left, right[i]);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> * vector<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)
-        {
-            typedef typename functional::multiplies<Left, Right>::result_type value_type;
-            std::vector<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::multiplies(left[i], right[i]);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> + vector<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)
-        {
-            typedef typename functional::plus<Left, Right>::result_type value_type;
-            std::vector<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::plus(left[i], right[i]);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> - vector<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)
-        {
-            typedef typename functional::minus<Left, Right>::result_type value_type;
-            std::vector<value_type> result(left.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::minus(left[i], right[i]);
-            }
-            return result;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> += vector<Left>
-        template<typename Left>
-        std::vector<Left> &
-        operator +=(std::vector<Left> &left, std::vector<Left> const &right)
-        {
-            BOOST_ASSERT(left.size() == right.size());
-            for(std::size_t i = 0, size = left.size(); i != size; ++i)
-            {
-                numeric::plus_assign(left[i], right[i]);
-            }
-            return left;
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle -vector<Arg>
-        template<typename Arg>
-        std::vector<typename functional::unary_minus<Arg>::result_type>
-        operator -(std::vector<Arg> const &arg)
-        {
-            typedef typename functional::unary_minus<Arg>::result_type value_type;
-            std::vector<value_type> result(arg.size());
-            for(std::size_t i = 0, size = result.size(); i != size; ++i)
-            {
-                result[i] = numeric::unary_minus(arg[i]);
-            }
-            return result;
-        }
-    }
-
-    namespace functional
-    {
-        struct std_vector_tag;
-
-        template<typename T, typename Al>
-        struct tag<std::vector<T, Al> >
-        {
-            typedef std_vector_tag type;
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // element-wise min of std::vector
-        template<typename Left, typename Right>
-        struct min_assign<Left, Right, std_vector_tag, std_vector_tag>
-          : std::binary_function<Left, Right, void>
-        {
-            void operator ()(Left &left, Right &right) const
-            {
-                BOOST_ASSERT(left.size() == right.size());
-                for(std::size_t i = 0, size = left.size(); i != size; ++i)
-                {
-                    if(numeric::less(right[i], left[i]))
-                    {
-                        left[i] = right[i];
-                    }
-                }
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // element-wise max of std::vector
-        template<typename Left, typename Right>
-        struct max_assign<Left, Right, std_vector_tag, std_vector_tag>
-          : std::binary_function<Left, Right, void>
-        {
-            void operator ()(Left &left, Right &right) const
-            {
-                BOOST_ASSERT(left.size() == right.size());
-                for(std::size_t i = 0, size = left.size(); i != size; ++i)
-                {
-                    if(numeric::greater(right[i], left[i]))
-                    {
-                        left[i] = right[i];
-                    }
-                }
-            }
-        };
-
-        // partial specialization for std::vector.
-        template<typename Left, typename Right>
-        struct average<Left, Right, std_vector_tag, void>
-          : mpl::if_<
-                are_integral<typename Left::value_type, Right>
-              , divides<Left, double const>
-              , divides<Left, Right>
-            >::type
-        {};
-
-        // promote
-        template<typename To, typename From>
-        struct promote<To, From, std_vector_tag, std_vector_tag>
-          : std::unary_function<From, To>
-        {
-            To operator ()(From &arr) const
-            {
-                typename remove_const<To>::type res(arr.size());
-                for(std::size_t i = 0, size = arr.size(); i != size; ++i)
-                {
-                    res[i] = numeric::promote<typename To::value_type>(arr[i]);
-                }
-                return res;
-            }
-        };
-
-        template<typename ToFrom>
-        struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>
-          : std::unary_function<ToFrom, ToFrom>
-        {
-            ToFrom &operator ()(ToFrom &tofrom) const
-            {
-                return tofrom;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_min
-        template<typename T>
-        struct as_min<T, std_vector_tag>
-          : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(arr.size(), numeric::as_min(arr[0]));
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_max
-        template<typename T>
-        struct as_max<T, std_vector_tag>
-          : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(arr.size(), numeric::as_max(arr[0]));
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_zero
-        template<typename T>
-        struct as_zero<T, std_vector_tag>
-          : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(arr.size(), numeric::as_zero(arr[0]));
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::as_one
-        template<typename T>
-        struct as_one<T, std_vector_tag>
-          : std::unary_function<T, typename remove_const<T>::type>
-        {
-            typename remove_const<T>::type operator ()(T &arr) const
-            {
-                return 0 == arr.size()
-                  ? T()
-                  : T(arr.size(), numeric::as_one(arr[0]));
-            }
-        };
-
-    } // namespace functional
-
-}} // namespace boost::numeric
-
-#endif
-

test/external/boost/accumulators/numeric/functional_fwd.hpp

@@ -1,221 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file functional_fwd.hpp
-///
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
-#define BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
-
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_const.hpp>
-
-namespace boost { namespace numeric
-{
-    // For using directives -- this namespace may be re-opened elsewhere
-    namespace operators
-    {}
-
-    namespace op
-    {
-        using mpl::_;
-        using mpl::_1;
-        using mpl::_2;
-    }
-
-    namespace functional
-    {
-        using namespace operators;
-
-        template<typename T>
-        struct tag
-        {
-            typedef void type;
-        };
-
-        template<typename T>
-        struct tag<T const>
-          : tag<T>
-        {};
-
-        template<typename T>
-        struct tag<T volatile>
-          : tag<T>
-        {};
-
-        template<typename T>
-        struct tag<T const volatile>
-          : tag<T>
-        {};
-
-        template<typename T>
-        struct static_;
-
-        template<typename A0, typename A1>
-        struct are_integral;
-    }
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(Name, Op)                                     \
-    namespace functional                                                                        \
-    {                                                                                           \
-        template<typename Arg, typename EnableIf = void>                                        \
-        struct Name ## _base;                                                                   \
-        template<typename Arg, typename ArgTag = typename tag<Arg>::type>                       \
-        struct Name;                                                                            \
-    }                                                                                           \
-    namespace op                                                                                \
-    {                                                                                           \
-        struct Name;                                                                            \
-    }                                                                                           \
-    namespace                                                                                   \
-    {                                                                                           \
-        extern op::Name const &Name;                                                            \
-    }
-
-    /// INTERNAL ONLY
-    ///
-#define BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(Name)                                        \
-    namespace functional                                                                        \
-    {                                                                                           \
-        template<typename Left, typename Right, typename EnableIf = void>                       \
-        struct result_of_ ## Name;                                                              \
-        template<typename Left, typename Right, typename EnableIf = void>                       \
-        struct Name ## _base;                                                                   \
-        template<                                                                               \
-            typename Left                                                                       \
-          , typename Right                                                                      \
-          , typename LeftTag = typename tag<Left>::type                                         \
-          , typename RightTag = typename tag<Right>::type                                       \
-        >                                                                                       \
-        struct Name;                                                                            \
-    }                                                                                           \
-    namespace op                                                                                \
-    {                                                                                           \
-        struct Name;                                                                            \
-    }                                                                                           \
-    namespace                                                                                   \
-    {                                                                                           \
-        extern op::Name const &Name;                                                            \
-    }
-
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater_equal)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less_equal)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(equal_to)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(not_equal_to)
-
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(assign)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus_assign)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus_assign)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies_assign)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides_assign)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus_assign)
-
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_plus, +)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_minus, -)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(complement, ~)
-    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(logical_not, !)
-
-#undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP
-#undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP
-
-
-    namespace functional
-    {
-        template<typename To, typename From, typename EnableIf = void>
-        struct promote_base;
-        template<typename Left, typename Right, typename EnableIf = void>
-        struct min_assign_base;
-        template<typename Left, typename Right, typename EnableIf = void>
-        struct max_assign_base;
-        template<typename Left, typename Right, typename EnableIf = void>
-        struct average_base;
-        template<typename Arg, typename EnableIf = void>
-        struct as_min_base;
-        template<typename Arg, typename EnableIf = void>
-        struct as_max_base;
-        template<typename Arg, typename EnableIf = void>
-        struct as_zero_base;
-        template<typename Arg, typename EnableIf = void>
-        struct as_one_base;
-
-        template<typename To, typename From, typename ToTag = typename tag<To>::type, typename FromTag = typename tag<From>::type>
-        struct promote;
-        template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
-        struct min_assign;
-        template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
-        struct max_assign;
-        template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
-        struct average;
-        template<typename Arg, typename Tag = typename tag<Arg>::type>
-        struct as_min;
-        template<typename Arg, typename Tag = typename tag<Arg>::type>
-        struct as_max;
-        template<typename Arg, typename Tag = typename tag<Arg>::type>
-        struct as_zero;
-        template<typename Arg, typename Tag = typename tag<Arg>::type>
-        struct as_one;
-    }
-
-    namespace op
-    {
-        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;
-    }
-
-    namespace
-    {
-        extern op::min_assign const &min_assign;
-        extern op::max_assign const &max_assign;
-        extern op::average const &average;
-        extern op::as_min const &as_min;
-        extern op::as_max const &as_max;
-        extern op::as_zero const &as_zero;
-        extern op::as_one const &as_one;
-    }
-
-    template<typename To, typename From>
-    typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type
-    promote(From &from);
-
-    template<typename To, typename From>
-    typename mpl::if_<is_same<To const, From const>, To const &, To const>::type
-    promote(From const &from);
-
-    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;
-
-}} // namespace boost::numeric
-
-#endif

test/external/boost/accumulators/statistics.hpp

@@ -1,61 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file statistics.hpp
-/// Includes all of the Statistical Accumulators Library
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_HPP_EAN_01_17_2006
-#define BOOST_ACCUMULATORS_STATISTICS_HPP_EAN_01_17_2006
-
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/covariance.hpp>
-#include <boost/accumulators/statistics/density.hpp>
-#include <boost/accumulators/statistics/error_of.hpp>
-#include <boost/accumulators/statistics/error_of_mean.hpp>
-#include <boost/accumulators/statistics/extended_p_square.hpp>
-#include <boost/accumulators/statistics/extended_p_square_quantile.hpp>
-#include <boost/accumulators/statistics/kurtosis.hpp>
-#include <boost/accumulators/statistics/max.hpp>
-#include <boost/accumulators/statistics/mean.hpp>
-#include <boost/accumulators/statistics/median.hpp>
-#include <boost/accumulators/statistics/min.hpp>
-#include <boost/accumulators/statistics/moment.hpp>
-#include <boost/accumulators/statistics/peaks_over_threshold.hpp>
-#include <boost/accumulators/statistics/pot_tail_mean.hpp>
-#include <boost/accumulators/statistics/pot_quantile.hpp>
-#include <boost/accumulators/statistics/p_square_cumulative_distribution.hpp>
-#include <boost/accumulators/statistics/p_square_quantile.hpp>
-#include <boost/accumulators/statistics/skewness.hpp>
-#include <boost/accumulators/statistics/stats.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/sum_kahan.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/tail_quantile.hpp>
-#include <boost/accumulators/statistics/tail_mean.hpp>
-#include <boost/accumulators/statistics/tail_variate.hpp>
-#include <boost/accumulators/statistics/tail_variate_means.hpp>
-#include <boost/accumulators/statistics/variance.hpp>
-#include <boost/accumulators/statistics/weighted_covariance.hpp>
-#include <boost/accumulators/statistics/weighted_density.hpp>
-#include <boost/accumulators/statistics/weighted_kurtosis.hpp>
-#include <boost/accumulators/statistics/weighted_extended_p_square.hpp>
-#include <boost/accumulators/statistics/weighted_mean.hpp>
-#include <boost/accumulators/statistics/weighted_median.hpp>
-#include <boost/accumulators/statistics/weighted_moment.hpp>
-#include <boost/accumulators/statistics/weighted_peaks_over_threshold.hpp>
-#include <boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp>
-#include <boost/accumulators/statistics/weighted_p_square_quantile.hpp>
-#include <boost/accumulators/statistics/weighted_skewness.hpp>
-#include <boost/accumulators/statistics/weighted_sum.hpp>
-#include <boost/accumulators/statistics/weighted_sum_kahan.hpp>
-#include <boost/accumulators/statistics/weighted_tail_quantile.hpp>
-#include <boost/accumulators/statistics/weighted_tail_mean.hpp>
-#include <boost/accumulators/statistics/weighted_tail_variate_means.hpp>
-#include <boost/accumulators/statistics/weighted_variance.hpp>
-#include <boost/accumulators/statistics/with_error.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-#include <boost/accumulators/statistics/variates/covariate.hpp>
-
-#endif

test/external/boost/accumulators/statistics/count.hpp

@@ -1,80 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// count.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_COUNT_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_COUNT_HPP_EAN_28_10_2005
-
-#include <boost/mpl/always.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // count_impl
-    struct count_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef std::size_t result_type;
-
-        count_impl(dont_care)
-          : cnt(0)
-        {
-        }
-
-        void operator ()(dont_care)
-        {
-            ++this->cnt;
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->cnt;
-        }
-
-    private:
-        std::size_t cnt;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::count
-//
-namespace tag
-{
-    struct count
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::count_impl> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::count
-//
-namespace extract
-{
-    extractor<tag::count> const count = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(count)
-}
-
-using extract::count;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/covariance.hpp

@@ -1,220 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// covariance.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_COVARIANCE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_COVARIANCE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <numeric>
-#include <functional>
-#include <complex>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/range.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/numeric/ublas/io.hpp>
-#include <boost/numeric/ublas/matrix.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/mean.hpp>
-
-namespace boost { namespace numeric
-{
-    namespace functional
-    {
-        struct std_vector_tag;
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // functional::outer_product
-        template<typename Left, typename Right, typename EnableIf = void>
-        struct outer_product_base
-          : functional::multiplies<Left, Right>
-        {};
-
-        template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
-        struct outer_product
-          : outer_product_base<Left, Right, void>
-        {};
-
-        template<typename Left, typename Right>
-        struct outer_product<Left, Right, std_vector_tag, std_vector_tag>
-          : std::binary_function<
-                Left
-              , Right
-              , ublas::matrix<
-                    typename functional::multiplies<
-                        typename Left::value_type
-                      , typename Right::value_type
-                    >::result_type
-                >
-            >
-        {
-            typedef
-                ublas::matrix<
-                    typename functional::multiplies<
-                        typename Left::value_type
-                      , typename Right::value_type
-                    >::result_type
-                >
-            result_type;
-
-            result_type
-            operator ()(Left & left, Right & right) const
-            {
-                std::size_t left_size = left.size();
-                std::size_t right_size = right.size();
-                result_type result(left_size, right_size);
-                for (std::size_t i = 0; i < left_size; ++i)
-                    for (std::size_t j = 0; j < right_size; ++j)
-                        result(i,j) = numeric::multiplies(left[i], right[j]);
-                return result;
-            }
-        };
-    }
-
-    namespace op
-    {
-        struct outer_product
-          : boost::detail::function2<functional::outer_product<_1, _2, functional::tag<_1>, functional::tag<_2> > >
-        {};
-    }
-
-    namespace
-    {
-        op::outer_product const &outer_product = boost::detail::pod_singleton<op::outer_product>::instance;
-    }
-
-}}
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // covariance_impl
-    //
-    /**
-        @brief Covariance Estimator
-
-        An iterative Monte Carlo estimator for the covariance \f$\mathrm{Cov}(X,X')\f$, where \f$X\f$ is a sample
-        and \f$X'\f$ is a variate, is given by:
-
-        \f[
-            \hat{c}_n = \frac{n-1}{n} \hat{c}_{n-1} + \frac{1}{n-1}(X_n - \hat{\mu}_n)(X_n' - \hat{\mu}_n'),\quad n\ge2,\quad\hat{c}_1 = 0,
-        \f]
-
-        \f$\hat{\mu}_n\f$ and \f$\hat{\mu}_n'\f$ being the means of the samples and variates.
-    */
-    template<typename Sample, typename VariateType, typename VariateTag>
-    struct covariance_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type sample_type;
-        typedef typename numeric::functional::average<VariateType, std::size_t>::result_type variate_type;
-        // for boost::result_of
-        typedef typename numeric::functional::outer_product<sample_type, variate_type>::result_type result_type;
-
-        template<typename Args>
-        covariance_impl(Args const &args)
-          : cov_(
-                numeric::outer_product(
-                    numeric::average(args[sample | Sample()], (std::size_t)1)
-                  , numeric::average(args[parameter::keyword<VariateTag>::get() | VariateType()], (std::size_t)1)
-                )
-            )
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-
-            if (cnt > 1)
-            {
-                extractor<tag::mean_of_variates<VariateType, VariateTag> > const some_mean_of_variates = {};
-
-                this->cov_ = this->cov_*(cnt-1.)/cnt
-                           + numeric::outer_product(
-                                 some_mean_of_variates(args) - args[parameter::keyword<VariateTag>::get()]
-                               , mean(args) - args[sample]
-                             ) / (cnt-1.);
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->cov_;
-        }
-
-    private:
-        result_type cov_;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::covariance
-//
-namespace tag
-{
-    template<typename VariateType, typename VariateTag>
-    struct covariance
-      : depends_on<count, mean, mean_of_variates<VariateType, VariateTag> >
-    {
-        typedef accumulators::impl::covariance_impl<mpl::_1, VariateType, VariateTag> impl;
-    };
-
-    struct abstract_covariance
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::covariance
-//
-namespace extract
-{
-    extractor<tag::abstract_covariance> const covariance = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(covariance)
-}
-
-using extract::covariance;
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::covariance<VariateType, VariateTag> >
-  : feature_of<tag::abstract_covariance>
-{
-};
-
-// So that covariance can be automatically substituted with
-// weighted_covariance when the weight parameter is non-void.
-template<typename VariateType, typename VariateTag>
-struct as_weighted_feature<tag::covariance<VariateType, VariateTag> >
-{
-    typedef tag::weighted_covariance<VariateType, VariateTag> type;
-};
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::weighted_covariance<VariateType, VariateTag> >
-  : feature_of<tag::covariance<VariateType, VariateTag> >
-{};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/density.hpp

@@ -1,246 +0,0 @@
-
-///////////////////////////////////////////////////////////////////////////////
-// density.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_DENSITY_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_DENSITY_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <functional>
-#include <boost/range.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/max.hpp>
-#include <boost/accumulators/statistics/min.hpp>
-
-namespace boost { namespace accumulators
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// cache_size and num_bins named parameters
-//
-BOOST_PARAMETER_NESTED_KEYWORD(tag, density_cache_size, cache_size)
-BOOST_PARAMETER_NESTED_KEYWORD(tag, density_num_bins, num_bins)
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // density_impl
-    //  density histogram
-    /**
-        @brief Histogram density estimator
-
-        The histogram density estimator returns a histogram of the sample distribution. The positions and sizes of the bins
-        are determined using a specifiable number of cached samples (cache_size). The range between the minimum and the
-        maximum of the cached samples is subdivided into a specifiable number of bins (num_bins) of same size. Additionally,
-        an under- and an overflow bin is added to capture future under- and overflow samples. Once the bins are determined,
-        the cached samples and all subsequent samples are added to the correct bins. At the end, a range of std::pair is
-        return, where each pair contains the position of the bin (lower bound) and the samples count (normalized with the
-        total number of samples).
-
-        @param  density_cache_size Number of first samples used to determine min and max.
-        @param  density_num_bins Number of bins (two additional bins collect under- and overflow samples).
-    */
-    template<typename Sample>
-    struct density_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        typedef std::vector<float_type> array_type;
-        // for boost::result_of
-        typedef iterator_range<typename histogram_type::iterator> result_type;
-
-        template<typename Args>
-        density_impl(Args const &args)
-            : cache_size(args[density_cache_size])
-            , cache(cache_size)
-            , num_bins(args[density_num_bins])
-            , samples_in_bin(num_bins + 2, 0.)
-            , bin_positions(num_bins + 2)
-            , histogram(
-                num_bins + 2
-              , std::make_pair(
-                    numeric::average(args[sample | Sample()],(std::size_t)1)
-                  , numeric::average(args[sample | Sample()],(std::size_t)1)
-                )
-              )
-            , is_dirty(true)
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->is_dirty = true;
-
-            std::size_t cnt = count(args);
-
-            // Fill up cache with cache_size first samples
-            if (cnt <= this->cache_size)
-            {
-                this->cache[cnt - 1] = args[sample];
-            }
-
-            // Once cache_size samples have been accumulated, create num_bins bins of same size between
-            // the minimum and maximum of the cached samples as well as an under- and and an overflow bin.
-            // Store their lower bounds (bin_positions) and fill the bins with the cached samples (samples_in_bin).
-            if (cnt == this->cache_size)
-            {
-                float_type minimum = numeric::average((min)(args), (std::size_t)1);
-                float_type maximum = numeric::average((max)(args), (std::size_t)1);
-                float_type bin_size = numeric::average(maximum - minimum, this->num_bins );
-
-                // determine bin positions (their lower bounds)
-                for (std::size_t i = 0; i < this->num_bins + 2; ++i)
-                {
-                    this->bin_positions[i] = minimum + (i - 1.) * bin_size;
-                }
-
-                for (typename array_type::const_iterator iter = this->cache.begin(); iter != this->cache.end(); ++iter)
-                {
-                    if (*iter < this->bin_positions[1])
-                    {
-                        ++(this->samples_in_bin[0]);
-                    }
-                    else if (*iter >= this->bin_positions[this->num_bins + 1])
-                    {
-                        ++(this->samples_in_bin[this->num_bins + 1]);
-                    }
-                    else
-                    {
-                        typename array_type::iterator it = std::upper_bound(
-                            this->bin_positions.begin()
-                          , this->bin_positions.end()
-                          , *iter
-                        );
-
-                        std::size_t d = std::distance(this->bin_positions.begin(), it);
-                        ++(this->samples_in_bin[d - 1]);
-                    }
-                }
-            }
-            // Add each subsequent sample to the correct bin
-            else if (cnt > this->cache_size)
-            {
-                if (args[sample] < this->bin_positions[1])
-                {
-                    ++(this->samples_in_bin[0]);
-                }
-                else if (args[sample] >= this->bin_positions[this->num_bins + 1])
-                {
-                    ++(this->samples_in_bin[this->num_bins + 1]);
-                }
-                else
-                {
-                    typename array_type::iterator it = std::upper_bound(
-                        this->bin_positions.begin()
-                      , this->bin_positions.end()
-                      , args[sample]
-                    );
-
-                    std::size_t d = std::distance(this->bin_positions.begin(), it);
-                    ++(this->samples_in_bin[d - 1]);
-                }
-            }
-        }
-
-        /**
-            @pre The number of samples must meet or exceed the cache size
-        */
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                // creates a vector of std::pair where each pair i holds
-                // the values bin_positions[i] (x-axis of histogram) and
-                // samples_in_bin[i] / cnt (y-axis of histogram).
-
-                for (std::size_t i = 0; i < this->num_bins + 2; ++i)
-                {
-                    this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::average(this->samples_in_bin[i], count(args)));
-                }
-            }
-            // returns a range of pairs
-            return make_iterator_range(this->histogram);
-        }
-
-    private:
-        std::size_t            cache_size;      // number of cached samples
-        array_type             cache;           // cache to store the first cache_size samples
-        std::size_t            num_bins;        // number of bins
-        array_type             samples_in_bin;  // number of samples in each bin
-        array_type             bin_positions;   // lower bounds of bins
-        mutable histogram_type histogram;       // histogram
-        mutable bool is_dirty;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::density
-//
-namespace tag
-{
-    struct density
-      : depends_on<count, min, max>
-      , density_cache_size
-      , density_num_bins
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::density_impl<mpl::_1> impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::density::cache_size named parameter
-        /// tag::density::num_bins named parameter
-        static boost::parameter::keyword<density_cache_size> const cache_size;
-        static boost::parameter::keyword<density_num_bins> const num_bins;
-        #endif
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::density
-//
-namespace extract
-{
-    extractor<tag::density> const density = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(density)
-}
-
-using extract::density;
-
-// So that density can be automatically substituted
-// with weighted_density when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::density>
-{
-    typedef tag::weighted_density type;
-};
-
-template<>
-struct feature_of<tag::weighted_density>
-  : feature_of<tag::density>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/error_of.hpp

@@ -1,99 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// error_of.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_ERROR_OF_HPP_EAN_29_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_ERROR_OF_HPP_EAN_29_11_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    /// INTERNAL ONLY
-    ///
-    template<typename Feature>
-    struct this_feature_has_no_error_calculation
-      : mpl::false_
-    {
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // error_of_impl
-    /// INTERNAL ONLY
-    ///
-    template<typename Sample, typename Feature>
-    struct error_of_impl
-      : accumulator_base
-    {
-        // TODO: specialize this on the specific features that have errors we're
-        // interested in.
-        BOOST_MPL_ASSERT((this_feature_has_no_error_calculation<Feature>));
-
-        // for boost::result_of
-        typedef int result_type;
-
-        error_of_impl(dont_care)
-        {
-        }
-
-        result_type result(dont_care) const
-        {
-            return 0;
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::error_of
-//
-namespace tag
-{
-    template<typename Feature>
-    struct error_of
-      : depends_on<Feature>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::error_of_impl<mpl::_1, Feature> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::error_of
-//
-namespace extract
-{
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, error_of, (typename))
-}
-
-using extract::error_of;
-
-// make tag::error_of<tag::feature(modifier)> work
-template<typename Feature>
-struct as_feature<tag::error_of<Feature> >
-{
-    typedef tag::error_of<typename as_feature<Feature>::type> type;
-};
-
-// make error_of<tag::mean> work with non-void weights (should become
-// error_of<tag::weighted_mean>
-template<typename Feature>
-struct as_weighted_feature<tag::error_of<Feature> >
-{
-    typedef tag::error_of<typename as_weighted_feature<Feature>::type> type;
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/error_of_mean.hpp

@@ -1,73 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// error_of.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_ERROR_OF_MEAN_HPP_EAN_27_03_2006
-#define BOOST_ACCUMULATORS_STATISTICS_ERROR_OF_MEAN_HPP_EAN_27_03_2006
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/error_of.hpp>
-#include <boost/accumulators/statistics/variance.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // error_of_mean_impl
-    template<typename Sample, typename Variance>
-    struct error_of_mean_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        error_of_mean_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            using namespace std;
-            extractor<Variance> const variance = {};
-            return sqrt(numeric::average(variance(args), count(args) - 1));
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::error_of
-//
-namespace tag
-{
-    template<>
-    struct error_of<mean>
-      : depends_on<lazy_variance, count>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::error_of_mean_impl<mpl::_1, lazy_variance> impl;
-    };
-
-    template<>
-    struct error_of<immediate_mean>
-      : depends_on<variance, count>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::error_of_mean_impl<mpl::_1, variance> impl;
-    };
-}
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/extended_p_square.hpp

@@ -1,293 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// extended_p_square.hpp
-//
-//  Copyright 2005 Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_EXTENDED_SINGLE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_EXTENDED_SINGLE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <functional>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/iterator/counting_iterator.hpp>
-#include <boost/iterator/permutation_iterator.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/times2_iterator.hpp>
-
-namespace boost { namespace accumulators
-{
-///////////////////////////////////////////////////////////////////////////////
-// probabilities named parameter
-//
-BOOST_PARAMETER_NESTED_KEYWORD(tag, extended_p_square_probabilities, probabilities)
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // extended_p_square_impl
-    //  multiple quantile estimation
-    /**
-        @brief Multiple quantile estimation with the extended \f$P^2\f$ algorithm
-
-        Extended \f$P^2\f$ algorithm for estimation of several quantiles without storing samples.
-        Assume that \f$m\f$ quantiles \f$\xi_{p_1}, \ldots, \xi_{p_m}\f$ are to be estimated.
-        Instead of storing the whole sample cumulative distribution, the algorithm maintains only
-        \f$m+2\f$ principal markers and \f$m+1\f$ middle markers, whose positions are updated
-        with each sample and whose heights are adjusted (if necessary) using a piecewise-parablic
-        formula. The heights of these central markers are the current estimates of the quantiles
-        and returned as an iterator range.
-
-        For further details, see
-
-        K. E. E. Raatikainen, Simultaneous estimation of several quantiles, Simulation, Volume 49,
-        Number 4 (October), 1986, p. 159-164.
-
-        The extended \f$ P^2 \f$ algorithm generalizess the \f$ P^2 \f$ algorithm of
-
-        R. Jain and I. Chlamtac, The P^2 algorithmus for dynamic calculation of quantiles and
-        histograms without storing observations, Communications of the ACM,
-        Volume 28 (October), Number 10, 1985, p. 1076-1085.
-
-        @param extended_p_square_probabilities A vector of quantile probabilities.
-    */
-    template<typename Sample>
-    struct extended_p_square_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<float_type> array_type;
-        // for boost::result_of
-        typedef iterator_range<
-            detail::lvalue_index_iterator<
-                permutation_iterator<
-                    typename array_type::const_iterator
-                  , detail::times2_iterator
-                >
-            >
-        > result_type;
-
-        template<typename Args>
-        extended_p_square_impl(Args const &args)
-          : probabilities(
-                boost::begin(args[extended_p_square_probabilities])
-              , boost::end(args[extended_p_square_probabilities])
-            )
-          , heights(2 * probabilities.size() + 3)
-          , actual_positions(heights.size())
-          , desired_positions(heights.size())
-          , positions_increments(heights.size())
-        {
-            std::size_t num_quantiles = this->probabilities.size();
-            std::size_t num_markers = this->heights.size();
-
-            for(std::size_t i = 0; i < num_markers; ++i)
-            {
-                this->actual_positions[i] = i + 1;
-            }
-
-            this->positions_increments[0] = 0.;
-            this->positions_increments[num_markers - 1] = 1.;
-
-            for(std::size_t i = 0; i < num_quantiles; ++i)
-            {
-                this->positions_increments[2 * i + 2] = probabilities[i];
-            }
-
-            for(std::size_t i = 0; i <= num_quantiles; ++i)
-            {
-                this->positions_increments[2 * i + 1] =
-                    0.5 * (this->positions_increments[2 * i] + this->positions_increments[2 * i + 2]);
-            }
-
-            for(std::size_t i = 0; i < num_markers; ++i)
-            {
-                this->desired_positions[i] = 1. + 2. * (num_quantiles + 1.) * this->positions_increments[i];
-            }
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-
-            // m+2 principal markers and m+1 middle markers
-            std::size_t num_markers = 2 * this->probabilities.size() + 3;
-
-            // first accumulate num_markers samples
-            if(cnt <= num_markers)
-            {
-                this->heights[cnt - 1] = args[sample];
-
-                // complete the initialization of heights by sorting
-                if(cnt == num_markers)
-                {
-                    std::sort(this->heights.begin(), this->heights.end());
-                }
-            }
-            else
-            {
-                std::size_t sample_cell = 1;
-
-                // find cell k = sample_cell such that heights[k-1] <= sample < heights[k]
-                if(args[sample] < this->heights[0])
-                {
-                    this->heights[0] = args[sample];
-                    sample_cell = 1;
-                }
-                else if(args[sample] >= this->heights[num_markers - 1])
-                {
-                    this->heights[num_markers - 1] = args[sample];
-                    sample_cell = num_markers - 1;
-                }
-                else
-                {
-                    typedef typename array_type::iterator iterator;
-                    iterator it = std::upper_bound(
-                        this->heights.begin()
-                      , this->heights.end()
-                      , args[sample]
-                    );
-
-                    sample_cell = std::distance(this->heights.begin(), it);
-                }
-
-                // update actual positions of all markers above sample_cell index
-                for(std::size_t i = sample_cell; i < num_markers; ++i)
-                {
-                    ++this->actual_positions[i];
-                }
-
-                // update desired positions of all markers
-                for(std::size_t i = 0; i < num_markers; ++i)
-                {
-                    this->desired_positions[i] += this->positions_increments[i];
-                }
-
-                // adjust heights and actual positions of markers 1 to num_markers-2 if necessary
-                for(std::size_t i = 1; i <= num_markers - 2; ++i)
-                {
-                    // offset to desired position
-                    float_type d = this->desired_positions[i] - this->actual_positions[i];
-
-                    // offset to next position
-                    float_type dp = this->actual_positions[i+1] - this->actual_positions[i];
-
-                    // offset to previous position
-                    float_type dm = this->actual_positions[i-1] - this->actual_positions[i];
-
-                    // height ds
-                    float_type hp = (this->heights[i+1] - this->heights[i]) / dp;
-                    float_type hm = (this->heights[i-1] - this->heights[i]) / dm;
-
-                    if((d >= 1 && dp > 1) || (d <= -1 && dm < -1))
-                    {
-                        short sign_d = static_cast<short>(d / std::abs(d));
-
-                        float_type h = this->heights[i] + sign_d / (dp - dm) * ((sign_d - dm)*hp
-                                     + (dp - sign_d) * hm);
-
-                        // try adjusting heights[i] using p-squared formula
-                        if(this->heights[i - 1] < h && h < this->heights[i + 1])
-                        {
-                            this->heights[i] = h;
-                        }
-                        else
-                        {
-                            // use linear formula
-                            if(d > 0)
-                            {
-                                this->heights[i] += hp;
-                            }
-                            if(d < 0)
-                            {
-                                this->heights[i] -= hm;
-                            }
-                        }
-                        this->actual_positions[i] += sign_d;
-                    }
-                }
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            // for i in [1,probabilities.size()], return heights[i * 2]
-            detail::times2_iterator idx_begin = detail::make_times2_iterator(1);
-            detail::times2_iterator idx_end = detail::make_times2_iterator(this->probabilities.size() + 1);
-
-            return result_type(
-                make_permutation_iterator(this->heights.begin(), idx_begin)
-              , make_permutation_iterator(this->heights.begin(), idx_end)
-            );
-        }
-
-    private:
-        array_type probabilities;         // the quantile probabilities
-        array_type heights;               // q_i
-        array_type actual_positions;      // n_i
-        array_type desired_positions;     // d_i
-        array_type positions_increments;  // f_i
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::extended_p_square
-//
-namespace tag
-{
-    struct extended_p_square
-      : depends_on<count>
-      , extended_p_square_probabilities
-    {
-        typedef accumulators::impl::extended_p_square_impl<mpl::_1> impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::extended_p_square::probabilities named paramter
-        static boost::parameter::keyword<tag::probabilities> const probabilities;
-        #endif
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::extended_p_square
-//
-namespace extract
-{
-    extractor<tag::extended_p_square> const extended_p_square = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(extended_p_square)
-}
-
-using extract::extended_p_square;
-
-// So that extended_p_square can be automatically substituted with
-// weighted_extended_p_square when the weight parameter is non-void
-template<>
-struct as_weighted_feature<tag::extended_p_square>
-{
-    typedef tag::weighted_extended_p_square type;
-};
-
-template<>
-struct feature_of<tag::weighted_extended_p_square>
-  : feature_of<tag::extended_p_square>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/extended_p_square_quantile.hpp

@@ -1,319 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// extended_p_square_quantile.hpp
-//
-//  Copyright 2005 Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_EXTENDED_SINGLE_QUANTILE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_EXTENDED_SINGLE_QUANTILE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <functional>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/iterator/counting_iterator.hpp>
-#include <boost/iterator/permutation_iterator.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-#include <boost/accumulators/statistics/extended_p_square.hpp>
-#include <boost/accumulators/statistics/weighted_extended_p_square.hpp>
-#include <boost/accumulators/statistics/times2_iterator.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // extended_p_square_quantile_impl
-    //  single quantile estimation
-    /**
-        @brief Quantile estimation using the extended \f$P^2\f$ algorithm for weighted and unweighted samples
-
-        Uses the quantile estimates calculated by the extended \f$P^2\f$ algorithm to compute
-        intermediate quantile estimates by means of quadratic interpolation.
-
-        @param quantile_probability The probability of the quantile to be estimated.
-    */
-    template<typename Sample, typename Impl1, typename Impl2> // Impl1: weighted/unweighted // Impl2: linear/quadratic
-    struct extended_p_square_quantile_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<float_type> array_type;
-        typedef iterator_range<
-            detail::lvalue_index_iterator<
-                permutation_iterator<
-                    typename array_type::const_iterator
-                  , detail::times2_iterator
-                >
-            >
-        > range_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        template<typename Args>
-        extended_p_square_quantile_impl(Args const &args)
-          : probabilities(
-                boost::begin(args[extended_p_square_probabilities])
-              , boost::end(args[extended_p_square_probabilities])
-            )
-        {
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            typedef
-                typename mpl::if_<
-                    is_same<Impl1, weighted>
-                  , tag::weighted_extended_p_square
-                  , tag::extended_p_square
-                >::type
-            extended_p_square_tag;
-
-            extractor<extended_p_square_tag> const some_extended_p_square = {};
-
-            array_type heights(some_extended_p_square(args).size());
-            std::copy(some_extended_p_square(args).begin(), some_extended_p_square(args).end(), heights.begin());
-
-            this->probability = args[quantile_probability];
-
-            typename array_type::const_iterator iter_probs = std::lower_bound(this->probabilities.begin(), this->probabilities.end(), this->probability);
-            std::size_t dist = std::distance(this->probabilities.begin(), iter_probs);
-            typename array_type::const_iterator iter_heights = heights.begin() + dist;
-
-            // If this->probability is not in a valid range return NaN or throw exception
-            if (this->probability < *this->probabilities.begin() || this->probability > *(this->probabilities.end() - 1))
-            {
-                if (std::numeric_limits<result_type>::has_quiet_NaN)
-                {
-                    return std::numeric_limits<result_type>::quiet_NaN();
-                }
-                else
-                {
-                    std::ostringstream msg;
-                    msg << "probability = " << this->probability << " is not in valid range (";
-                    msg << *this->probabilities.begin() << ", " << *(this->probabilities.end() - 1) << ")";
-                    boost::throw_exception(std::runtime_error(msg.str()));
-                    return Sample(0);
-                }
-
-            }
-
-            if (*iter_probs == this->probability)
-            {
-                return heights[dist];
-            }
-            else
-            {
-                result_type res;
-
-                if (is_same<Impl2, linear>::value)
-                {
-                    /////////////////////////////////////////////////////////////////////////////////
-                    // LINEAR INTERPOLATION
-                    //
-                    float_type p1 = *iter_probs;
-                    float_type p0 = *(iter_probs - 1);
-                    float_type h1 = *iter_heights;
-                    float_type h0 = *(iter_heights - 1);
-
-                    float_type a = numeric::average(h1 - h0, p1 - p0);
-                    float_type b = h1 - p1 * a;
-
-                    res = a * this->probability + b;
-                }
-                else
-                {
-                    /////////////////////////////////////////////////////////////////////////////////
-                    // QUADRATIC INTERPOLATION
-                    //
-                    float_type p0, p1, p2;
-                    float_type h0, h1, h2;
-
-                    if ( (dist == 1 || *iter_probs - this->probability <= this->probability - *(iter_probs - 1) ) && dist != this->probabilities.size() - 1 )
-                    {
-                        p0 = *(iter_probs - 1);
-                        p1 = *iter_probs;
-                        p2 = *(iter_probs + 1);
-                        h0 = *(iter_heights - 1);
-                        h1 = *iter_heights;
-                        h2 = *(iter_heights + 1);
-                    }
-                    else
-                    {
-                        p0 = *(iter_probs - 2);
-                        p1 = *(iter_probs - 1);
-                        p2 = *iter_probs;
-                        h0 = *(iter_heights - 2);
-                        h1 = *(iter_heights - 1);
-                        h2 = *iter_heights;
-                    }
-
-                    float_type hp21 = numeric::average(h2 - h1, p2 - p1);
-                    float_type hp10 = numeric::average(h1 - h0, p1 - p0);
-                    float_type p21  = numeric::average(p2 * p2 - p1 * p1, p2 - p1);
-                    float_type p10  = numeric::average(p1 * p1 - p0 * p0, p1 - p0);
-
-                    float_type a = numeric::average(hp21 - hp10, p21 - p10);
-                    float_type b = hp21 - a * p21;
-                    float_type c = h2 - a * p2 * p2 - b * p2;
-
-                    res = a * this->probability * this-> probability + b * this->probability + c;
-                }
-
-                return res;
-            }
-
-        }
-    private:
-
-        array_type probabilities;
-        mutable float_type probability;
-
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::extended_p_square_quantile
-//
-namespace tag
-{
-    struct extended_p_square_quantile
-      : depends_on<extended_p_square>
-    {
-        typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, unweighted, linear> impl;
-    };
-    struct extended_p_square_quantile_quadratic
-      : depends_on<extended_p_square>
-    {
-        typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, unweighted, quadratic> impl;
-    };
-    struct weighted_extended_p_square_quantile
-      : depends_on<weighted_extended_p_square>
-    {
-        typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, weighted, linear> impl;
-    };
-    struct weighted_extended_p_square_quantile_quadratic
-      : depends_on<weighted_extended_p_square>
-    {
-        typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, weighted, quadratic> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::extended_p_square_quantile
-// extract::weighted_extended_p_square_quantile
-//
-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 = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(extended_p_square_quantile)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(extended_p_square_quantile_quadratic)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_extended_p_square_quantile)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_extended_p_square_quantile_quadratic)
-}
-
-using extract::extended_p_square_quantile;
-using extract::extended_p_square_quantile_quadratic;
-using extract::weighted_extended_p_square_quantile;
-using extract::weighted_extended_p_square_quantile_quadratic;
-
-// extended_p_square_quantile(linear) -> extended_p_square_quantile
-template<>
-struct as_feature<tag::extended_p_square_quantile(linear)>
-{
-    typedef tag::extended_p_square_quantile type;
-};
-
-// extended_p_square_quantile(quadratic) -> extended_p_square_quantile_quadratic
-template<>
-struct as_feature<tag::extended_p_square_quantile(quadratic)>
-{
-    typedef tag::extended_p_square_quantile_quadratic type;
-};
-
-// weighted_extended_p_square_quantile(linear) -> weighted_extended_p_square_quantile
-template<>
-struct as_feature<tag::weighted_extended_p_square_quantile(linear)>
-{
-    typedef tag::weighted_extended_p_square_quantile type;
-};
-
-// weighted_extended_p_square_quantile(quadratic) -> weighted_extended_p_square_quantile_quadratic
-template<>
-struct as_feature<tag::weighted_extended_p_square_quantile(quadratic)>
-{
-    typedef tag::weighted_extended_p_square_quantile_quadratic type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// extended_p_square_quantile and weighted_extended_p_square_quantile
-// provide the same feature as quantile
-template<>
-struct feature_of<tag::extended_p_square_quantile>
-  : feature_of<tag::quantile>
-{
-};
-template<>
-struct feature_of<tag::extended_p_square_quantile_quadratic>
-  : feature_of<tag::quantile>
-{
-};
-// So that extended_p_square_quantile can be automatically substituted with
-// weighted_extended_p_square_quantile when the weight parameter is non-void
-template<>
-struct as_weighted_feature<tag::extended_p_square_quantile>
-{
-    typedef tag::weighted_extended_p_square_quantile type;
-};
-
-template<>
-struct feature_of<tag::weighted_extended_p_square_quantile>
-  : feature_of<tag::extended_p_square_quantile>
-{
-};
-
-// So that extended_p_square_quantile_quadratic can be automatically substituted with
-// weighted_extended_p_square_quantile_quadratic when the weight parameter is non-void
-template<>
-struct as_weighted_feature<tag::extended_p_square_quantile_quadratic>
-{
-    typedef tag::weighted_extended_p_square_quantile_quadratic type;
-};
-template<>
-struct feature_of<tag::weighted_extended_p_square_quantile_quadratic>
-  : feature_of<tag::extended_p_square_quantile_quadratic>
-{
-};
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/kurtosis.hpp

@@ -1,112 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// kurtosis.hpp
-//
-//  Copyright 2006 Olivier Gygi, Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_KURTOSIS_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_KURTOSIS_HPP_EAN_28_10_2005
-
-#include <limits>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics/mean.hpp>
-#include <boost/accumulators/statistics/moment.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // kurtosis_impl
-    /**
-        @brief Kurtosis estimation
-
-        The kurtosis of a sample distribution is defined as the ratio of the 4th central moment and the square of the 2nd central
-        moment (the variance) of the samples, minus 3. The term \f$ -3 \f$ is added in order to ensure that the normal distribution
-        has zero kurtosis. The kurtosis can also be expressed by the simple moments:
-
-        \f[
-            \hat{g}_2 =
-                \frac
-                {\widehat{m}_n^{(4)}-4\widehat{m}_n^{(3)}\hat{\mu}_n+6\widehat{m}_n^{(2)}\hat{\mu}_n^2-3\hat{\mu}_n^4}
-                {\left(\widehat{m}_n^{(2)} - \hat{\mu}_n^{2}\right)^2} - 3,
-        \f]
-
-        where \f$ \widehat{m}_n^{(i)} \f$ are the \f$ i \f$-th moment and \f$ \hat{\mu}_n \f$ the mean (first moment) of the
-        \f$ n \f$ samples.
-    */
-    template<typename Sample>
-    struct kurtosis_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, Sample>::result_type result_type;
-
-        kurtosis_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return numeric::average(
-                        accumulators::moment<4>(args)
-                        - 4. * accumulators::moment<3>(args) * mean(args)
-                        + 6. * accumulators::moment<2>(args) * mean(args) * mean(args)
-                        - 3. * mean(args) * mean(args) * mean(args) * mean(args)
-                      , ( accumulators::moment<2>(args) - mean(args) * mean(args) )
-                        * ( accumulators::moment<2>(args) - mean(args) * mean(args) )
-                    ) - 3.;
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::kurtosis
-//
-namespace tag
-{
-    struct kurtosis
-      : depends_on<mean, moment<2>, moment<3>, moment<4> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::kurtosis_impl<mpl::_1> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::kurtosis
-//
-namespace extract
-{
-    extractor<tag::kurtosis> const kurtosis = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(kurtosis)
-}
-
-using extract::kurtosis;
-
-// So that kurtosis can be automatically substituted with
-// weighted_kurtosis when the weight parameter is non-void
-template<>
-struct as_weighted_feature<tag::kurtosis>
-{
-    typedef tag::weighted_kurtosis type;
-};
-
-template<>
-struct feature_of<tag::weighted_kurtosis>
-  : feature_of<tag::kurtosis>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/max.hpp

@@ -1,85 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// max.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_MAX_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_MAX_HPP_EAN_28_10_2005
-
-#include <limits>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // max_impl
-    template<typename Sample>
-    struct max_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef Sample result_type;
-
-        template<typename Args>
-        max_impl(Args const &args)
-          : max_(numeric::as_min(args[sample | Sample()]))
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            numeric::max_assign(this->max_, args[sample]);
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->max_;
-        }
-
-    private:
-        Sample max_;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::max
-//
-namespace tag
-{
-    struct max
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::max_impl<mpl::_1> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::max
-//
-namespace extract
-{
-    extractor<tag::max> const max = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(max)
-}
-
-using extract::max;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/mean.hpp

@@ -1,298 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// mean.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_MEAN_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_MEAN_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // mean_impl
-    //      lazy, by default
-    template<typename Sample, typename SumFeature>
-    struct mean_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        mean_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            extractor<SumFeature> sum;
-            return numeric::average(sum(args), count(args));
-        }
-    };
-
-    template<typename Sample, typename Tag>
-    struct immediate_mean_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        template<typename Args>
-        immediate_mean_impl(Args const &args)
-          : mean(numeric::average(args[sample | Sample()], numeric::one<std::size_t>::value))
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-            this->mean = numeric::average(
-                (this->mean * (cnt - 1)) + args[parameter::keyword<Tag>::get()]
-              , cnt
-            );
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->mean;
-        }
-
-    private:
-        result_type mean;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::mean
-// tag::immediate_mean
-// tag::mean_of_weights
-// tag::immediate_mean_of_weights
-// tag::mean_of_variates
-// tag::immediate_mean_of_variates
-//
-namespace tag
-{
-    struct mean
-      : depends_on<count, sum>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::mean_impl<mpl::_1, sum> impl;
-    };
-    struct immediate_mean
-      : depends_on<count>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::immediate_mean_impl<mpl::_1, tag::sample> impl;
-    };
-    struct mean_of_weights
-      : depends_on<count, sum_of_weights>
-    {
-        typedef mpl::true_ is_weight_accumulator;
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::mean_impl<mpl::_2, sum_of_weights> impl;
-    };
-    struct immediate_mean_of_weights
-      : depends_on<count>
-    {
-        typedef mpl::true_ is_weight_accumulator;
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::immediate_mean_impl<mpl::_2, tag::weight> impl;
-    };
-    template<typename VariateType, typename VariateTag>
-    struct mean_of_variates
-      : depends_on<count, sum_of_variates<VariateType, VariateTag> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::mean_impl<VariateType, sum_of_variates<VariateType, VariateTag> > > impl;
-    };
-    template<typename VariateType, typename VariateTag>
-    struct immediate_mean_of_variates
-      : depends_on<count>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::immediate_mean_impl<VariateType, VariateTag> > impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::mean
-// extract::mean_of_weights
-// extract::mean_of_variates
-//
-namespace extract
-{
-    extractor<tag::mean> const mean = {};
-    extractor<tag::mean_of_weights> const mean_of_weights = {};
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, mean_of_variates, (typename)(typename))
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(mean)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(mean_of_weights)
-}
-
-using extract::mean;
-using extract::mean_of_weights;
-using extract::mean_of_variates;
-
-// mean(lazy) -> mean
-template<>
-struct as_feature<tag::mean(lazy)>
-{
-    typedef tag::mean type;
-};
-
-// mean(immediate) -> immediate_mean
-template<>
-struct as_feature<tag::mean(immediate)>
-{
-    typedef tag::immediate_mean type;
-};
-
-// mean_of_weights(lazy) -> mean_of_weights
-template<>
-struct as_feature<tag::mean_of_weights(lazy)>
-{
-    typedef tag::mean_of_weights type;
-};
-
-// mean_of_weights(immediate) -> immediate_mean_of_weights
-template<>
-struct as_feature<tag::mean_of_weights(immediate)>
-{
-    typedef tag::immediate_mean_of_weights type;
-};
-
-// mean_of_variates<VariateType, VariateTag>(lazy) -> mean_of_variates<VariateType, VariateTag>
-template<typename VariateType, typename VariateTag>
-struct as_feature<tag::mean_of_variates<VariateType, VariateTag>(lazy)>
-{
-    typedef tag::mean_of_variates<VariateType, VariateTag> type;
-};
-
-// mean_of_variates<VariateType, VariateTag>(immediate) -> immediate_mean_of_variates<VariateType, VariateTag>
-template<typename VariateType, typename VariateTag>
-struct as_feature<tag::mean_of_variates<VariateType, VariateTag>(immediate)>
-{
-    typedef tag::immediate_mean_of_variates<VariateType, VariateTag> type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// immediate_mean provides the same feature as mean
-template<>
-struct feature_of<tag::immediate_mean>
-  : feature_of<tag::mean>
-{
-};
-
-// for the purposes of feature-based dependency resolution,
-// immediate_mean provides the same feature as mean
-template<>
-struct feature_of<tag::immediate_mean_of_weights>
-  : feature_of<tag::mean_of_weights>
-{
-};
-
-// for the purposes of feature-based dependency resolution,
-// immediate_mean provides the same feature as mean
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::immediate_mean_of_variates<VariateType, VariateTag> >
-  : feature_of<tag::mean_of_variates<VariateType, VariateTag> >
-{
-};
-
-// So that mean can be automatically substituted with
-// weighted_mean when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::mean>
-{
-    typedef tag::weighted_mean type;
-};
-
-template<>
-struct feature_of<tag::weighted_mean>
-  : feature_of<tag::mean>
-{};
-
-// So that immediate_mean can be automatically substituted with
-// immediate_weighted_mean when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::immediate_mean>
-{
-    typedef tag::immediate_weighted_mean type;
-};
-
-template<>
-struct feature_of<tag::immediate_weighted_mean>
-  : feature_of<tag::immediate_mean>
-{};
-
-// So that mean_of_weights<> can be automatically substituted with
-// weighted_mean_of_variates<> when the weight parameter is non-void.
-template<typename VariateType, typename VariateTag>
-struct as_weighted_feature<tag::mean_of_variates<VariateType, VariateTag> >
-{
-    typedef tag::weighted_mean_of_variates<VariateType, VariateTag> type;
-};
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::weighted_mean_of_variates<VariateType, VariateTag> >
-  : feature_of<tag::mean_of_variates<VariateType, VariateTag> >
-{
-};
-
-// So that immediate_mean_of_weights<> can be automatically substituted with
-// immediate_weighted_mean_of_variates<> when the weight parameter is non-void.
-template<typename VariateType, typename VariateTag>
-struct as_weighted_feature<tag::immediate_mean_of_variates<VariateType, VariateTag> >
-{
-    typedef tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> type;
-};
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> >
-  : feature_of<tag::immediate_mean_of_variates<VariateType, VariateTag> >
-{
-};
-
-////////////////////////////////////////////////////////////////////////////
-//// droppable_accumulator<mean_impl>
-////  need to specialize droppable lazy mean to cache the result at the
-////  point the accumulator is dropped.
-///// INTERNAL ONLY
-/////
-//template<typename Sample, typename SumFeature>
-//struct droppable_accumulator<impl::mean_impl<Sample, SumFeature> >
-//  : droppable_accumulator_base<
-//        with_cached_result<impl::mean_impl<Sample, SumFeature> >
-//    >
-//{
-//    template<typename Args>
-//    droppable_accumulator(Args const &args)
-//      : droppable_accumulator::base(args)
-//    {
-//    }
-//};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/median.hpp

@@ -1,301 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// median.hpp
-//
-//  Copyright 2006 Eric Niebler, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_MEDIAN_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_MEDIAN_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/p_square_quantile.hpp>
-#include <boost/accumulators/statistics/density.hpp>
-#include <boost/accumulators/statistics/p_square_cumulative_distribution.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // median_impl
-    //
-    /**
-        @brief Median estimation based on the \f$P^2\f$ quantile estimator
-
-        The \f$P^2\f$ algorithm is invoked with a quantile probability of 0.5.
-    */
-    template<typename Sample>
-    struct median_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        median_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return p_square_quantile_for_median(args);
-        }
-    };
-    ///////////////////////////////////////////////////////////////////////////////
-    // with_density_median_impl
-    //
-    /**
-        @brief Median estimation based on the density estimator
-
-        The algorithm determines the bin in which the \f$0.5*cnt\f$-th sample lies, \f$cnt\f$ being
-        the total number of samples. It returns the approximate horizontal position of this sample,
-        based on a linear interpolation inside the bin.
-    */
-    template<typename Sample>
-    struct with_density_median_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        typedef iterator_range<typename histogram_type::iterator> range_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        template<typename Args>
-        with_density_median_impl(Args const &args)
-          : sum(numeric::average(args[sample | Sample()], (std::size_t)1))
-          , is_dirty(true)
-        {
-        }
-
-        void operator ()(dont_care)
-        {
-            this->is_dirty = true;
-        }
-
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                std::size_t cnt = count(args);
-                range_type histogram = density(args);
-                typename range_type::iterator it = histogram.begin();
-                while (this->sum < 0.5 * cnt)
-                {
-                    this->sum += it->second * cnt;
-                    ++it;
-                }
-                --it;
-                float_type over = numeric::average(this->sum - 0.5 * cnt, it->second * cnt);
-                this->median = it->first * over + (it + 1)->first * (1. - over);
-            }
-
-            return this->median;
-        }
-
-    private:
-        mutable float_type sum;
-        mutable bool is_dirty;
-        mutable float_type median;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // with_p_square_cumulative_distribution_median_impl
-    //
-    /**
-        @brief Median estimation based on the \f$P^2\f$ cumulative distribution estimator
-
-        The algorithm determines the first (leftmost) bin with a height exceeding 0.5. It
-        returns the approximate horizontal position of where the cumulative distribution
-        equals 0.5, based on a linear interpolation inside the bin.
-    */
-    template<typename Sample>
-    struct with_p_square_cumulative_distribution_median_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        typedef iterator_range<typename histogram_type::iterator> range_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        with_p_square_cumulative_distribution_median_impl(dont_care)
-          : is_dirty(true)
-        {
-        }
-
-        void operator ()(dont_care)
-        {
-            this->is_dirty = true;
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                range_type histogram = p_square_cumulative_distribution(args);
-                typename range_type::iterator it = histogram.begin();
-                while (it->second < 0.5)
-                {
-                    ++it;
-                }
-                float_type over = numeric::average(it->second - 0.5, it->second - (it - 1)->second);
-                this->median = it->first * over + (it + 1)->first * ( 1. - over );
-            }
-
-            return this->median;
-        }
-    private:
-
-        mutable bool is_dirty;
-        mutable float_type median;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::median
-// tag::with_densisty_median
-// tag::with_p_square_cumulative_distribution_median
-//
-namespace tag
-{
-    struct median
-      : depends_on<p_square_quantile_for_median>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::median_impl<mpl::_1> impl;
-    };
-    struct with_density_median
-      : depends_on<count, density>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::with_density_median_impl<mpl::_1> impl;
-    };
-    struct with_p_square_cumulative_distribution_median
-      : depends_on<p_square_cumulative_distribution>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::with_p_square_cumulative_distribution_median_impl<mpl::_1> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::median
-// extract::with_density_median
-// extract::with_p_square_cumulative_distribution_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 = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(median)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(with_density_median)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(with_p_square_cumulative_distribution_median)
-}
-
-using extract::median;
-using extract::with_density_median;
-using extract::with_p_square_cumulative_distribution_median;
-
-// median(with_p_square_quantile) -> median
-template<>
-struct as_feature<tag::median(with_p_square_quantile)>
-{
-    typedef tag::median type;
-};
-
-// median(with_density) -> with_density_median
-template<>
-struct as_feature<tag::median(with_density)>
-{
-    typedef tag::with_density_median type;
-};
-
-// median(with_p_square_cumulative_distribution) -> with_p_square_cumulative_distribution_median
-template<>
-struct as_feature<tag::median(with_p_square_cumulative_distribution)>
-{
-    typedef tag::with_p_square_cumulative_distribution_median type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// with_density_median and with_p_square_cumulative_distribution_median
-// provide the same feature as median
-template<>
-struct feature_of<tag::with_density_median>
-  : feature_of<tag::median>
-{
-};
-
-template<>
-struct feature_of<tag::with_p_square_cumulative_distribution_median>
-  : feature_of<tag::median>
-{
-};
-
-// So that median can be automatically substituted with
-// weighted_median when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::median>
-{
-    typedef tag::weighted_median type;
-};
-
-template<>
-struct feature_of<tag::weighted_median>
-  : feature_of<tag::median>
-{
-};
-
-// So that with_density_median can be automatically substituted with
-// with_density_weighted_median when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::with_density_median>
-{
-    typedef tag::with_density_weighted_median type;
-};
-
-template<>
-struct feature_of<tag::with_density_weighted_median>
-  : feature_of<tag::with_density_median>
-{
-};
-
-// So that with_p_square_cumulative_distribution_median can be automatically substituted with
-// with_p_square_cumulative_distribution_weighted_median when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::with_p_square_cumulative_distribution_median>
-{
-    typedef tag::with_p_square_cumulative_distribution_weighted_median type;
-};
-
-template<>
-struct feature_of<tag::with_p_square_cumulative_distribution_weighted_median>
-  : feature_of<tag::with_p_square_cumulative_distribution_median>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/min.hpp

@@ -1,85 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// min.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_MIN_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_MIN_HPP_EAN_28_10_2005
-
-#include <limits>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // min_impl
-    template<typename Sample>
-    struct min_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef Sample result_type;
-
-        template<typename Args>
-        min_impl(Args const &args)
-          : min_(numeric::as_max(args[sample | Sample()]))
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            numeric::min_assign(this->min_, args[sample]);
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->min_;
-        }
-
-    private:
-        Sample min_;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::min
-//
-namespace tag
-{
-    struct min
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::min_impl<mpl::_1> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::min
-//
-namespace extract
-{
-    extractor<tag::min> const min = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(min)
-}
-
-using extract::min;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/moment.hpp

@@ -1,125 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// moment.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_MOMENT_HPP_EAN_15_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_MOMENT_HPP_EAN_15_11_2005
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-
-namespace boost { namespace numeric
-{
-    /// INTERNAL ONLY
-    ///
-    template<typename T>
-    T const &pow(T const &x, mpl::int_<1>)
-    {
-        return x;
-    }
-
-    /// INTERNAL ONLY
-    ///
-    template<typename T, int N>
-    T pow(T const &x, mpl::int_<N>)
-    {
-        using namespace operators;
-        T y = numeric::pow(x, mpl::int_<N/2>());
-        T z = y * y;
-        return (N % 2) ? (z * x) : z;
-    }
-}}
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // moment_impl
-    template<typename N, typename Sample>
-    struct moment_impl
-      : accumulator_base // TODO: also depends_on sum of powers
-    {
-        BOOST_MPL_ASSERT_RELATION(N::value, >, 0);
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        template<typename Args>
-        moment_impl(Args const &args)
-          : sum(args[sample | Sample()])
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->sum += numeric::pow(args[sample], N());
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return numeric::average(this->sum, count(args));
-        }
-
-    private:
-        Sample sum;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::moment
-//
-namespace tag
-{
-    template<int N>
-    struct moment
-      : depends_on<count>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::moment_impl<mpl::int_<N>, mpl::_1> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::moment
-//
-namespace extract
-{
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, moment, (int))
-}
-
-using extract::moment;
-
-// So that moment<N> can be automatically substituted with
-// weighted_moment<N> when the weight parameter is non-void
-template<int N>
-struct as_weighted_feature<tag::moment<N> >
-{
-    typedef tag::weighted_moment<N> type;
-};
-
-template<int N>
-struct feature_of<tag::weighted_moment<N> >
-  : feature_of<tag::moment<N> >
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/p_square_cumulative_distribution.hpp

@@ -1,260 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// p_square_cumulative_distribution.hpp
-//
-//  Copyright 2005 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_DE_01_01_2006
-
-#include <vector>
-#include <functional>
-#include <boost/parameter/keyword.hpp>
-#include <boost/range.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-
-namespace boost { namespace accumulators
-{
-///////////////////////////////////////////////////////////////////////////////
-// num_cells named parameter
-//
-BOOST_PARAMETER_NESTED_KEYWORD(tag, p_square_cumulative_distribution_num_cells, num_cells)
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // p_square_cumulative_distribution_impl
-    //  cumulative_distribution calculation (as histogram)
-    /**
-        @brief Histogram calculation of the cumulative distribution with the \f$P^2\f$ algorithm
-
-        A histogram of the sample cumulative distribution is computed dynamically without storing samples
-        based on the \f$ P^2 \f$ algorithm. The returned histogram has a specifiable amount (num_cells)
-        equiprobable (and not equal-sized) cells.
-
-        For further details, see
-
-        R. Jain and I. Chlamtac, The P^2 algorithmus for dynamic calculation of quantiles and
-        histograms without storing observations, Communications of the ACM,
-        Volume 28 (October), Number 10, 1985, p. 1076-1085.
-
-        @param p_square_cumulative_distribution_num_cells.
-    */
-    template<typename Sample>
-    struct p_square_cumulative_distribution_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<float_type> array_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        // for boost::result_of
-        typedef iterator_range<typename histogram_type::iterator> result_type;
-
-        template<typename Args>
-        p_square_cumulative_distribution_impl(Args const &args)
-          : num_cells(args[p_square_cumulative_distribution_num_cells])
-          , heights(num_cells + 1)
-          , actual_positions(num_cells + 1)
-          , desired_positions(num_cells + 1)
-          , positions_increments(num_cells + 1)
-          , histogram(num_cells + 1)
-          , is_dirty(true)
-        {
-            std::size_t b = this->num_cells;
-
-            for (std::size_t i = 0; i < b + 1; ++i)
-            {
-                this->actual_positions[i] = i + 1.;
-                this->desired_positions[i] = i + 1.;
-                this->positions_increments[i] = numeric::average(i, b);
-            }
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->is_dirty = true;
-
-            std::size_t cnt = count(args);
-            std::size_t sample_cell = 1; // k
-            std::size_t b = this->num_cells;
-
-            // accumulate num_cells + 1 first samples
-            if (cnt <= b + 1)
-            {
-                this->heights[cnt - 1] = args[sample];
-
-                // complete the initialization of heights by sorting
-                if (cnt == b + 1)
-                {
-                    std::sort(this->heights.begin(), this->heights.end());
-                }
-            }
-            else
-            {
-                // find cell k such that heights[k-1] <= args[sample] < heights[k] and adjust extreme values
-                if (args[sample] < this->heights[0])
-                {
-                    this->heights[0] = args[sample];
-                    sample_cell = 1;
-                }
-                else if (this->heights[b] <= args[sample])
-                {
-                    this->heights[b] = args[sample];
-                    sample_cell = b;
-                }
-                else
-                {
-                    typename array_type::iterator it;
-                    it = std::upper_bound(
-                        this->heights.begin()
-                      , this->heights.end()
-                      , args[sample]
-                    );
-
-                    sample_cell = std::distance(this->heights.begin(), it);
-                }
-
-                // increment positions of markers above sample_cell
-                for (std::size_t i = sample_cell; i < b + 1; ++i)
-                {
-                    ++this->actual_positions[i];
-                }
-
-                // update desired position of markers 2 to num_cells + 1
-                // (desired position of first marker is always 1)
-                for (std::size_t i = 1; i < b + 1; ++i)
-                {
-                    this->desired_positions[i] += this->positions_increments[i];
-                }
-
-                // adjust heights of markers 2 to num_cells if necessary
-                for (std::size_t i = 1; i < b; ++i)
-                {
-                    // offset to desire position
-                    float_type d = this->desired_positions[i] - this->actual_positions[i];
-
-                    // offset to next position
-                    float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
-
-                    // offset to previous position
-                    float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
-
-                    // height ds
-                    float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
-                    float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
-
-                    if ( ( d >= 1. && dp > 1. ) || ( d <= -1. && dm < -1. ) )
-                    {
-                        short sign_d = static_cast<short>(d / std::abs(d));
-
-                        // try adjusting heights[i] using p-squared formula
-                        float_type h = this->heights[i] + sign_d / (dp - dm) * ( (sign_d - dm) * hp + (dp - sign_d) * hm );
-
-                        if ( this->heights[i - 1] < h && h < this->heights[i + 1] )
-                        {
-                            this->heights[i] = h;
-                        }
-                        else
-                        {
-                            // use linear formula
-                            if (d>0)
-                            {
-                                this->heights[i] += hp;
-                            }
-                            if (d<0)
-                            {
-                                this->heights[i] -= hm;
-                            }
-                        }
-                        this->actual_positions[i] += sign_d;
-                    }
-                }
-            }
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                // creates a vector of std::pair where each pair i holds
-                // the values heights[i] (x-axis of histogram) and
-                // actual_positions[i] / cnt (y-axis of histogram)
-
-                std::size_t cnt = count(args);
-
-                for (std::size_t i = 0; i < this->histogram.size(); ++i)
-                {
-                    this->histogram[i] = std::make_pair(this->heights[i], numeric::average(this->actual_positions[i], cnt));
-                }
-            }
-            //return histogram;
-            return make_iterator_range(this->histogram);
-        }
-
-    private:
-        std::size_t num_cells;            // number of cells b
-        array_type  heights;              // q_i
-        array_type  actual_positions;     // n_i
-        array_type  desired_positions;    // n'_i
-        array_type  positions_increments; // dn'_i
-        mutable histogram_type histogram; // histogram
-        mutable bool is_dirty;
-    };
-
-} // namespace detail
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::p_square_cumulative_distribution
-//
-namespace tag
-{
-    struct p_square_cumulative_distribution
-      : depends_on<count>
-      , p_square_cumulative_distribution_num_cells
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::p_square_cumulative_distribution_impl<mpl::_1> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::p_square_cumulative_distribution
-//
-namespace extract
-{
-    extractor<tag::p_square_cumulative_distribution> const p_square_cumulative_distribution = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(p_square_cumulative_distribution)
-}
-
-using extract::p_square_cumulative_distribution;
-
-// So that p_square_cumulative_distribution can be automatically substituted with
-// weighted_p_square_cumulative_distribution when the weight parameter is non-void
-template<>
-struct as_weighted_feature<tag::p_square_cumulative_distribution>
-{
-    typedef tag::weighted_p_square_cumulative_distribution type;
-};
-
-template<>
-struct feature_of<tag::weighted_p_square_cumulative_distribution>
-  : feature_of<tag::p_square_cumulative_distribution>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/p_square_quantile.hpp

@@ -1,257 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// p_square_quantile.hpp
-//
-//  Copyright 2005 Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_P_SQUARE_QUANTILE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_P_SQUARE_QUANTILE_HPP_DE_01_01_2006
-
-#include <cmath>
-#include <functional>
-#include <boost/array.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // p_square_quantile_impl
-    //  single quantile estimation
-    /**
-        @brief Single quantile estimation with the \f$P^2\f$ algorithm
-
-        The \f$P^2\f$ algorithm estimates a quantile dynamically without storing samples. Instead of
-        storing the whole sample cumulative distribution, only five points (markers) are stored. The heights
-        of these markers are the minimum and the maximum of the samples and the current estimates of the
-        \f$(p/2)\f$-, \f$p\f$- and \f$(1+p)/2\f$-quantiles. Their positions are equal to the number
-        of samples that are smaller or equal to the markers. Each time a new samples is recorded, the
-        positions of the markers are updated and if necessary their heights are adjusted using a piecewise-
-        parabolic formula.
-
-        For further details, see
-
-        R. Jain and I. Chlamtac, The P^2 algorithmus fordynamic calculation of quantiles and
-        histograms without storing observations, Communications of the ACM,
-        Volume 28 (October), Number 10, 1985, p. 1076-1085.
-
-        @param quantile_probability
-    */
-    template<typename Sample, typename Impl>
-    struct p_square_quantile_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef array<float_type, 5> array_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        template<typename Args>
-        p_square_quantile_impl(Args const &args)
-          : p(is_same<Impl, for_median>::value ? 0.5 : args[quantile_probability | 0.5])
-          , heights()
-          , actual_positions()
-          , desired_positions()
-          , positions_increments()
-        {
-            for(std::size_t i = 0; i < 5; ++i)
-            {
-                this->actual_positions[i] = i + 1;
-            }
-
-            this->desired_positions[0] = 1.;
-            this->desired_positions[1] = 1. + 2. * this->p;
-            this->desired_positions[2] = 1. + 4. * this->p;
-            this->desired_positions[3] = 3. + 2. * this->p;
-            this->desired_positions[4] = 5.;
-
-            this->positions_increments[0] = 0.;
-            this->positions_increments[1] = this->p / 2.;
-            this->positions_increments[2] = this->p;
-            this->positions_increments[3] = (1. + this->p) / 2.;
-            this->positions_increments[4] = 1.;
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-
-            // accumulate 5 first samples
-            if(cnt <= 5)
-            {
-                this->heights[cnt - 1] = args[sample];
-
-                // complete the initialization of heights by sorting
-                if(cnt == 5)
-                {
-                    std::sort(this->heights.begin(), this->heights.end());
-                }
-            }
-            else
-            {
-                std::size_t sample_cell = 1; // k
-
-                // find cell k such that heights[k-1] <= args[sample] < heights[k] and ajust extreme values
-                if (args[sample] < this->heights[0])
-                {
-                    this->heights[0] = args[sample];
-                    sample_cell = 1;
-                }
-                else if (this->heights[4] <= args[sample])
-                {
-                    this->heights[4] = args[sample];
-                    sample_cell = 4;
-                }
-                else
-                {
-                    typedef typename array_type::iterator iterator;
-                    iterator it = std::upper_bound(
-                        this->heights.begin()
-                      , this->heights.end()
-                      , args[sample]
-                    );
-
-                    sample_cell = std::distance(this->heights.begin(), it);
-                }
-
-                // update positions of markers above sample_cell
-                for(std::size_t i = sample_cell; i < 5; ++i)
-                {
-                    ++this->actual_positions[i];
-                }
-
-                // update desired positions of all markers
-                for(std::size_t i = 0; i < 5; ++i)
-                {
-                    this->desired_positions[i] += this->positions_increments[i];
-                }
-
-                // adjust heights and actual positions of markers 1 to 3 if necessary
-                for(std::size_t i = 1; i <= 3; ++i)
-                {
-                    // offset to desired positions
-                    float_type d = this->desired_positions[i] - this->actual_positions[i];
-
-                    // offset to next position
-                    float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
-
-                    // offset to previous position
-                    float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
-
-                    // height ds
-                    float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
-                    float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
-
-                    if((d >= 1. && dp > 1.) || (d <= -1. && dm < -1.))
-                    {
-                        short sign_d = static_cast<short>(d / std::abs(d));
-
-                        // try adjusting heights[i] using p-squared formula
-                        float_type h = this->heights[i] + sign_d / (dp - dm) * ((sign_d - dm) * hp
-                                     + (dp - sign_d) * hm);
-
-                        if(this->heights[i - 1] < h && h < this->heights[i + 1])
-                        {
-                            this->heights[i] = h;
-                        }
-                        else
-                        {
-                            // use linear formula
-                            if(d > 0)
-                            {
-                                this->heights[i] += hp;
-                            }
-                            if(d < 0)
-                            {
-                                this->heights[i] -= hm;
-                            }
-                        }
-                        this->actual_positions[i] += sign_d;
-                    }
-                }
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->heights[2];
-        }
-
-    private:
-        float_type p;                    // the quantile probability p
-        array_type heights;              // q_i
-        array_type actual_positions;     // n_i
-        array_type desired_positions;    // n'_i
-        array_type positions_increments; // dn'_i
-    };
-
-} // namespace detail
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::p_square_quantile
-//
-namespace tag
-{
-    struct p_square_quantile
-      : depends_on<count>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::p_square_quantile_impl<mpl::_1, regular> impl;
-    };
-    struct p_square_quantile_for_median
-      : depends_on<count>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::p_square_quantile_impl<mpl::_1, for_median> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::p_square_quantile
-// extract::p_square_quantile_for_median
-//
-namespace extract
-{
-    extractor<tag::p_square_quantile> const p_square_quantile = {};
-    extractor<tag::p_square_quantile_for_median> const p_square_quantile_for_median = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(p_square_quantile)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(p_square_quantile_for_median)
-}
-
-using extract::p_square_quantile;
-using extract::p_square_quantile_for_median;
-
-// So that p_square_quantile can be automatically substituted with
-// weighted_p_square_quantile when the weight parameter is non-void
-template<>
-struct as_weighted_feature<tag::p_square_quantile>
-{
-    typedef tag::weighted_p_square_quantile type;
-};
-
-template<>
-struct feature_of<tag::weighted_p_square_quantile>
-  : feature_of<tag::p_square_quantile>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/parameters/quantile_probability.hpp

@@ -1,20 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// quantile_probability.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_PARAMETERS_QUANTILE_PROBABILITY_HPP_EAN_03_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_PARAMETERS_QUANTILE_PROBABILITY_HPP_EAN_03_11_2005
-
-#include <boost/parameter/keyword.hpp>
-
-namespace boost { namespace accumulators
-{
-
-BOOST_PARAMETER_KEYWORD(tag, quantile_probability)
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/peaks_over_threshold.hpp

@@ -1,401 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// peaks_over_threshold.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_PEAKS_OVER_THRESHOLD_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_PEAKS_OVER_THRESHOLD_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <numeric>
-#include <functional>
-#include <boost/config/no_tr1/cmath.hpp> // pow
-#include <sstream> // stringstream
-#include <stdexcept> // runtime_error
-#include <boost/throw_exception.hpp>
-#include <boost/range.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// threshold_probability and threshold named parameters
-//
-BOOST_PARAMETER_NESTED_KEYWORD(tag, pot_threshold_value, threshold_value)
-BOOST_PARAMETER_NESTED_KEYWORD(tag, pot_threshold_probability, threshold_probability)
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // peaks_over_threshold_impl
-    //  works with an explicit threshold value and does not depend on order statistics
-    /**
-        @brief Peaks over Threshold Method for Quantile and Tail Mean Estimation
-
-        According to the theorem of Pickands-Balkema-de Haan, the distribution function \f$F_u(x)\f$ of
-        the excesses \f$x\f$ over some sufficiently high threshold \f$u\f$ of a distribution function \f$F(x)\f$
-        may be approximated by a generalized Pareto distribution
-        \f[
-            G_{\xi,\beta}(x) =
-            \left\{
-            \begin{array}{ll}
-                \beta^{-1}\left(1+\frac{\xi x}{\beta}\right)^{-1/\xi-1} & \textrm{if }\xi\neq0\\
-                \beta^{-1}\exp\left(-\frac{x}{\beta}\right) & \textrm{if }\xi=0,
-            \end{array}
-            \right.
-        \f]
-        with suitable parameters \f$\xi\f$ and \f$\beta\f$ that can be estimated, e.g., with the method of moments, cf.
-        Hosking and Wallis (1987),
-        \f[
-            \begin{array}{lll}
-            \hat{\xi} & = & \frac{1}{2}\left[1-\frac{(\hat{\mu}-u)^2}{\hat{\sigma}^2}\right]\\
-            \hat{\beta} & = & \frac{\hat{\mu}-u}{2}\left[\frac{(\hat{\mu}-u)^2}{\hat{\sigma}^2}+1\right],
-            \end{array}
-        \f]
-        \f$\hat{\mu}\f$ and \f$\hat{\sigma}^2\f$ being the empirical mean and variance of the samples over
-        the threshold \f$u\f$. Equivalently, the distribution function
-        \f$F_u(x-u)\f$ of the exceedances \f$x-u\f$ can be approximated by
-        \f$G_{\xi,\beta}(x-u)=G_{\xi,\beta,u}(x)\f$. Since for \f$x\geq u\f$ the distribution function \f$F(x)\f$
-        can be written as
-        \f[
-            F(x) = [1 - \P(X \leq u)]F_u(x - u) + \P(X \leq u)
-        \f]
-        and the probability \f$\P(X \leq u)\f$ can be approximated by the empirical distribution function
-        \f$F_n(u)\f$ evaluated at \f$u\f$, an estimator of \f$F(x)\f$ is given by
-        \f[
-            \widehat{F}(x) = [1 - F_n(u)]G_{\xi,\beta,u}(x) + F_n(u).
-        \f]
-        It can be shown that \f$\widehat{F}(x)\f$ is a generalized
-        Pareto distribution \f$G_{\xi,\bar{\beta},\bar{u}}(x)\f$ with \f$\bar{\beta}=\beta[1-F_n(u)]^{\xi}\f$
-        and \f$\bar{u}=u-\bar{\beta}\left\{[1-F_n(u)]^{-\xi}-1\right\}/\xi\f$. By inverting \f$\widehat{F}(x)\f$,
-        one obtains an estimator for the \f$\alpha\f$-quantile,
-        \f[
-            \hat{q}_{\alpha} = \bar{u} + \frac{\bar{\beta}}{\xi}\left[(1-\alpha)^{-\xi}-1\right],
-        \f]
-        and similarly an estimator for the (coherent) tail mean,
-        \f[
-            \widehat{CTM}_{\alpha} = \hat{q}_{\alpha} - \frac{\bar{\beta}}{\xi-1}(1-\alpha)^{-\xi},
-        \f]
-        cf. McNeil and Frey (2000).
-
-        Note that in case extreme values of the left tail are fitted, the distribution is mirrored with respect to the
-        \f$y\f$ axis such that the left tail can be treated as a right tail. The computed fit parameters thus define
-        the Pareto distribution that fits the mirrored left tail. When quantities like a quantile or a tail mean are
-        computed using the fit parameters obtained from the mirrored data, the result is mirrored back, yielding the
-        correct result.
-
-        For further details, see
-
-        J. R. M. Hosking and J. R. Wallis, Parameter and quantile estimation for the generalized Pareto distribution,
-        Technometrics, Volume 29, 1987, p. 339-349
-
-        A. J. McNeil and R. Frey, Estimation of Tail-Related Risk Measures for Heteroscedastic Financial Time Series:
-        an Extreme Value Approach, Journal of Empirical Finance, Volume 7, 2000, p. 271-300
-
-        @param quantile_probability
-        @param pot_threshold_value
-    */
-    template<typename Sample, typename LeftRight>
-    struct peaks_over_threshold_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef boost::tuple<float_type, float_type, float_type> result_type;
-        // for left tail fitting, mirror the extreme values
-        typedef mpl::int_<is_same<LeftRight, left>::value ? -1 : 1> sign;
-
-        template<typename Args>
-        peaks_over_threshold_impl(Args const &args)
-          : Nu_(0)
-          , mu_(sign::value * numeric::average(args[sample | Sample()], (std::size_t)1))
-          , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
-          , threshold_(sign::value * args[pot_threshold_value])
-          , fit_parameters_(boost::make_tuple(0., 0., 0.))
-          , is_dirty_(true)
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->is_dirty_ = true;
-
-            if (sign::value * args[sample] > this->threshold_)
-            {
-                this->mu_ += args[sample];
-                this->sigma2_ += args[sample] * args[sample];
-                ++this->Nu_;
-            }
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty_)
-            {
-                this->is_dirty_ = false;
-
-                std::size_t cnt = count(args);
-
-                this->mu_ = sign::value * numeric::average(this->mu_, this->Nu_);
-                this->sigma2_ = numeric::average(this->sigma2_, this->Nu_);
-                this->sigma2_ -= this->mu_ * this->mu_;
-
-                float_type threshold_probability = numeric::average(cnt - this->Nu_, cnt);
-
-                float_type tmp = numeric::average(( this->mu_ - this->threshold_ )*( this->mu_ - this->threshold_ ), this->sigma2_);
-                float_type xi_hat = 0.5 * ( 1. - tmp );
-                float_type beta_hat = 0.5 * ( this->mu_ - this->threshold_ ) * ( 1. + tmp );
-                float_type beta_bar = beta_hat * std::pow(1. - threshold_probability, xi_hat);
-                float_type u_bar = this->threshold_ - beta_bar * ( std::pow(1. - threshold_probability, -xi_hat) - 1.)/xi_hat;
-                this->fit_parameters_ = boost::make_tuple(u_bar, beta_bar, xi_hat);
-            }
-
-            return this->fit_parameters_;
-        }
-
-    private:
-        std::size_t Nu_;                     // number of samples larger than threshold
-        mutable float_type mu_;              // mean of Nu_ largest samples
-        mutable float_type sigma2_;          // variance of Nu_ largest samples
-        float_type threshold_;
-        mutable result_type fit_parameters_; // boost::tuple that stores fit parameters
-        mutable bool is_dirty_;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // peaks_over_threshold_prob_impl
-    //  determines threshold from a given threshold probability using order statistics
-    /**
-        @brief Peaks over Threshold Method for Quantile and Tail Mean Estimation
-
-        @sa peaks_over_threshold_impl
-
-        @param quantile_probability
-        @param pot_threshold_probability
-    */
-    template<typename Sample, typename LeftRight>
-    struct peaks_over_threshold_prob_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef boost::tuple<float_type, float_type, float_type> result_type;
-        // for left tail fitting, mirror the extreme values
-        typedef mpl::int_<is_same<LeftRight, left>::value ? -1 : 1> sign;
-
-        template<typename Args>
-        peaks_over_threshold_prob_impl(Args const &args)
-          : mu_(sign::value * numeric::average(args[sample | Sample()], (std::size_t)1))
-          , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
-          , threshold_probability_(args[pot_threshold_probability])
-          , fit_parameters_(boost::make_tuple(0., 0., 0.))
-          , is_dirty_(true)
-        {
-        }
-
-        void operator ()(dont_care)
-        {
-            this->is_dirty_ = true;
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty_)
-            {
-                this->is_dirty_ = false;
-
-                std::size_t cnt = count(args);
-
-                // the n'th cached sample provides an approximate threshold value u
-                std::size_t n = static_cast<std::size_t>(
-                    std::ceil(
-                        cnt * ( ( is_same<LeftRight, left>::value ) ? this->threshold_probability_ : 1. - this->threshold_probability_ )
-                    )
-                );
-
-                // If n is in a valid range, return result, otherwise return NaN or throw exception
-                if ( n >= static_cast<std::size_t>(tail(args).size()))
-                {
-                    if (std::numeric_limits<float_type>::has_quiet_NaN)
-                    {
-                        return boost::make_tuple(
-                            std::numeric_limits<float_type>::quiet_NaN()
-                          , std::numeric_limits<float_type>::quiet_NaN()
-                          , std::numeric_limits<float_type>::quiet_NaN()
-                        );
-                    }
-                    else
-                    {
-                        std::ostringstream msg;
-                        msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                        boost::throw_exception(std::runtime_error(msg.str()));
-                        return boost::make_tuple(Sample(0), Sample(0), Sample(0));
-                    }
-                }
-                else
-                {
-                    float_type u = *(tail(args).begin() + n - 1) * sign::value;
-
-                    // compute mean and variance of samples above/under threshold value u
-                    for (std::size_t i = 0; i < n; ++i)
-                    {
-                        mu_ += *(tail(args).begin() + i);
-                        sigma2_ += *(tail(args).begin() + i) * (*(tail(args).begin() + i));
-                    }
-
-                    this->mu_ = sign::value * numeric::average(this->mu_, n);
-                    this->sigma2_ = numeric::average(this->sigma2_, n);
-                    this->sigma2_ -= this->mu_ * this->mu_;
-
-                    if (is_same<LeftRight, left>::value)
-                        this->threshold_probability_ = 1. - this->threshold_probability_;
-
-                    float_type tmp = numeric::average(( this->mu_ - u )*( this->mu_ - u ), this->sigma2_);
-                    float_type xi_hat = 0.5 * ( 1. - tmp );
-                    float_type beta_hat = 0.5 * ( this->mu_ - u ) * ( 1. + tmp );
-                    float_type beta_bar = beta_hat * std::pow(1. - threshold_probability_, xi_hat);
-                    float_type u_bar = u - beta_bar * ( std::pow(1. - threshold_probability_, -xi_hat) - 1.)/xi_hat;
-                    this->fit_parameters_ = boost::make_tuple(u_bar, beta_bar, xi_hat);
-                }
-            }
-
-            return this->fit_parameters_;
-        }
-
-    private:
-        mutable float_type mu_;                     // mean of samples above threshold u
-        mutable float_type sigma2_;                 // variance of samples above threshold u
-        mutable float_type threshold_probability_;
-        mutable result_type fit_parameters_;        // boost::tuple that stores fit parameters
-        mutable bool is_dirty_;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::peaks_over_threshold
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct peaks_over_threshold
-      : depends_on<count>
-      , pot_threshold_value
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::peaks_over_threshold_impl<mpl::_1, LeftRight> impl;
-    };
-
-    template<typename LeftRight>
-    struct peaks_over_threshold_prob
-      : depends_on<count, tail<LeftRight> >
-      , pot_threshold_probability
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::peaks_over_threshold_prob_impl<mpl::_1, LeftRight> impl;
-    };
-
-    struct abstract_peaks_over_threshold
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::peaks_over_threshold
-//
-namespace extract
-{
-    extractor<tag::abstract_peaks_over_threshold> const peaks_over_threshold = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(peaks_over_threshold)
-}
-
-using extract::peaks_over_threshold;
-
-// peaks_over_threshold<LeftRight>(with_threshold_value) -> peaks_over_threshold<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::peaks_over_threshold<LeftRight>(with_threshold_value)>
-{
-    typedef tag::peaks_over_threshold<LeftRight> type;
-};
-
-// peaks_over_threshold<LeftRight>(with_threshold_probability) -> peaks_over_threshold_prob<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::peaks_over_threshold<LeftRight>(with_threshold_probability)>
-{
-    typedef tag::peaks_over_threshold_prob<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::peaks_over_threshold<LeftRight> >
-  : feature_of<tag::abstract_peaks_over_threshold>
-{
-};
-
-template<typename LeftRight>
-struct feature_of<tag::peaks_over_threshold_prob<LeftRight> >
-  : feature_of<tag::abstract_peaks_over_threshold>
-{
-};
-
-// So that peaks_over_threshold can be automatically substituted
-// with weighted_peaks_over_threshold when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::peaks_over_threshold<LeftRight> >
-{
-    typedef tag::weighted_peaks_over_threshold<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::weighted_peaks_over_threshold<LeftRight> >
-  : feature_of<tag::peaks_over_threshold<LeftRight> >
-{};
-
-// So that peaks_over_threshold_prob can be automatically substituted
-// with weighted_peaks_over_threshold_prob when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::peaks_over_threshold_prob<LeftRight> >
-{
-    typedef tag::weighted_peaks_over_threshold_prob<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::weighted_peaks_over_threshold_prob<LeftRight> >
-  : feature_of<tag::peaks_over_threshold_prob<LeftRight> >
-{};
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/pot_quantile.hpp

@@ -1,205 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// pot_quantile.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_POT_QUANTILE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_POT_QUANTILE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <numeric>
-#include <functional>
-#include <boost/parameter/keyword.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/peaks_over_threshold.hpp>
-#include <boost/accumulators/statistics/weighted_peaks_over_threshold.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // pot_quantile_impl
-    //
-    /**
-        @brief Quantile Estimation based on Peaks over Threshold Method (for both left and right tails)
-
-        Computes an estimate
-        \f[
-            \hat{q}_{\alpha} = \bar{u} + \frac{\bar{\beta}}{\xi}\left[(1-\alpha)^{-\xi}-1\right]
-        \f]
-        for a right or left extreme quantile, \f$\bar[u]\f$, \f$\bar{\beta}\f$ and \f$\xi\f$ being the parameters of the
-        generalized Pareto distribution that approximates the right tail of the distribution (or the mirrored left tail,
-        in case the left tail is used). In the latter case, the result is mirrored back, yielding the correct result.
-    */
-    template<typename Sample, typename Impl, typename LeftRight>
-    struct pot_quantile_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        pot_quantile_impl(dont_care)
-          : sign_((is_same<LeftRight, left>::value) ? -1 : 1)
-        {
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            typedef
-                typename mpl::if_<
-                    is_same<Impl, weighted>
-                  , tag::weighted_peaks_over_threshold<LeftRight>
-                  , tag::peaks_over_threshold<LeftRight>
-                >::type
-            peaks_over_threshold_tag;
-
-            extractor<peaks_over_threshold_tag> const some_peaks_over_threshold = {};
-
-            float_type u_bar    = some_peaks_over_threshold(args).template get<0>();
-            float_type beta_bar = some_peaks_over_threshold(args).template get<1>();
-            float_type xi_hat   = some_peaks_over_threshold(args).template get<2>();
-
-            return this->sign_ * (u_bar + beta_bar/xi_hat * ( std::pow(
-                    is_same<LeftRight, left>::value ? args[quantile_probability] : 1. - args[quantile_probability]
-                , -xi_hat
-              ) - 1.));
-        }
-
-    private:
-        short sign_; // if the fit parameters from the mirrored left tail extreme values are used, mirror back the result
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::pot_quantile<>
-// tag::pot_quantile_prob<>
-// tag::weighted_pot_quantile<>
-// tag::weighted_pot_quantile_prob<>
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct pot_quantile
-      : depends_on<peaks_over_threshold<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_quantile_impl<mpl::_1, unweighted, LeftRight> impl;
-    };
-    template<typename LeftRight>
-    struct pot_quantile_prob
-      : depends_on<peaks_over_threshold_prob<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_quantile_impl<mpl::_1, unweighted, LeftRight> impl;
-    };
-    template<typename LeftRight>
-    struct weighted_pot_quantile
-      : depends_on<weighted_peaks_over_threshold<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_quantile_impl<mpl::_1, weighted, LeftRight> impl;
-    };
-    template<typename LeftRight>
-    struct weighted_pot_quantile_prob
-      : depends_on<weighted_peaks_over_threshold_prob<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_quantile_impl<mpl::_1, weighted, LeftRight> impl;
-    };
-}
-
-// pot_quantile<LeftRight>(with_threshold_value) -> pot_quantile<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::pot_quantile<LeftRight>(with_threshold_value)>
-{
-    typedef tag::pot_quantile<LeftRight> type;
-};
-
-// pot_quantile<LeftRight>(with_threshold_probability) -> pot_quantile_prob<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::pot_quantile<LeftRight>(with_threshold_probability)>
-{
-    typedef tag::pot_quantile_prob<LeftRight> type;
-};
-
-// weighted_pot_quantile<LeftRight>(with_threshold_value) -> weighted_pot_quantile<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::weighted_pot_quantile<LeftRight>(with_threshold_value)>
-{
-    typedef tag::weighted_pot_quantile<LeftRight> type;
-};
-
-// weighted_pot_quantile<LeftRight>(with_threshold_probability) -> weighted_pot_quantile_prob<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::weighted_pot_quantile<LeftRight>(with_threshold_probability)>
-{
-    typedef tag::weighted_pot_quantile_prob<LeftRight> type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// pot_quantile<LeftRight> and pot_quantile_prob<LeftRight> provide
-// the same feature as quantile
-template<typename LeftRight>
-struct feature_of<tag::pot_quantile<LeftRight> >
-  : feature_of<tag::quantile>
-{
-};
-
-template<typename LeftRight>
-struct feature_of<tag::pot_quantile_prob<LeftRight> >
-  : feature_of<tag::quantile>
-{
-};
-
-// So that pot_quantile can be automatically substituted
-// with weighted_pot_quantile when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::pot_quantile<LeftRight> >
-{
-    typedef tag::weighted_pot_quantile<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::weighted_pot_quantile<LeftRight> >
-  : feature_of<tag::pot_quantile<LeftRight> >
-{
-};
-
-// So that pot_quantile_prob can be automatically substituted
-// with weighted_pot_quantile_prob when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::pot_quantile_prob<LeftRight> >
-{
-    typedef tag::weighted_pot_quantile_prob<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::weighted_pot_quantile_prob<LeftRight> >
-  : feature_of<tag::pot_quantile_prob<LeftRight> >
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/pot_tail_mean.hpp

@@ -1,211 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// pot_tail_mean.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_POT_TAIL_MEAN_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_POT_TAIL_MEAN_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <numeric>
-#include <functional>
-#include <boost/range.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/peaks_over_threshold.hpp>
-#include <boost/accumulators/statistics/weighted_peaks_over_threshold.hpp>
-#include <boost/accumulators/statistics/pot_quantile.hpp>
-#include <boost/accumulators/statistics/tail_mean.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // pot_tail_mean_impl
-    //
-    /**
-        @brief Estimation of the (coherent) tail mean based on the peaks over threshold method (for both left and right tails)
-
-        Computes an estimate for the (coherent) tail mean
-        \f[
-            \widehat{CTM}_{\alpha} = \hat{q}_{\alpha} - \frac{\bar{\beta}}{\xi-1}(1-\alpha)^{-\xi},
-        \f]
-        where \f$\bar[u]\f$, \f$\bar{\beta}\f$ and \f$\xi\f$ are the parameters of the
-        generalized Pareto distribution that approximates the right tail of the distribution (or the
-        mirrored left tail, in case the left tail is used). In the latter case, the result is mirrored
-        back, yielding the correct result.
-    */
-    template<typename Sample, typename Impl, typename LeftRight>
-    struct pot_tail_mean_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        pot_tail_mean_impl(dont_care)
-          : sign_((is_same<LeftRight, left>::value) ? -1 : 1)
-        {
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            typedef
-                typename mpl::if_<
-                    is_same<Impl, weighted>
-                  , tag::weighted_peaks_over_threshold<LeftRight>
-                  , tag::peaks_over_threshold<LeftRight>
-                >::type
-            peaks_over_threshold_tag;
-
-            typedef
-                typename mpl::if_<
-                    is_same<Impl, weighted>
-                  , tag::weighted_pot_quantile<LeftRight>
-                  , tag::pot_quantile<LeftRight>
-                >::type
-            pot_quantile_tag;
-
-            extractor<peaks_over_threshold_tag> const some_peaks_over_threshold = {};
-            extractor<pot_quantile_tag> const some_pot_quantile = {};
-
-            float_type beta_bar = some_peaks_over_threshold(args).template get<1>();
-            float_type xi_hat   = some_peaks_over_threshold(args).template get<2>();
-
-            return some_pot_quantile(args) - this->sign_ * beta_bar/( xi_hat - 1. ) * std::pow(
-                is_same<LeftRight, left>::value ? args[quantile_probability] : 1. - args[quantile_probability]
-              , -xi_hat);
-        }
-    private:
-        short sign_; // if the fit parameters from the mirrored left tail extreme values are used, mirror back the result
-    };
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::pot_tail_mean
-// tag::pot_tail_mean_prob
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct pot_tail_mean
-      : depends_on<peaks_over_threshold<LeftRight>, pot_quantile<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_tail_mean_impl<mpl::_1, unweighted, LeftRight> impl;
-    };
-    template<typename LeftRight>
-    struct pot_tail_mean_prob
-      : depends_on<peaks_over_threshold_prob<LeftRight>, pot_quantile_prob<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_tail_mean_impl<mpl::_1, unweighted, LeftRight> impl;
-    };
-    template<typename LeftRight>
-    struct weighted_pot_tail_mean
-      : depends_on<weighted_peaks_over_threshold<LeftRight>, weighted_pot_quantile<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_tail_mean_impl<mpl::_1, weighted, LeftRight> impl;
-    };
-    template<typename LeftRight>
-    struct weighted_pot_tail_mean_prob
-      : depends_on<weighted_peaks_over_threshold_prob<LeftRight>, weighted_pot_quantile_prob<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::pot_tail_mean_impl<mpl::_1, weighted, LeftRight> impl;
-    };
-}
-
-// pot_tail_mean<LeftRight>(with_threshold_value) -> pot_tail_mean<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_value)>
-{
-    typedef tag::pot_tail_mean<LeftRight> type;
-};
-
-// pot_tail_mean<LeftRight>(with_threshold_probability) -> pot_tail_mean_prob<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_probability)>
-{
-    typedef tag::pot_tail_mean_prob<LeftRight> type;
-};
-
-// weighted_pot_tail_mean<LeftRight>(with_threshold_value) -> weighted_pot_tail_mean<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_threshold_value)>
-{
-    typedef tag::weighted_pot_tail_mean<LeftRight> type;
-};
-
-// weighted_pot_tail_mean<LeftRight>(with_threshold_probability) -> weighted_pot_tail_mean_prob<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_threshold_probability)>
-{
-    typedef tag::weighted_pot_tail_mean_prob<LeftRight> type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// pot_tail_mean<LeftRight> and pot_tail_mean_prob<LeftRight> provide
-// the same feature as tail_mean
-template<typename LeftRight>
-struct feature_of<tag::pot_tail_mean<LeftRight> >
-  : feature_of<tag::tail_mean>
-{
-};
-
-template<typename LeftRight>
-struct feature_of<tag::pot_tail_mean_prob<LeftRight> >
-  : feature_of<tag::tail_mean>
-{
-};
-
-// So that pot_tail_mean can be automatically substituted
-// with weighted_pot_tail_mean when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::pot_tail_mean<LeftRight> >
-{
-    typedef tag::weighted_pot_tail_mean<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::weighted_pot_tail_mean<LeftRight> >
-  : feature_of<tag::pot_tail_mean<LeftRight> >
-{
-};
-
-// So that pot_tail_mean_prob can be automatically substituted
-// with weighted_pot_tail_mean_prob when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::pot_tail_mean_prob<LeftRight> >
-{
-    typedef tag::weighted_pot_tail_mean_prob<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::weighted_pot_tail_mean_prob<LeftRight> >
-  : feature_of<tag::pot_tail_mean_prob<LeftRight> >
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/rolling_count.hpp

@@ -1,80 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// rolling_count.hpp
-//
-// Copyright 2008 Eric Niebler. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_ROLLING_COUNT_HPP_EAN_26_12_2008
-#define BOOST_ACCUMULATORS_STATISTICS_ROLLING_COUNT_HPP_EAN_26_12_2008
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/rolling_window.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // rolling_count_impl
-    //    returns the count of elements in the rolling window
-    template<typename Sample>
-    struct rolling_count_impl
-      : accumulator_base
-    {
-        typedef std::size_t result_type;
-
-        rolling_count_impl(dont_care)
-        {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return static_cast<std::size_t>(rolling_window_plus1(args).size()) - is_rolling_window_plus1_full(args);
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::rolling_count
-//
-namespace tag
-{
-    struct rolling_count
-      : depends_on< rolling_window_plus1 >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::rolling_count_impl< mpl::_1 > impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::rolling_window::window_size named parameter
-        static boost::parameter::keyword<tag::rolling_window_size> const window_size;
-        #endif
-    };
-} // namespace tag
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::rolling_count
-//
-namespace extract
-{
-    extractor<tag::rolling_count> const rolling_count = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_count)
-}
-
-using extract::rolling_count;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/rolling_mean.hpp

@@ -1,81 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// rolling_mean.hpp
-//
-// Copyright 2008 Eric Niebler. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_ROLLING_MEAN_HPP_EAN_26_12_2008
-#define BOOST_ACCUMULATORS_STATISTICS_ROLLING_MEAN_HPP_EAN_26_12_2008
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/rolling_sum.hpp>
-#include <boost/accumulators/statistics/rolling_count.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // rolling_mean_impl
-    //    returns the unshifted results from the shifted rolling window
-    template<typename Sample>
-    struct rolling_mean_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        rolling_mean_impl(dont_care)
-        {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return numeric::average(rolling_sum(args), rolling_count(args));
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::rolling_mean
-//
-namespace tag
-{
-    struct rolling_mean
-      : depends_on< rolling_sum, rolling_count >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::rolling_mean_impl< mpl::_1 > impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::rolling_window::window_size named parameter
-        static boost::parameter::keyword<tag::rolling_window_size> const window_size;
-        #endif
-    };
-} // namespace tag
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::rolling_mean
-//
-namespace extract
-{
-    extractor<tag::rolling_mean> const rolling_mean = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_mean)
-}
-
-using extract::rolling_mean;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/rolling_sum.hpp

@@ -1,93 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// rolling_sum.hpp
-//
-// Copyright 2008 Eric Niebler. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_ROLLING_SUM_HPP_EAN_26_12_2008
-#define BOOST_ACCUMULATORS_STATISTICS_ROLLING_SUM_HPP_EAN_26_12_2008
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/rolling_window.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // rolling_sum_impl
-    //    returns the sum of the samples in the rolling window
-    template<typename Sample>
-    struct rolling_sum_impl
-      : accumulator_base
-    {
-        typedef Sample result_type;
-
-        template<typename Args>
-        rolling_sum_impl(Args const &args)
-          : sum_(args[sample | Sample()])
-        {}
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            if(is_rolling_window_plus1_full(args))
-            {
-                this->sum_ -= rolling_window_plus1(args).front();
-            }
-            this->sum_ += args[sample];
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return this->sum_;
-        }
-
-    private:
-        Sample sum_;
-    };
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::rolling_sum
-//
-namespace tag
-{
-    struct rolling_sum
-      : depends_on< rolling_window_plus1 >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::rolling_sum_impl< mpl::_1 > impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::rolling_window::window_size named parameter
-        static boost::parameter::keyword<tag::rolling_window_size> const window_size;
-        #endif
-    };
-} // namespace tag
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::rolling_sum
-//
-namespace extract
-{
-    extractor<tag::rolling_sum> const rolling_sum = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_sum)
-}
-
-using extract::rolling_sum;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/rolling_window.hpp

@@ -1,169 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// rolling_window.hpp
-//
-// Copyright 2008 Eric Niebler. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_ROLLING_WINDOW_HPP_EAN_26_12_2008
-#define BOOST_ACCUMULATORS_STATISTICS_ROLLING_WINDOW_HPP_EAN_26_12_2008
-
-#include <cstddef>
-#include <boost/version.hpp>
-#include <boost/assert.hpp>
-#include <boost/circular_buffer.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/parameters/accumulator.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::rolling_window::size named parameter
-BOOST_PARAMETER_NESTED_KEYWORD(tag, rolling_window_size, window_size)
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // rolling_window_plus1_impl
-    //    stores the latest N+1 samples, where N is specified at construction time
-    //    with the rolling_window_size named parameter
-    template<typename Sample>
-    struct rolling_window_plus1_impl
-      : accumulator_base
-    {
-        typedef typename circular_buffer<Sample>::const_iterator const_iterator;
-        typedef iterator_range<const_iterator> result_type;
-
-        template<typename Args>
-        rolling_window_plus1_impl(Args const & args)
-          : buffer_(args[rolling_window_size] + 1)
-        {}
-
-        #if BOOST_VERSION < 103600
-        // Before Boost 1.36, copying a circular buffer didn't copy
-        // it's capacity, and we need that behavior.
-        rolling_window_plus1_impl(rolling_window_plus1_impl const &that)
-          : buffer_(that.buffer_)
-        {
-            this->buffer_.set_capacity(that.buffer_.capacity());
-        }
-
-        rolling_window_plus1_impl &operator =(rolling_window_plus1_impl const &that)
-        {
-            this->buffer_ = that.buffer_;
-            this->buffer_.set_capacity(that.buffer_.capacity());
-        }
-        #endif
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->buffer_.push_back(args[sample]);
-        }
-
-        bool full() const
-        {
-            return this->buffer_.full();
-        }
-
-        // The result of a shifted rolling window is the range including
-        // everything except the most recently added element.
-        result_type result(dont_care) const
-        {
-            return result_type(this->buffer_.begin(), this->buffer_.end());
-        }
-
-    private:
-        circular_buffer<Sample> buffer_;
-    };
-
-    template<typename Args>
-    bool is_rolling_window_plus1_full(Args const &args)
-    {
-        return find_accumulator<tag::rolling_window_plus1>(args[accumulator]).full();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // rolling_window_impl
-    //    stores the latest N samples, where N is specified at construction type
-    //    with the rolling_window_size named parameter
-    template<typename Sample>
-    struct rolling_window_impl
-      : accumulator_base
-    {
-        typedef typename circular_buffer<Sample>::const_iterator const_iterator;
-        typedef iterator_range<const_iterator> result_type;
-
-        rolling_window_impl(dont_care)
-        {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return rolling_window_plus1(args).advance_begin(is_rolling_window_plus1_full(args));
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::rolling_window_plus1
-// tag::rolling_window
-//
-namespace tag
-{
-    struct rolling_window_plus1
-      : depends_on<>
-      , tag::rolling_window_size
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::rolling_window_plus1_impl< mpl::_1 > impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::rolling_window::size named parameter
-        static boost::parameter::keyword<tag::rolling_window_size> const window_size;
-        #endif
-    };
-
-    struct rolling_window
-      : depends_on< rolling_window_plus1 >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::rolling_window_impl< mpl::_1 > impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::rolling_window::size named parameter
-        static boost::parameter::keyword<tag::rolling_window_size> const window_size;
-        #endif
-    };
-
-} // namespace tag
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::rolling_window_plus1
-// extract::rolling_window
-//
-namespace extract
-{
-    extractor<tag::rolling_window_plus1> const rolling_window_plus1 = {};
-    extractor<tag::rolling_window> const rolling_window = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_window_plus1)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_window)
-}
-
-using extract::rolling_window_plus1;
-using extract::rolling_window;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/skewness.hpp

@@ -1,114 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// skewness.hpp
-//
-//  Copyright 2006 Olivier Gygi, Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_SKEWNESS_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_SKEWNESS_HPP_EAN_28_10_2005
-
-#include <limits>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/moment.hpp>
-#include <boost/accumulators/statistics/mean.hpp>
-
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // skewness_impl
-    /**
-        @brief Skewness estimation
-
-        The skewness of a sample distribution is defined as the ratio of the 3rd central moment and the \f$ 3/2 \f$-th power
-        of the 2nd central moment (the variance) of the sampless 3. The skewness can also be expressed by the simple moments:
-
-        \f[
-            \hat{g}_1 =
-                \frac
-                {\widehat{m}_n^{(3)}-3\widehat{m}_n^{(2)}\hat{\mu}_n+2\hat{\mu}_n^3}
-                {\left(\widehat{m}_n^{(2)} - \hat{\mu}_n^{2}\right)^{3/2}}
-        \f]
-
-        where \f$ \widehat{m}_n^{(i)} \f$ are the \f$ i \f$-th moment and \f$ \hat{\mu}_n \f$ the mean (first moment) of the
-        \f$ n \f$ samples.
-    */
-    template<typename Sample>
-    struct skewness_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, Sample>::result_type result_type;
-
-        skewness_impl(dont_care)
-        {
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return numeric::average(
-                        accumulators::moment<3>(args)
-                        - 3. * accumulators::moment<2>(args) * mean(args)
-                        + 2. * mean(args) * mean(args) * mean(args)
-                      , ( accumulators::moment<2>(args) - mean(args) * mean(args) )
-                        * std::sqrt( accumulators::moment<2>(args) - mean(args) * mean(args) )
-                   );
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::skewness
-//
-namespace tag
-{
-    struct skewness
-      : depends_on<mean, moment<2>, moment<3> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::skewness_impl<mpl::_1> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::skewness
-//
-namespace extract
-{
-    extractor<tag::skewness> const skewness = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(skewness)
-}
-
-using extract::skewness;
-
-// So that skewness can be automatically substituted with
-// weighted_skewness when the weight parameter is non-void
-template<>
-struct as_weighted_feature<tag::skewness>
-{
-    typedef tag::weighted_skewness type;
-};
-
-template<>
-struct feature_of<tag::weighted_skewness>
-  : feature_of<tag::skewness>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/stats.hpp

@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-/// \file stats.hpp
-/// Contains the stats<> template.
-///
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_STATS_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_STATS_HPP_EAN_28_10_2005
-
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-///////////////////////////////////////////////////////////////////////////////
-/// An MPL sequence of statistics.
-template<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, typename Stat)>
-struct stats
-  : mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Stat)>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/sum.hpp

@@ -1,141 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// sum.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_SUM_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_SUM_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/parameters/weight.hpp>
-#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // sum_impl
-    template<typename Sample, typename Tag>
-    struct sum_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef Sample result_type;
-
-        template<typename Args>
-        sum_impl(Args const &args)
-          : sum(args[parameter::keyword<Tag>::get() | Sample()])
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            // what about overflow?
-            this->sum += args[parameter::keyword<Tag>::get()];
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->sum;
-        }
-
-    private:
-
-        Sample sum;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::sum
-// tag::sum_of_weights
-// tag::sum_of_variates
-//
-namespace tag
-{
-    struct sum
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::sum_impl<mpl::_1, tag::sample> impl;
-    };
-
-    struct sum_of_weights
-      : depends_on<>
-    {
-        typedef mpl::true_ is_weight_accumulator;
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::sum_impl<mpl::_2, tag::weight> impl;
-    };
-
-    template<typename VariateType, typename VariateTag>
-    struct sum_of_variates
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::sum_impl<VariateType, VariateTag> > impl;
-    };
-
-    struct abstract_sum_of_variates
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::sum
-// extract::sum_of_weights
-// extract::sum_of_variates
-//
-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 = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_of_weights)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_of_variates)
-}
-
-using extract::sum;
-using extract::sum_of_weights;
-using extract::sum_of_variates;
-
-// So that mean can be automatically substituted with
-// weighted_mean when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::sum>
-{
-    typedef tag::weighted_sum type;
-};
-
-template<>
-struct feature_of<tag::weighted_sum>
-  : feature_of<tag::sum>
-{};
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::sum_of_variates<VariateType, VariateTag> >
-  : feature_of<tag::abstract_sum_of_variates>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/sum_kahan.hpp

@@ -1,188 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// sum_kahan.hpp
-//
-//  Copyright 2010 Gaetano Mendola, 2011 Simon West. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_SUM_KAHAN_HPP_EAN_26_07_2010
-#define BOOST_ACCUMULATORS_STATISTICS_SUM_KAHAN_HPP_EAN_26_07_2010
-
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/weighted_sum_kahan.hpp>
-#include <boost/numeric/conversion/cast.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-#if _MSC_VER > 1400
-# pragma float_control(push)
-# pragma float_control(precise, on)
-#endif
-
-template<typename Sample, typename Tag>
-struct sum_kahan_impl
-  : accumulator_base
-{
-    typedef Sample result_type;
-
-    ////////////////////////////////////////////////////////////////////////////
-    // sum_kahan_impl
-    /**
-        @brief Kahan summation algorithm
-
-        The Kahan summation algorithm reduces the numerical error obtained with standard
-        sequential sum.
-
-    */
-    template<typename Args>
-    sum_kahan_impl(Args const & args)
-      : sum(args[parameter::keyword<Tag>::get() | Sample()]),
-        compensation(boost::numeric_cast<Sample>(0.0))
-    {
-    }
-
-    template<typename Args>
-    void 
-#if BOOST_ACCUMULATORS_GCC_VERSION > 40305
-    __attribute__((optimize("no-associative-math")))
-#endif
-    operator ()(Args const & args)
-    {
-        const Sample myTmp1 = args[parameter::keyword<Tag>::get()] - this->compensation;
-        const Sample myTmp2 = this->sum + myTmp1;
-        this->compensation = (myTmp2 - this->sum) - myTmp1;
-        this->sum = myTmp2;
-    }
-
-    result_type result(dont_care) const
-    {
-      return this->sum;
-    }
-
-private:
-    Sample sum;
-    Sample compensation;
-};
-
-#if _MSC_VER > 1400
-# pragma float_control(pop)
-#endif
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::sum_kahan
-// tag::sum_of_weights_kahan
-// tag::sum_of_variates_kahan
-//
-namespace tag
-{
-
-    struct sum_kahan
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef impl::sum_kahan_impl< mpl::_1, tag::sample > impl;
-    };
-
-    struct sum_of_weights_kahan
-      : depends_on<>
-    {
-        typedef mpl::true_ is_weight_accumulator;
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::sum_kahan_impl<mpl::_2, tag::weight> impl;
-    };
-
-    template<typename VariateType, typename VariateTag>
-    struct sum_of_variates_kahan
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::sum_kahan_impl<VariateType, VariateTag> > impl;
-    };
-
-} // namespace tag
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::sum_kahan
-// extract::sum_of_weights_kahan
-// extract::sum_of_variates_kahan
-//
-namespace extract
-{
-    extractor<tag::sum_kahan> const sum_kahan = {};
-    extractor<tag::sum_of_weights_kahan> const sum_of_weights_kahan = {};
-    extractor<tag::abstract_sum_of_variates> const sum_of_variates_kahan = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_kahan)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_of_weights_kahan)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_of_variates_kahan)
-} // namespace extract
-
-using extract::sum_kahan;
-using extract::sum_of_weights_kahan;
-using extract::sum_of_variates_kahan;
-
-// sum(kahan) -> sum_kahan
-template<>
-struct as_feature<tag::sum(kahan)>
-{
-    typedef tag::sum_kahan type;
-};
-
-// sum_of_weights(kahan) -> sum_of_weights_kahan
-template<>
-struct as_feature<tag::sum_of_weights(kahan)>
-{
-    typedef tag::sum_of_weights_kahan type;
-};
-
-// So that sum_kahan can be automatically substituted with
-// weighted_sum_kahan when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::sum_kahan>
-{
-    typedef tag::weighted_sum_kahan type;
-};
-
-template<>
-struct feature_of<tag::weighted_sum_kahan>
-  : feature_of<tag::sum>
-{};
-
-// for the purposes of feature-based dependency resolution,
-// sum_kahan provides the same feature as sum
-template<>
-struct feature_of<tag::sum_kahan>
-  : feature_of<tag::sum>
-{
-};
-
-// for the purposes of feature-based dependency resolution,
-// sum_of_weights_kahan provides the same feature as sum_of_weights
-template<>
-struct feature_of<tag::sum_of_weights_kahan>
-  : feature_of<tag::sum_of_weights>
-{
-};
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::sum_of_variates_kahan<VariateType, VariateTag> >
-  : feature_of<tag::abstract_sum_of_variates>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif
-

test/external/boost/accumulators/statistics/tail.hpp

@@ -1,334 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// tail.hpp
-//
-//  Copyright 2005 Eric Niebler, Michael Gauckler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_TAIL_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_TAIL_HPP_EAN_28_10_2005
-
-#include <vector>
-#include <functional>
-#include <boost/assert.hpp>
-#include <boost/range.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/iterator/permutation_iterator.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-///////////////////////////////////////////////////////////////////////////////
-// cache_size named parameters
-BOOST_PARAMETER_NESTED_KEYWORD(tag, right_tail_cache_size, cache_size)
-BOOST_PARAMETER_NESTED_KEYWORD(tag, left_tail_cache_size, cache_size)
-
-namespace detail
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // tail_range
-    /// INTERNAL ONLY
-    ///
-    template<typename ElementIterator, typename IndexIterator>
-    struct tail_range
-    {
-        typedef boost::iterator_range<
-            boost::reverse_iterator<boost::permutation_iterator<ElementIterator, IndexIterator> >
-        > type;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // make_tail_range
-    /// INTERNAL ONLY
-    ///
-    template<typename ElementIterator, typename IndexIterator>
-    typename tail_range<ElementIterator, IndexIterator>::type
-    make_tail_range(ElementIterator elem_begin, IndexIterator index_begin, IndexIterator index_end)
-    {
-        return boost::make_iterator_range(
-            boost::make_reverse_iterator(
-                boost::make_permutation_iterator(elem_begin, index_end)
-            )
-          , boost::make_reverse_iterator(
-                boost::make_permutation_iterator(elem_begin, index_begin)
-            )
-        );
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // stat_assign_visitor
-    /// INTERNAL ONLY
-    ///
-    template<typename Args>
-    struct stat_assign_visitor
-    {
-        stat_assign_visitor(Args const &a, std::size_t i)
-          : args(a)
-          , index(i)
-        {
-        }
-
-        template<typename Stat>
-        void operator ()(Stat &stat) const
-        {
-            stat.assign(this->args, this->index);
-        }
-
-    private:
-        stat_assign_visitor &operator =(stat_assign_visitor const &);
-        Args const &args;
-        std::size_t index;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // stat_assign
-    /// INTERNAL ONLY
-    ///
-    template<typename Args>
-    inline stat_assign_visitor<Args> const stat_assign(Args const &args, std::size_t index)
-    {
-        return stat_assign_visitor<Args>(args, index);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // is_tail_variate_feature
-    /// INTERNAL ONLY
-    ///
-    template<typename Stat, typename LeftRight>
-    struct is_tail_variate_feature
-      : mpl::false_
-    {
-    };
-
-    /// INTERNAL ONLY
-    ///
-    template<typename VariateType, typename VariateTag, typename LeftRight>
-    struct is_tail_variate_feature<tag::tail_variate<VariateType, VariateTag, LeftRight>, LeftRight>
-      : mpl::true_
-    {
-    };
-
-    /// INTERNAL ONLY
-    ///
-    template<typename LeftRight>
-    struct is_tail_variate_feature<tag::tail_weights<LeftRight>, LeftRight>
-      : mpl::true_
-    {
-    };
-
-} // namespace detail
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // tail_impl
-    template<typename Sample, typename LeftRight>
-    struct tail_impl
-      : accumulator_base
-    {
-        // LeftRight must be either right or left
-        BOOST_MPL_ASSERT((
-            mpl::or_<is_same<LeftRight, right>, is_same<LeftRight, left> >
-        ));
-
-        typedef
-            typename mpl::if_<
-                is_same<LeftRight, right>
-              , numeric::functional::greater<Sample const, Sample const>
-              , numeric::functional::less<Sample const, Sample const>
-            >::type
-        predicate_type;
-
-        // for boost::result_of
-        typedef typename detail::tail_range<
-            typename std::vector<Sample>::const_iterator
-          , std::vector<std::size_t>::iterator
-        >::type result_type;
-
-        template<typename Args>
-        tail_impl(Args const &args)
-          : is_sorted(false)
-          , indices()
-          , samples(args[tag::tail<LeftRight>::cache_size], args[sample | Sample()])
-        {
-            this->indices.reserve(this->samples.size());
-        }
-
-        tail_impl(tail_impl const &that)
-          : is_sorted(that.is_sorted)
-          , indices(that.indices)
-          , samples(that.samples)
-        {
-            this->indices.reserve(this->samples.size());
-        }
-
-        // This just stores the heap and the samples.
-        // In operator()() below, if we are adding a new sample
-        // to the sample cache, we force all the
-        // tail_variates to update also. (It's not
-        // good enough to wait for the accumulator_set to do it
-        // for us because then information about whether a sample
-        // was stored and where is lost, and would need to be
-        // queried at runtime, which would be slow.) This is
-        // implemented as a filtered visitation over the stats,
-        // which we can access because args[accumulator] gives us
-        // all the stats.
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            if(this->indices.size() < this->samples.size())
-            {
-                this->indices.push_back(this->indices.size());
-                this->assign(args, this->indices.back());
-            }
-            else if(predicate_type()(args[sample], this->samples[this->indices[0]]))
-            {
-                std::pop_heap(this->indices.begin(), this->indices.end(), indirect_cmp(this->samples));
-                this->assign(args, this->indices.back());
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            if(!this->is_sorted)
-            {
-                // Must use the same predicate here as in push_heap/pop_heap above.
-                std::sort_heap(this->indices.begin(), this->indices.end(), indirect_cmp(this->samples));
-                // sort_heap puts elements in reverse order. Calling std::reverse
-                // turns the sorted sequence back into a valid heap.
-                std::reverse(this->indices.begin(), this->indices.end());
-                this->is_sorted = true;
-            }
-
-            return detail::make_tail_range(
-                this->samples.begin()
-              , this->indices.begin()
-              , this->indices.end()
-            );
-        }
-
-    private:
-
-        struct is_tail_variate
-        {
-            template<typename T>
-            struct apply
-              : detail::is_tail_variate_feature<
-                    typename detail::feature_tag<T>::type
-                  , LeftRight
-                >
-            {};
-        };
-
-        template<typename Args>
-        void assign(Args const &args, std::size_t index)
-        {
-            BOOST_ASSERT(index < this->samples.size());
-            this->samples[index] = args[sample];
-            std::push_heap(this->indices.begin(), this->indices.end(), indirect_cmp(this->samples));
-            this->is_sorted = false;
-            // Tell the tail variates to store their values also
-            args[accumulator].template visit_if<is_tail_variate>(detail::stat_assign(args, index));
-        }
-
-        ///////////////////////////////////////////////////////////////////////////////
-        //
-        struct indirect_cmp
-          : std::binary_function<std::size_t, std::size_t, bool>
-        {
-            indirect_cmp(std::vector<Sample> const &s)
-              : samples(s)
-            {
-            }
-
-            bool operator ()(std::size_t left, std::size_t right) const
-            {
-                return predicate_type()(this->samples[left], this->samples[right]);
-            }
-
-        private:
-            indirect_cmp &operator =(indirect_cmp const &);
-            std::vector<Sample> const &samples;
-        };
-
-        mutable bool is_sorted;
-        mutable std::vector<std::size_t> indices;
-        std::vector<Sample> samples;
-    };
-
-} // namespace impl
-
-// TODO The templatized tag::tail below should inherit from the correct named parameter.
-// The following lines provide a workaround, but there must be a better way of doing this.
-template<typename T>
-struct tail_cache_size_named_arg
-{
-};
-template<>
-struct tail_cache_size_named_arg<left>
-  : tag::left_tail_cache_size
-{
-};
-template<>
-struct tail_cache_size_named_arg<right>
-  : tag::right_tail_cache_size
-{
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::tail<>
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct tail
-      : depends_on<>
-      , tail_cache_size_named_arg<LeftRight>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::tail_impl<mpl::_1, LeftRight> impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        /// tag::tail<LeftRight>::cache_size named parameter
-        static boost::parameter::keyword<tail_cache_size_named_arg<LeftRight> > const cache_size;
-        #endif
-    };
-
-    struct abstract_tail
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::tail
-//
-namespace extract
-{
-    extractor<tag::abstract_tail> const tail = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(tail)
-}
-
-using extract::tail;
-
-template<typename LeftRight>
-struct feature_of<tag::tail<LeftRight> >
-  : feature_of<tag::abstract_tail>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/tail_mean.hpp

@@ -1,246 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// tail_mean.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_TAIL_MEAN_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_TAIL_MEAN_HPP_DE_01_01_2006
-
-#include <numeric>
-#include <vector>
-#include <limits>
-#include <functional>
-#include <sstream>
-#include <stdexcept>
-#include <boost/throw_exception.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/tail_quantile.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // coherent_tail_mean_impl
-    //
-    /**
-        @brief Estimation of the coherent tail mean based on order statistics (for both left and right tails)
-
-        The coherent tail mean \f$\widehat{CTM}_{n,\alpha}(X)\f$ is equal to the non-coherent tail mean \f$\widehat{NCTM}_{n,\alpha}(X)\f$
-        plus a correction term that ensures coherence in case of non-continuous distributions.
-
-        \f[
-            \widehat{CTM}_{n,\alpha}^{\mathrm{right}}(X) = \widehat{NCTM}_{n,\alpha}^{\mathrm{right}}(X) +
-            \frac{1}{\lceil n(1-\alpha)\rceil}\hat{q}_{n,\alpha}(X)\left(1 - \alpha - \frac{1}{n}\lceil n(1-\alpha)\rceil \right)
-        \f]
-
-        \f[
-            \widehat{CTM}_{n,\alpha}^{\mathrm{left}}(X) = \widehat{NCTM}_{n,\alpha}^{\mathrm{left}}(X) +
-            \frac{1}{\lceil n\alpha\rceil}\hat{q}_{n,\alpha}(X)\left(\alpha - \frac{1}{n}\lceil n\alpha\rceil \right)
-        \f]
-    */
-    template<typename Sample, typename LeftRight>
-    struct coherent_tail_mean_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        coherent_tail_mean_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            std::size_t cnt = count(args);
-
-            std::size_t n = static_cast<std::size_t>(
-                std::ceil(
-                    cnt * ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] )
-                )
-            );
-
-            extractor<tag::non_coherent_tail_mean<LeftRight> > const some_non_coherent_tail_mean = {};
-
-            return some_non_coherent_tail_mean(args)
-                 + numeric::average(quantile(args), n)
-                 * (
-                     ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability]
-                     - numeric::average(n, count(args))
-                   );
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // non_coherent_tail_mean_impl
-    //
-    /**
-        @brief Estimation of the (non-coherent) tail mean based on order statistics (for both left and right tails)
-
-        An estimation of the non-coherent tail mean \f$\widehat{NCTM}_{n,\alpha}(X)\f$ is given by the mean of the
-        \f$\lceil n\alpha\rceil\f$ smallest samples (left tail) or the mean of the  \f$\lceil n(1-\alpha)\rceil\f$
-        largest samples (right tail), \f$n\f$ being the total number of samples and \f$\alpha\f$ the quantile level:
-
-        \f[
-            \widehat{NCTM}_{n,\alpha}^{\mathrm{right}}(X) = \frac{1}{\lceil n(1-\alpha)\rceil} \sum_{i=\lceil \alpha n \rceil}^n X_{i:n}
-        \f]
-
-        \f[
-            \widehat{NCTM}_{n,\alpha}^{\mathrm{left}}(X) = \frac{1}{\lceil n\alpha\rceil} \sum_{i=1}^{\lceil \alpha n \rceil} X_{i:n}
-        \f]
-
-        It thus requires the caching of at least the \f$\lceil n\alpha\rceil\f$ smallest or the \f$\lceil n(1-\alpha)\rceil\f$
-        largest samples.
-
-        @param quantile_probability
-    */
-    template<typename Sample, typename LeftRight>
-    struct non_coherent_tail_mean_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        non_coherent_tail_mean_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            std::size_t cnt = count(args);
-
-            std::size_t n = static_cast<std::size_t>(
-                std::ceil(
-                    cnt * ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] )
-                )
-            );
-
-            // If n is in a valid range, return result, otherwise return NaN or throw exception
-            if (n <= static_cast<std::size_t>(tail(args).size()))
-                return numeric::average(
-                    std::accumulate(
-                        tail(args).begin()
-                      , tail(args).begin() + n
-                      , Sample(0)
-                    )
-                  , n
-                );
-            else
-            {
-                if (std::numeric_limits<result_type>::has_quiet_NaN)
-                {
-                    return std::numeric_limits<result_type>::quiet_NaN();
-                }
-                else
-                {
-                    std::ostringstream msg;
-                    msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                    boost::throw_exception(std::runtime_error(msg.str()));
-                    return Sample(0);
-                }
-            }
-        }
-    };
-
-} // namespace impl
-
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::coherent_tail_mean<>
-// tag::non_coherent_tail_mean<>
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct coherent_tail_mean
-      : depends_on<count, quantile, non_coherent_tail_mean<LeftRight> >
-    {
-        typedef accumulators::impl::coherent_tail_mean_impl<mpl::_1, LeftRight> impl;
-    };
-
-    template<typename LeftRight>
-    struct non_coherent_tail_mean
-      : depends_on<count, tail<LeftRight> >
-    {
-        typedef accumulators::impl::non_coherent_tail_mean_impl<mpl::_1, LeftRight> impl;
-    };
-
-    struct abstract_non_coherent_tail_mean
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::non_coherent_tail_mean;
-// extract::coherent_tail_mean;
-//
-namespace extract
-{
-    extractor<tag::abstract_non_coherent_tail_mean> const non_coherent_tail_mean = {};
-    extractor<tag::tail_mean> const coherent_tail_mean = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(non_coherent_tail_mean)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(coherent_tail_mean)
-}
-
-using extract::non_coherent_tail_mean;
-using extract::coherent_tail_mean;
-
-// for the purposes of feature-based dependency resolution,
-// coherent_tail_mean<LeftRight> provides the same feature as tail_mean
-template<typename LeftRight>
-struct feature_of<tag::coherent_tail_mean<LeftRight> >
-  : feature_of<tag::tail_mean>
-{
-};
-
-template<typename LeftRight>
-struct feature_of<tag::non_coherent_tail_mean<LeftRight> >
-  : feature_of<tag::abstract_non_coherent_tail_mean>
-{
-};
-
-// So that non_coherent_tail_mean can be automatically substituted
-// with weighted_non_coherent_tail_mean when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::non_coherent_tail_mean<LeftRight> >
-{
-    typedef tag::non_coherent_weighted_tail_mean<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::non_coherent_weighted_tail_mean<LeftRight> >
-  : feature_of<tag::non_coherent_tail_mean<LeftRight> >
-{};
-
-// NOTE that non_coherent_tail_mean cannot be feature-grouped with tail_mean,
-// which is the base feature for coherent tail means, since (at least for
-// non-continuous distributions) non_coherent_tail_mean is a different measure!
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/tail_quantile.hpp

@@ -1,158 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// tail_quantile.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_TAIL_QUANTILE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_TAIL_QUANTILE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <functional>
-#include <sstream>
-#include <stdexcept>
-#include <boost/config/no_tr1/cmath.hpp>             // For ceil
-#include <boost/throw_exception.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // tail_quantile_impl
-    //  Tail quantile estimation based on order statistics
-    /**
-        @brief Tail quantile estimation based on order statistics (for both left and right tails)
-
-        The estimation of a tail quantile \f$\hat{q}\f$ with level \f$\alpha\f$ based on order statistics requires the
-        chaching of at least the \f$\lceil n\alpha\rceil\f$ smallest or the \f$\lceil n(1-\alpha)\rceil\f$ largest samples,
-        \f$n\f$ being the total number of samples. The largest of the \f$\lceil n\alpha\rceil\f$ smallest samples or the
-        smallest of the \f$\lceil n(1-\alpha)\rceil\f$ largest samples provides an estimate for the quantile:
-
-        \f[
-            \hat{q}_{n,\alpha} = X_{\lceil \alpha n \rceil:n}
-        \f]
-
-        @param quantile_probability
-    */
-    template<typename Sample, typename LeftRight>
-    struct tail_quantile_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef Sample result_type;
-
-        tail_quantile_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            std::size_t cnt = count(args);
-
-            std::size_t n = static_cast<std::size_t>(
-                std::ceil(
-                    cnt * ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] )
-                )
-            );
-
-            // If n is in a valid range, return result, otherwise return NaN or throw exception
-            if ( n < static_cast<std::size_t>(tail(args).size()))
-            {
-               // Note that the cached samples of the left are sorted in ascending order,
-               // whereas the samples of the right tail are sorted in descending order
-               return *(boost::begin(tail(args)) + n - 1);
-            }
-            else
-            {
-                if (std::numeric_limits<result_type>::has_quiet_NaN)
-                {
-                    return std::numeric_limits<result_type>::quiet_NaN();
-                }
-                else
-                {
-                    std::ostringstream msg;
-                    msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                    boost::throw_exception(std::runtime_error(msg.str()));
-                    return Sample(0);
-                }
-            }
-        }
-    };
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::tail_quantile<>
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct tail_quantile
-      : depends_on<count, tail<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::tail_quantile_impl<mpl::_1, LeftRight> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::tail_quantile
-//
-namespace extract
-{
-    extractor<tag::quantile> const tail_quantile = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(tail_quantile)
-}
-
-using extract::tail_quantile;
-
-// for the purposes of feature-based dependency resolution,
-// tail_quantile<LeftRight> provide the same feature as quantile
-template<typename LeftRight>
-struct feature_of<tag::tail_quantile<LeftRight> >
-  : feature_of<tag::quantile>
-{
-};
-
-// So that tail_quantile can be automatically substituted with
-// weighted_tail_quantile when the weight parameter is non-void.
-template<typename LeftRight>
-struct as_weighted_feature<tag::tail_quantile<LeftRight> >
-{
-    typedef tag::weighted_tail_quantile<LeftRight> type;
-};
-
-template<typename LeftRight>
-struct feature_of<tag::weighted_tail_quantile<LeftRight> >
-  : feature_of<tag::tail_quantile<LeftRight> >
-{};
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/tail_variate.hpp

@@ -1,141 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// tail_variate.hpp
-//
-//  Copyright 2005 Eric Niebler, Michael Gauckler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_STAT_STATISTICS_TAIL_VARIATE_HPP_EAN_28_10_2005
-#define BOOST_STAT_STATISTICS_TAIL_VARIATE_HPP_EAN_28_10_2005
-
-#include <boost/range.hpp>
-#include <boost/mpl/always.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/iterator/permutation_iterator.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // tail_variate_impl
-    template<typename VariateType, typename VariateTag, typename LeftRight>
-    struct tail_variate_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef
-            typename detail::tail_range<
-                typename std::vector<VariateType>::const_iterator
-              , std::vector<std::size_t>::iterator
-            >::type
-        result_type;
-
-        template<typename Args>
-        tail_variate_impl(Args const &args)
-          : variates(args[tag::tail<LeftRight>::cache_size], args[parameter::keyword<VariateTag>::get() | VariateType()])
-        {
-        }
-
-        template<typename Args>
-        void assign(Args const &args, std::size_t index)
-        {
-            this->variates[index] = args[parameter::keyword<VariateTag>::get()];
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            // getting the order result causes the indices vector to be sorted.
-            extractor<tag::tail<LeftRight> > const some_tail = {};
-            return this->do_result(some_tail(args));
-        }
-
-    private:
-        template<typename TailRng>
-        result_type do_result(TailRng const &rng) const
-        {
-            return detail::make_tail_range(
-                this->variates.begin()
-              , rng.end().base().base()   // the index iterator
-              , rng.begin().base().base() // (begin and end reversed because these are reverse iterators)
-            );
-        }
-
-        std::vector<VariateType> variates;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::tail_variate<>
-//
-namespace tag
-{
-    template<typename VariateType, typename VariateTag, typename LeftRight>
-    struct tail_variate
-      : depends_on<tail<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef mpl::always<accumulators::impl::tail_variate_impl<VariateType, VariateTag, LeftRight> > impl;
-    };
-
-    struct abstract_tail_variate
-      : depends_on<>
-    {
-    };
-
-    template<typename LeftRight>
-    struct tail_weights
-      : depends_on<tail<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::tail_variate_impl<mpl::_2, tag::weight, LeftRight> impl;
-    };
-
-    struct abstract_tail_weights
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::tail_variate
-// extract::tail_weights
-//
-namespace extract
-{
-    extractor<tag::abstract_tail_variate> const tail_variate = {};
-    extractor<tag::abstract_tail_weights> const tail_weights = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(tail_variate)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(tail_weights)
-}
-
-using extract::tail_variate;
-using extract::tail_weights;
-
-template<typename VariateType, typename VariateTag, typename LeftRight>
-struct feature_of<tag::tail_variate<VariateType, VariateTag, LeftRight> >
-  : feature_of<tag::abstract_tail_variate>
-{
-};
-
-template<typename LeftRight>
-struct feature_of<tag::tail_weights<LeftRight> >
-{
-    typedef tag::abstract_tail_weights type;
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/tail_variate_means.hpp

@@ -1,258 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// tail_variate_means.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_TAIL_VARIATE_MEANS_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_TAIL_VARIATE_MEANS_HPP_DE_01_01_2006
-
-#include <numeric>
-#include <vector>
-#include <limits>
-#include <functional>
-#include <sstream>
-#include <stdexcept>
-#include <boost/throw_exception.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/tail_variate.hpp>
-#include <boost/accumulators/statistics/tail_mean.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    /**
-        @brief Estimation of the absolute and relative tail variate means (for both left and right tails)
-
-        For all \f$j\f$-th variates associated to the \f$\lceil n(1-\alpha)\rceil\f$ largest samples (or the
-        \f$\lceil n(1-\alpha)\rceil\f$ smallest samples in case of the left tail), the absolute tail means
-        \f$\widehat{ATM}_{n,\alpha}(X, j)\f$ are computed and returned as an iterator range. Alternatively,
-        the relative tail means \f$\widehat{RTM}_{n,\alpha}(X, j)\f$ are returned, which are the absolute
-        tail means normalized with the (non-coherent) sample tail mean \f$\widehat{NCTM}_{n,\alpha}(X)\f$.
-
-        \f[
-            \widehat{ATM}_{n,\alpha}^{\mathrm{right}}(X, j) =
-                \frac{1}{\lceil n(1-\alpha) \rceil}
-                \sum_{i=\lceil \alpha n \rceil}^n \xi_{j,i}
-        \f]
-
-        \f[
-            \widehat{ATM}_{n,\alpha}^{\mathrm{left}}(X, j) =
-                \frac{1}{\lceil n\alpha \rceil}
-                \sum_{i=1}^{\lceil n\alpha \rceil} \xi_{j,i}
-        \f]
-
-        \f[
-            \widehat{RTM}_{n,\alpha}^{\mathrm{right}}(X, j) =
-                \frac{\sum_{i=\lceil n\alpha \rceil}^n \xi_{j,i}}
-            {\lceil n(1-\alpha)\rceil\widehat{NCTM}_{n,\alpha}^{\mathrm{right}}(X)}
-        \f]
-
-        \f[
-            \widehat{RTM}_{n,\alpha}^{\mathrm{left}}(X, j) =
-                \frac{\sum_{i=1}^{\lceil n\alpha \rceil} \xi_{j,i}}
-            {\lceil n\alpha\rceil\widehat{NCTM}_{n,\alpha}^{\mathrm{left}}(X)}
-        \f]
-    */
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // tail_variate_means_impl
-    //  by default: absolute tail_variate_means
-    template<typename Sample, typename Impl, typename LeftRight, typename VariateTag>
-    struct tail_variate_means_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<float_type> array_type;
-        // for boost::result_of
-        typedef iterator_range<typename array_type::iterator> result_type;
-
-        tail_variate_means_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            std::size_t cnt = count(args);
-
-            std::size_t n = static_cast<std::size_t>(
-                std::ceil(
-                    cnt * ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] )
-                )
-            );
-
-            std::size_t num_variates = tail_variate(args).begin()->size();
-
-            this->tail_means_.clear();
-            this->tail_means_.resize(num_variates, Sample(0));
-
-            // If n is in a valid range, return result, otherwise return NaN or throw exception
-            if (n < static_cast<std::size_t>(tail(args).size()))
-            {
-                this->tail_means_ = std::accumulate(
-                    tail_variate(args).begin()
-                  , tail_variate(args).begin() + n
-                  , this->tail_means_
-                  , numeric::plus
-                );
-
-                float_type factor = n * ( (is_same<Impl, relative>::value) ? non_coherent_tail_mean(args) : 1. );
-
-                std::transform(
-                    this->tail_means_.begin()
-                  , this->tail_means_.end()
-                  , this->tail_means_.begin()
-                  , std::bind2nd(std::divides<float_type>(), factor)
-                );
-            }
-            else
-            {
-                if (std::numeric_limits<float_type>::has_quiet_NaN)
-                {
-                    std::fill(
-                        this->tail_means_.begin()
-                      , this->tail_means_.end()
-                      , std::numeric_limits<float_type>::quiet_NaN()
-                    );
-                }
-                else
-                {
-                    std::ostringstream msg;
-                    msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                    boost::throw_exception(std::runtime_error(msg.str()));
-                }
-            }
-            return make_iterator_range(this->tail_means_);
-        }
-
-    private:
-
-        mutable array_type tail_means_;
-
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::absolute_tail_variate_means
-// tag::relative_tail_variate_means
-//
-namespace tag
-{
-    template<typename LeftRight, typename VariateType, typename VariateTag>
-    struct absolute_tail_variate_means
-      : depends_on<count, non_coherent_tail_mean<LeftRight>, tail_variate<VariateType, VariateTag, LeftRight> >
-    {
-        typedef accumulators::impl::tail_variate_means_impl<mpl::_1, absolute, LeftRight, VariateTag> impl;
-    };
-    template<typename LeftRight, typename VariateType, typename VariateTag>
-    struct relative_tail_variate_means
-      : depends_on<count, non_coherent_tail_mean<LeftRight>, tail_variate<VariateType, VariateTag, LeftRight> >
-    {
-        typedef accumulators::impl::tail_variate_means_impl<mpl::_1, relative, LeftRight, VariateTag> impl;
-    };
-    struct abstract_absolute_tail_variate_means
-      : depends_on<>
-    {
-    };
-    struct abstract_relative_tail_variate_means
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::tail_variate_means
-// extract::relative_tail_variate_means
-//
-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 = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(tail_variate_means)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(relative_tail_variate_means)
-}
-
-using extract::tail_variate_means;
-using extract::relative_tail_variate_means;
-
-// tail_variate_means<LeftRight, VariateType, VariateTag>(absolute) -> absolute_tail_variate_means<LeftRight, VariateType, VariateTag>
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct as_feature<tag::tail_variate_means<LeftRight, VariateType, VariateTag>(absolute)>
-{
-    typedef tag::absolute_tail_variate_means<LeftRight, VariateType, VariateTag> type;
-};
-
-// tail_variate_means<LeftRight, VariateType, VariateTag>(relative) ->relative_tail_variate_means<LeftRight, VariateType, VariateTag>
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct as_feature<tag::tail_variate_means<LeftRight, VariateType, VariateTag>(relative)>
-{
-    typedef tag::relative_tail_variate_means<LeftRight, VariateType, VariateTag> type;
-};
-
-// Provides non-templatized extractor
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct feature_of<tag::absolute_tail_variate_means<LeftRight, VariateType, VariateTag> >
-  : feature_of<tag::abstract_absolute_tail_variate_means>
-{
-};
-
-// Provides non-templatized extractor
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct feature_of<tag::relative_tail_variate_means<LeftRight, VariateType, VariateTag> >
-  : feature_of<tag::abstract_relative_tail_variate_means>
-{
-};
-
-// So that absolute_tail_means can be automatically substituted
-// with absolute_weighted_tail_means when the weight parameter is non-void.
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct as_weighted_feature<tag::absolute_tail_variate_means<LeftRight, VariateType, VariateTag> >
-{
-    typedef tag::absolute_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> type;
-};
-
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct feature_of<tag::absolute_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> >
-  : feature_of<tag::absolute_tail_variate_means<LeftRight, VariateType, VariateTag> >
-{
-};
-
-// So that relative_tail_means can be automatically substituted
-// with relative_weighted_tail_means when the weight parameter is non-void.
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct as_weighted_feature<tag::relative_tail_variate_means<LeftRight, VariateType, VariateTag> >
-{
-    typedef tag::relative_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> type;
-};
-
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct feature_of<tag::relative_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> >
-  : feature_of<tag::relative_tail_variate_means<LeftRight, VariateType, VariateTag> >
-{
-};
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/times2_iterator.hpp

@@ -1,58 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// times2_iterator.hpp
-//
-//  Copyright 2006 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_TIMES2_ITERATOR_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_TIMES2_ITERATOR_HPP_DE_01_01_2006
-
-#include <functional>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/iterator/counting_iterator.hpp>
-#include <boost/iterator/permutation_iterator.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace detail
-{
-    typedef transform_iterator<
-        std::binder1st<std::multiplies<std::size_t> >
-      , counting_iterator<std::size_t>
-    > times2_iterator;
-
-    inline times2_iterator make_times2_iterator(std::size_t i)
-    {
-        return make_transform_iterator(
-            make_counting_iterator(i)
-          , std::bind1st(std::multiplies<std::size_t>(), 2)
-        );
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // lvalue_index_iterator
-    template<typename Base>
-    struct lvalue_index_iterator
-      : Base
-    {
-        lvalue_index_iterator(Base base)
-          : Base(base)
-        {
-        }
-
-        typename Base::reference operator [](typename Base::difference_type n) const
-        {
-            return *(*this + n);
-        }
-    };
-} // namespace detail
-
-}}
-
-#endif

test/external/boost/accumulators/statistics/variance.hpp

@@ -1,236 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// variance.hpp
-//
-//  Copyright 2005 Daniel Egloff, Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_VARIANCE_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_VARIANCE_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/mean.hpp>
-#include <boost/accumulators/statistics/moment.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    //! Lazy calculation of variance.
-    /*!
-        Default sample variance implementation based on the second moment \f$ M_n^{(2)} \f$ moment<2>, mean and count.
-        \f[
-            \sigma_n^2 = M_n^{(2)} - \mu_n^2.
-        \f]
-        where
-        \f[
-            \mu_n = \frac{1}{n} \sum_{i = 1}^n x_i.
-        \f]
-        is the estimate of the sample mean and \f$n\f$ is the number of samples.
-    */
-    template<typename Sample, typename MeanFeature>
-    struct lazy_variance_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        lazy_variance_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            extractor<MeanFeature> mean;
-            result_type tmp = mean(args);
-            return accumulators::moment<2>(args) - tmp * tmp;
-        }
-    };
-
-    //! Iterative calculation of variance.
-    /*!
-        Iterative calculation of sample variance \f$\sigma_n^2\f$ according to the formula
-        \f[
-            \sigma_n^2 = \frac{1}{n} \sum_{i = 1}^n (x_i - \mu_n)^2 = \frac{n-1}{n} \sigma_{n-1}^2 + \frac{1}{n-1}(x_n - \mu_n)^2.
-        \f]
-        where
-        \f[
-            \mu_n = \frac{1}{n} \sum_{i = 1}^n x_i.
-        \f]
-        is the estimate of the sample mean and \f$n\f$ is the number of samples.
-
-        Note that the sample variance is not defined for \f$n <= 1\f$.
-
-        A simplification can be obtained by the approximate recursion
-        \f[
-            \sigma_n^2 \approx \frac{n-1}{n} \sigma_{n-1}^2 + \frac{1}{n}(x_n - \mu_n)^2.
-        \f]
-        because the difference
-        \f[
-            \left(\frac{1}{n-1} - \frac{1}{n}\right)(x_n - \mu_n)^2 = \frac{1}{n(n-1)}(x_n - \mu_n)^2.
-        \f]
-        converges to zero as \f$n \rightarrow \infty\f$. However, for small \f$ n \f$ the difference
-        can be non-negligible.
-    */
-    template<typename Sample, typename MeanFeature, typename Tag>
-    struct variance_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        template<typename Args>
-        variance_impl(Args const &args)
-          : variance(numeric::average(args[sample | Sample()], numeric::one<std::size_t>::value))
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-
-            if(cnt > 1)
-            {
-                extractor<MeanFeature> mean;
-                result_type tmp = args[parameter::keyword<Tag>::get()] - mean(args);
-                this->variance =
-                    numeric::average(this->variance * (cnt - 1), cnt)
-                  + numeric::average(tmp * tmp, cnt - 1);
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->variance;
-        }
-
-    private:
-        result_type variance;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::variance
-// tag::immediate_variance
-//
-namespace tag
-{
-    struct lazy_variance
-      : depends_on<moment<2>, mean>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::lazy_variance_impl<mpl::_1, mean> impl;
-    };
-
-    struct variance
-      : depends_on<count, immediate_mean>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::variance_impl<mpl::_1, mean, sample> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::lazy_variance
-// extract::variance
-//
-namespace extract
-{
-    extractor<tag::lazy_variance> const lazy_variance = {};
-    extractor<tag::variance> const variance = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(lazy_variance)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(variance)
-}
-
-using extract::lazy_variance;
-using extract::variance;
-
-// variance(lazy) -> lazy_variance
-template<>
-struct as_feature<tag::variance(lazy)>
-{
-    typedef tag::lazy_variance type;
-};
-
-// variance(immediate) -> variance
-template<>
-struct as_feature<tag::variance(immediate)>
-{
-    typedef tag::variance type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// immediate_variance provides the same feature as variance
-template<>
-struct feature_of<tag::lazy_variance>
-  : feature_of<tag::variance>
-{
-};
-
-// So that variance can be automatically substituted with
-// weighted_variance when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::variance>
-{
-    typedef tag::weighted_variance type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// weighted_variance provides the same feature as variance
-template<>
-struct feature_of<tag::weighted_variance>
-  : feature_of<tag::variance>
-{
-};
-
-// So that immediate_variance can be automatically substituted with
-// immediate_weighted_variance when the weight parameter is non-void.
-template<>
-struct as_weighted_feature<tag::lazy_variance>
-{
-    typedef tag::lazy_weighted_variance type;
-};
-
-// for the purposes of feature-based dependency resolution,
-// immediate_weighted_variance provides the same feature as immediate_variance
-template<>
-struct feature_of<tag::lazy_weighted_variance>
-  : feature_of<tag::lazy_variance>
-{
-};
-
-////////////////////////////////////////////////////////////////////////////
-//// droppable_accumulator<variance_impl>
-////  need to specialize droppable lazy variance to cache the result at the
-////  point the accumulator is dropped.
-///// INTERNAL ONLY
-/////
-//template<typename Sample, typename MeanFeature>
-//struct droppable_accumulator<impl::variance_impl<Sample, MeanFeature> >
-//  : droppable_accumulator_base<
-//        with_cached_result<impl::variance_impl<Sample, MeanFeature> >
-//    >
-//{
-//    template<typename Args>
-//    droppable_accumulator(Args const &args)
-//      : droppable_accumulator::base(args)
-//    {
-//    }
-//};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/variates/covariate.hpp

@@ -1,21 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weight.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_VARIATES_COVARIATE_HPP_EAN_03_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_VARIATES_COVARIATE_HPP_EAN_03_11_2005
-
-#include <boost/parameter/keyword.hpp>
-
-namespace boost { namespace accumulators
-{
-
-BOOST_PARAMETER_KEYWORD(tag, covariate1)
-BOOST_PARAMETER_KEYWORD(tag, covariate2)
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_covariance.hpp

@@ -1,133 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_covariance.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_COVARIANCE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_COVARIANCE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <numeric>
-#include <functional>
-#include <complex>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/range.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/numeric/ublas/io.hpp>
-#include <boost/numeric/ublas/matrix.hpp>
-#include <boost/type_traits/is_scalar.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/covariance.hpp> // for numeric::outer_product() and type traits
-#include <boost/accumulators/statistics/weighted_mean.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_covariance_impl
-    //
-    /**
-        @brief Weighted Covariance Estimator
-
-        An iterative Monte Carlo estimator for the weighted covariance \f$\mathrm{Cov}(X,X')\f$, where \f$X\f$ is a sample
-        and \f$X'\f$ a variate, is given by:
-
-        \f[
-            \hat{c}_n = \frac{\bar{w}_n-w_n}{\bar{w}_n} \hat{c}_{n-1} + \frac{w_n}{\bar{w}_n-w_n}(X_n - \hat{\mu}_n)(X_n' - \hat{\mu}_n'),
-            \quad n\ge2,\quad\hat{c}_1 = 0,
-        \f]
-
-        \f$\hat{\mu}_n\f$ and \f$\hat{\mu}_n'\f$ being the weighted means of the samples and variates and
-        \f$\bar{w}_n\f$ the sum of the \f$n\f$ first weights \f$w_i\f$.
-    */
-    template<typename Sample, typename Weight, typename VariateType, typename VariateTag>
-    struct weighted_covariance_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Weight, typename numeric::functional::average<Sample, std::size_t>::result_type>::result_type weighted_sample_type;
-        typedef typename numeric::functional::multiplies<Weight, typename numeric::functional::average<VariateType, std::size_t>::result_type>::result_type weighted_variate_type;
-        // for boost::result_of
-        typedef typename numeric::functional::outer_product<weighted_sample_type, weighted_variate_type>::result_type result_type;
-
-        template<typename Args>
-        weighted_covariance_impl(Args const &args)
-          : cov_(
-                numeric::outer_product(
-                    numeric::average(args[sample | Sample()], (std::size_t)1)
-                      * numeric::one<Weight>::value
-                  , numeric::average(args[parameter::keyword<VariateTag>::get() | VariateType()], (std::size_t)1)
-                      * numeric::one<Weight>::value
-                )
-            )
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-
-            if (cnt > 1)
-            {
-                extractor<tag::weighted_mean_of_variates<VariateType, VariateTag> > const some_weighted_mean_of_variates = {};
-
-                this->cov_ = this->cov_ * (sum_of_weights(args) - args[weight]) / sum_of_weights(args)
-                           + numeric::outer_product(
-                                 some_weighted_mean_of_variates(args) - args[parameter::keyword<VariateTag>::get()]
-                               , weighted_mean(args) - args[sample]
-                             ) * args[weight] / (sum_of_weights(args) - args[weight]);
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->cov_;
-        }
-
-    private:
-        result_type cov_;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_covariance
-//
-namespace tag
-{
-    template<typename VariateType, typename VariateTag>
-    struct weighted_covariance
-      : depends_on<count, sum_of_weights, weighted_mean, weighted_mean_of_variates<VariateType, VariateTag> >
-    {
-        typedef accumulators::impl::weighted_covariance_impl<mpl::_1, mpl::_2, VariateType, VariateTag> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_covariance
-//
-namespace extract
-{
-    extractor<tag::abstract_covariance> const weighted_covariance = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_covariance)
-}
-
-using extract::weighted_covariance;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_density.hpp

@@ -1,221 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_density.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_DENSITY_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_DENSITY_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <functional>
-#include <boost/range.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/max.hpp>
-#include <boost/accumulators/statistics/min.hpp>
-#include <boost/accumulators/statistics/density.hpp> // for named parameters density_cache_size and density_num_bins
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_density_impl
-    //  density histogram for weighted samples
-    /**
-        @brief Histogram density estimator for weighted samples
-
-        The histogram density estimator returns a histogram of the sample distribution. The positions and sizes of the bins
-        are determined using a specifiable number of cached samples (cache_size). The range between the minimum and the
-        maximum of the cached samples is subdivided into a specifiable number of bins (num_bins) of same size. Additionally,
-        an under- and an overflow bin is added to capture future under- and overflow samples. Once the bins are determined,
-        the cached samples and all subsequent samples are added to the correct bins. At the end, a range of std::pair is
-        returned, where each pair contains the position of the bin (lower bound) and the sum of the weights (normalized with the
-        sum of all weights).
-
-        @param density_cache_size Number of first samples used to determine min and max.
-        @param density_num_bins Number of bins (two additional bins collect under- and overflow samples).
-    */
-    template<typename Sample, typename Weight>
-    struct weighted_density_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Weight, std::size_t>::result_type float_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        typedef std::vector<float_type> array_type;
-        // for boost::result_of
-        typedef iterator_range<typename histogram_type::iterator> result_type;
-
-        template<typename Args>
-        weighted_density_impl(Args const &args)
-            : cache_size(args[density_cache_size])
-            , cache(cache_size)
-            , num_bins(args[density_num_bins])
-            , samples_in_bin(num_bins + 2, 0.)
-            , bin_positions(num_bins + 2)
-            , histogram(
-                num_bins + 2
-              , std::make_pair(
-                    numeric::average(args[sample | Sample()],(std::size_t)1)
-                  , numeric::average(args[sample | Sample()],(std::size_t)1)
-                )
-              )
-            , is_dirty(true)
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->is_dirty = true;
-
-            std::size_t cnt = count(args);
-
-            // Fill up cache with cache_size first samples
-            if (cnt <= this->cache_size)
-            {
-                this->cache[cnt - 1] = std::make_pair(args[sample], args[weight]);
-            }
-
-            // Once cache_size samples have been accumulated, create num_bins bins of same size between
-            // the minimum and maximum of the cached samples as well as an under- and an overflow bin.
-            // Store their lower bounds (bin_positions) and fill the bins with the cached samples (samples_in_bin).
-            if (cnt == this->cache_size)
-            {
-                float_type minimum = numeric::average((min)(args),(std::size_t)1);
-                float_type maximum = numeric::average((max)(args),(std::size_t)1);
-                float_type bin_size = numeric::average(maximum - minimum, this->num_bins);
-
-                // determine bin positions (their lower bounds)
-                for (std::size_t i = 0; i < this->num_bins + 2; ++i)
-                {
-                    this->bin_positions[i] = minimum + (i - 1.) * bin_size;
-                }
-
-                for (typename histogram_type::const_iterator iter = this->cache.begin(); iter != this->cache.end(); ++iter)
-                {
-                    if (iter->first < this->bin_positions[1])
-                    {
-                        this->samples_in_bin[0] += iter->second;
-                    }
-                    else if (iter->first >= this->bin_positions[this->num_bins + 1])
-                    {
-                        this->samples_in_bin[this->num_bins + 1] += iter->second;
-                    }
-                    else
-                    {
-                        typename array_type::iterator it = std::upper_bound(
-                            this->bin_positions.begin()
-                          , this->bin_positions.end()
-                          , iter->first
-                        );
-
-                        std::size_t d = std::distance(this->bin_positions.begin(), it);
-                        this->samples_in_bin[d - 1] += iter->second;
-                    }
-                }
-            }
-            // Add each subsequent sample to the correct bin
-            else if (cnt > this->cache_size)
-            {
-                if (args[sample] < this->bin_positions[1])
-                {
-                    this->samples_in_bin[0] += args[weight];
-                }
-                else if (args[sample] >= this->bin_positions[this->num_bins + 1])
-                {
-                    this->samples_in_bin[this->num_bins + 1] += args[weight];
-                }
-                else
-                {
-                    typename array_type::iterator it = std::upper_bound(
-                        this->bin_positions.begin()
-                      , this->bin_positions.end()
-                      , args[sample]
-                    );
-
-                    std::size_t d = std::distance(this->bin_positions.begin(), it);
-                    this->samples_in_bin[d - 1] += args[weight];
-                }
-            }
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                // creates a vector of std::pair where each pair i holds
-                // the values bin_positions[i] (x-axis of histogram) and
-                // samples_in_bin[i] / cnt (y-axis of histogram).
-
-                for (std::size_t i = 0; i < this->num_bins + 2; ++i)
-                {
-                    this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::average(this->samples_in_bin[i], sum_of_weights(args)));
-                }
-            }
-
-            // returns a range of pairs
-            return make_iterator_range(this->histogram);
-        }
-
-    private:
-        std::size_t            cache_size;      // number of cached samples
-        histogram_type         cache;           // cache to store the first cache_size samples with their weights as std::pair
-        std::size_t            num_bins;        // number of bins
-        array_type             samples_in_bin;  // number of samples in each bin
-        array_type             bin_positions;   // lower bounds of bins
-        mutable histogram_type histogram;       // histogram
-        mutable bool is_dirty;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_density
-//
-namespace tag
-{
-    struct weighted_density
-      : depends_on<count, sum_of_weights, min, max>
-      , density_cache_size
-      , density_num_bins
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_density_impl<mpl::_1, mpl::_2> impl;
-
-        #ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
-        static boost::parameter::keyword<density_cache_size> const cache_size;
-        static boost::parameter::keyword<density_num_bins> const num_bins;
-        #endif
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_density
-//
-namespace extract
-{
-    extractor<tag::density> const weighted_density = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_density)
-}
-
-using extract::weighted_density;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_extended_p_square.hpp

@@ -1,290 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_extended_p_square.hpp
-//
-//  Copyright 2005 Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_EXTENDED_P_SQUARE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_EXTENDED_P_SQUARE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <functional>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/iterator/counting_iterator.hpp>
-#include <boost/iterator/permutation_iterator.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/times2_iterator.hpp>
-#include <boost/accumulators/statistics/extended_p_square.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_extended_p_square_impl
-    //  multiple quantile estimation with weighted samples
-    /**
-        @brief Multiple quantile estimation with the extended \f$P^2\f$ algorithm for weighted samples
-
-        This version of the extended \f$P^2\f$ algorithm extends the extended \f$P^2\f$ algorithm to
-        support weighted samples. The extended \f$P^2\f$ algorithm dynamically estimates several
-        quantiles without storing samples. Assume that \f$m\f$ quantiles
-        \f$\xi_{p_1}, \ldots, \xi_{p_m}\f$ are to be estimated. Instead of storing the whole sample
-        cumulative distribution, the algorithm maintains only \f$m+2\f$ principal markers and
-        \f$m+1\f$ middle markers, whose positions are updated with each sample and whose heights
-        are adjusted (if necessary) using a piecewise-parablic formula. The heights of the principal
-        markers are the current estimates of the quantiles and are returned as an iterator range.
-
-        For further details, see
-
-        K. E. E. Raatikainen, Simultaneous estimation of several quantiles, Simulation, Volume 49,
-        Number 4 (October), 1986, p. 159-164.
-
-        The extended \f$ P^2 \f$ algorithm generalizess the \f$ P^2 \f$ algorithm of
-
-        R. Jain and I. Chlamtac, The P^2 algorithmus for dynamic calculation of quantiles and
-        histograms without storing observations, Communications of the ACM,
-        Volume 28 (October), Number 10, 1985, p. 1076-1085.
-
-        @param extended_p_square_probabilities A vector of quantile probabilities.
-    */
-    template<typename Sample, typename Weight>
-    struct weighted_extended_p_square_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
-        typedef std::vector<float_type> array_type;
-        // for boost::result_of
-        typedef iterator_range<
-            detail::lvalue_index_iterator<
-                permutation_iterator<
-                    typename array_type::const_iterator
-                  , detail::times2_iterator
-                >
-            >
-        > result_type;
-
-        template<typename Args>
-        weighted_extended_p_square_impl(Args const &args)
-          : probabilities(
-                boost::begin(args[extended_p_square_probabilities])
-              , boost::end(args[extended_p_square_probabilities])
-            )
-          , heights(2 * probabilities.size() + 3)
-          , actual_positions(heights.size())
-          , desired_positions(heights.size())
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-            std::size_t sample_cell = 1; // k
-            std::size_t num_quantiles = this->probabilities.size();
-
-            // m+2 principal markers and m+1 middle markers
-            std::size_t num_markers = 2 * num_quantiles + 3;
-
-            // first accumulate num_markers samples
-            if(cnt <= num_markers)
-            {
-                this->heights[cnt - 1] = args[sample];
-                this->actual_positions[cnt - 1] = args[weight];
-
-                // complete the initialization of heights (and actual_positions) by sorting
-                if(cnt == num_markers)
-                {
-                    // TODO: we need to sort the initial samples (in heights) in ascending order and
-                    // sort their weights (in actual_positions) the same way. The following lines do
-                    // it, but there must be a better and more efficient way of doing this.
-                    typename array_type::iterator it_begin, it_end, it_min;
-
-                    it_begin = this->heights.begin();
-                    it_end   = this->heights.end();
-
-                    std::size_t pos = 0;
-
-                    while (it_begin != it_end)
-                    {
-                        it_min = std::min_element(it_begin, it_end);
-                        std::size_t d = std::distance(it_begin, it_min);
-                        std::swap(*it_begin, *it_min);
-                        std::swap(this->actual_positions[pos], this->actual_positions[pos + d]);
-                        ++it_begin;
-                        ++pos;
-                    }
-
-                    // calculate correct initial actual positions
-                    for (std::size_t i = 1; i < num_markers; ++i)
-                    {
-                        actual_positions[i] += actual_positions[i - 1];
-                    }
-                }
-            }
-            else
-            {
-                if(args[sample] < this->heights[0])
-                {
-                    this->heights[0] = args[sample];
-                    this->actual_positions[0] = args[weight];
-                    sample_cell = 1;
-                }
-                else if(args[sample] >= this->heights[num_markers - 1])
-                {
-                    this->heights[num_markers - 1] = args[sample];
-                    sample_cell = num_markers - 1;
-                }
-                else
-                {
-                    // find cell k = sample_cell such that heights[k-1] <= sample < heights[k]
-
-                    typedef typename array_type::iterator iterator;
-                    iterator it = std::upper_bound(
-                        this->heights.begin()
-                      , this->heights.end()
-                      , args[sample]
-                    );
-
-                    sample_cell = std::distance(this->heights.begin(), it);
-                }
-
-                // update actual position of all markers above sample_cell
-                for(std::size_t i = sample_cell; i < num_markers; ++i)
-                {
-                    this->actual_positions[i] += args[weight];
-                }
-
-                // compute desired positions
-                {
-                    this->desired_positions[0] = this->actual_positions[0];
-                    this->desired_positions[num_markers - 1] = sum_of_weights(args);
-                    this->desired_positions[1] = (sum_of_weights(args) - this->actual_positions[0]) * probabilities[0]
-                                              / 2. + this->actual_positions[0];
-                    this->desired_positions[num_markers - 2] = (sum_of_weights(args) - this->actual_positions[0])
-                                                            * (probabilities[num_quantiles - 1] + 1.)
-                                                            / 2. + this->actual_positions[0];
-
-                    for (std::size_t i = 0; i < num_quantiles; ++i)
-                    {
-                        this->desired_positions[2 * i + 2] = (sum_of_weights(args) - this->actual_positions[0])
-                                                          * probabilities[i] + this->actual_positions[0];
-                    }
-
-                    for (std::size_t i = 1; i < num_quantiles; ++i)
-                    {
-                        this->desired_positions[2 * i + 1] = (sum_of_weights(args) - this->actual_positions[0])
-                                                      * (probabilities[i - 1] + probabilities[i])
-                                                      / 2. + this->actual_positions[0];
-                    }
-                }
-
-                // adjust heights and actual_positions of markers 1 to num_markers - 2 if necessary
-                for (std::size_t i = 1; i <= num_markers - 2; ++i)
-                {
-                    // offset to desired position
-                    float_type d = this->desired_positions[i] - this->actual_positions[i];
-
-                    // offset to next position
-                    float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
-
-                    // offset to previous position
-                    float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
-
-                    // height ds
-                    float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
-                    float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
-
-                    if((d >= 1 && dp > 1) || (d <= -1 && dm < -1))
-                    {
-                        short sign_d = static_cast<short>(d / std::abs(d));
-
-                        float_type h = this->heights[i] + sign_d / (dp - dm) * ((sign_d - dm)*hp + (dp - sign_d) * hm);
-
-                        // try adjusting heights[i] using p-squared formula
-                        if(this->heights[i - 1] < h && h < this->heights[i + 1])
-                        {
-                            this->heights[i] = h;
-                        }
-                        else
-                        {
-                            // use linear formula
-                            if(d > 0)
-                            {
-                                this->heights[i] += hp;
-                            }
-                            if(d < 0)
-                            {
-                                this->heights[i] -= hm;
-                            }
-                        }
-                        this->actual_positions[i] += sign_d;
-                    }
-                }
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            // for i in [1,probabilities.size()], return heights[i * 2]
-            detail::times2_iterator idx_begin = detail::make_times2_iterator(1);
-            detail::times2_iterator idx_end = detail::make_times2_iterator(this->probabilities.size() + 1);
-
-            return result_type(
-                make_permutation_iterator(this->heights.begin(), idx_begin)
-              , make_permutation_iterator(this->heights.begin(), idx_end)
-            );
-        }
-
-    private:
-        array_type probabilities;         // the quantile probabilities
-        array_type heights;               // q_i
-        array_type actual_positions;      // n_i
-        array_type desired_positions;     // d_i
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_extended_p_square
-//
-namespace tag
-{
-    struct weighted_extended_p_square
-      : depends_on<count, sum_of_weights>
-      , extended_p_square_probabilities
-    {
-        typedef accumulators::impl::weighted_extended_p_square_impl<mpl::_1, mpl::_2> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_extended_p_square
-//
-namespace extract
-{
-    extractor<tag::weighted_extended_p_square> const weighted_extended_p_square = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_extended_p_square)
-}
-
-using extract::weighted_extended_p_square;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_kurtosis.hpp

@@ -1,105 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_kurtosis.hpp
-//
-//  Copyright 2006 Olivier Gygi, Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_KURTOSIS_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_KURTOSIS_HPP_EAN_28_10_2005
-
-#include <limits>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/weighted_moment.hpp>
-#include <boost/accumulators/statistics/weighted_mean.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_kurtosis_impl
-    /**
-        @brief Kurtosis estimation for weighted samples
-
-        The kurtosis of a sample distribution is defined as the ratio of the 4th central moment and the square of the 2nd central
-        moment (the variance) of the samples, minus 3. The term \f$ -3 \f$ is added in order to ensure that the normal distribution
-        has zero kurtosis. The kurtosis can also be expressed by the simple moments:
-
-        \f[
-            \hat{g}_2 =
-                \frac
-                {\widehat{m}_n^{(4)}-4\widehat{m}_n^{(3)}\hat{\mu}_n+6\widehat{m}_n^{(2)}\hat{\mu}_n^2-3\hat{\mu}_n^4}
-                {\left(\widehat{m}_n^{(2)} - \hat{\mu}_n^{2}\right)^2} - 3,
-        \f]
-
-        where \f$ \widehat{m}_n^{(i)} \f$ are the \f$ i \f$-th moment and \f$ \hat{\mu}_n \f$ the mean (first moment) of the
-        \f$ n \f$ samples.
-
-        The kurtosis estimator for weighted samples is formally identical to the estimator for unweighted samples, except that
-        the weighted counterparts of all measures it depends on are to be taken.
-    */
-    template<typename Sample, typename Weight>
-    struct weighted_kurtosis_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, weighted_sample>::result_type result_type;
-
-        weighted_kurtosis_impl(dont_care)
-        {
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return numeric::average(
-                        accumulators::weighted_moment<4>(args)
-                        - 4. * accumulators::weighted_moment<3>(args) * weighted_mean(args)
-                        + 6. * accumulators::weighted_moment<2>(args) * weighted_mean(args) * weighted_mean(args)
-                        - 3. * weighted_mean(args) * weighted_mean(args) * weighted_mean(args) * weighted_mean(args)
-                      , ( accumulators::weighted_moment<2>(args) - weighted_mean(args) * weighted_mean(args) )
-                        * ( accumulators::weighted_moment<2>(args) - weighted_mean(args) * weighted_mean(args) )
-                   ) - 3.;
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_kurtosis
-//
-namespace tag
-{
-    struct weighted_kurtosis
-      : depends_on<weighted_mean, weighted_moment<2>, weighted_moment<3>, weighted_moment<4> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_kurtosis_impl<mpl::_1, mpl::_2> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_kurtosis
-//
-namespace extract
-{
-    extractor<tag::weighted_kurtosis> const weighted_kurtosis = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_kurtosis)
-}
-
-using extract::weighted_kurtosis;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_mean.hpp

@@ -1,189 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_mean.hpp
-//
-//  Copyright 2006 Eric Niebler, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_MEAN_HPP_EAN_03_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_MEAN_HPP_EAN_03_11_2005
-
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/weights.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/mean.hpp>
-#include <boost/accumulators/statistics/weighted_sum.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_mean_impl
-    //      lazy, by default
-    template<typename Sample, typename Weight, typename Tag>
-    struct weighted_mean_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
-
-        weighted_mean_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            typedef
-                typename mpl::if_<
-                    is_same<Tag, tag::sample>
-                  , tag::weighted_sum
-                  , tag::weighted_sum_of_variates<Sample, Tag>
-                >::type
-            weighted_sum_tag;
-
-            extractor<weighted_sum_tag> const some_weighted_sum = {};
-
-            return numeric::average(some_weighted_sum(args), sum_of_weights(args));
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // immediate_weighted_mean_impl
-    //      immediate
-    template<typename Sample, typename Weight, typename Tag>
-    struct immediate_weighted_mean_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
-
-        template<typename Args>
-        immediate_weighted_mean_impl(Args const &args)
-          : mean(
-                numeric::average(
-                    args[parameter::keyword<Tag>::get() | Sample()]
-                      * numeric::one<Weight>::value
-                  , numeric::one<Weight>::value
-                )
-            )
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            // Matthias:
-            //  need to pass the argument pack since the weight might be an external
-            //  accumulator set passed as a named parameter
-            Weight w_sum = sum_of_weights(args);
-            Weight w = args[weight];
-            weighted_sample const &s = args[parameter::keyword<Tag>::get()] * w;
-            this->mean = numeric::average(this->mean * (w_sum - w) + s, w_sum);
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->mean;
-        }
-
-    private:
-        result_type mean;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_mean
-// tag::immediate_weighted_mean
-//
-namespace tag
-{
-    struct weighted_mean
-      : depends_on<sum_of_weights, weighted_sum>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_mean_impl<mpl::_1, mpl::_2, tag::sample> impl;
-    };
-    struct immediate_weighted_mean
-      : depends_on<sum_of_weights>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::immediate_weighted_mean_impl<mpl::_1, mpl::_2, tag::sample> impl;
-    };
-    template<typename VariateType, typename VariateTag>
-    struct weighted_mean_of_variates
-      : depends_on<sum_of_weights, weighted_sum_of_variates<VariateType, VariateTag> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_mean_impl<VariateType, mpl::_2, VariateTag> impl;
-    };
-    template<typename VariateType, typename VariateTag>
-    struct immediate_weighted_mean_of_variates
-      : depends_on<sum_of_weights>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::immediate_weighted_mean_impl<VariateType, mpl::_2, VariateTag> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_mean
-// extract::weighted_mean_of_variates
-//
-namespace extract
-{
-    extractor<tag::mean> const weighted_mean = {};
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, weighted_mean_of_variates, (typename)(typename))
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_mean)
-}
-
-using extract::weighted_mean;
-using extract::weighted_mean_of_variates;
-
-// weighted_mean(lazy) -> weighted_mean
-template<>
-struct as_feature<tag::weighted_mean(lazy)>
-{
-    typedef tag::weighted_mean type;
-};
-
-// weighted_mean(immediate) -> immediate_weighted_mean
-template<>
-struct as_feature<tag::weighted_mean(immediate)>
-{
-    typedef tag::immediate_weighted_mean type;
-};
-
-// weighted_mean_of_variates<VariateType, VariateTag>(lazy) -> weighted_mean_of_variates<VariateType, VariateTag>
-template<typename VariateType, typename VariateTag>
-struct as_feature<tag::weighted_mean_of_variates<VariateType, VariateTag>(lazy)>
-{
-    typedef tag::weighted_mean_of_variates<VariateType, VariateTag> type;
-};
-
-// weighted_mean_of_variates<VariateType, VariateTag>(immediate) -> immediate_weighted_mean_of_variates<VariateType, VariateTag>
-template<typename VariateType, typename VariateTag>
-struct as_feature<tag::weighted_mean_of_variates<VariateType, VariateTag>(immediate)>
-{
-    typedef tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> type;
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_median.hpp

@@ -1,237 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_median.hpp
-//
-//  Copyright 2006 Eric Niebler, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_MEDIAN_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_MEDIAN_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/median.hpp>
-#include <boost/accumulators/statistics/weighted_p_square_quantile.hpp>
-#include <boost/accumulators/statistics/weighted_density.hpp>
-#include <boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_median_impl
-    //
-    /**
-        @brief Median estimation for weighted samples based on the \f$P^2\f$ quantile estimator
-
-        The \f$P^2\f$ algorithm for weighted samples is invoked with a quantile probability of 0.5.
-    */
-    template<typename Sample>
-    struct weighted_median_impl
-      : accumulator_base
-    {
-        // for boost::result_of
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
-
-        weighted_median_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return weighted_p_square_quantile_for_median(args);
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // with_density_weighted_median_impl
-    //
-    /**
-        @brief Median estimation for weighted samples based on the density estimator
-
-        The algorithm determines the bin in which the \f$0.5*cnt\f$-th sample lies, \f$cnt\f$ being
-        the total number of samples. It returns the approximate horizontal position of this sample,
-        based on a linear interpolation inside the bin.
-    */
-    template<typename Sample>
-    struct with_density_weighted_median_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        typedef iterator_range<typename histogram_type::iterator> range_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        template<typename Args>
-        with_density_weighted_median_impl(Args const &args)
-          : sum(numeric::average(args[sample | Sample()], (std::size_t)1))
-          , is_dirty(true)
-        {
-        }
-
-        void operator ()(dont_care)
-        {
-            this->is_dirty = true;
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                std::size_t cnt = count(args);
-                range_type histogram = weighted_density(args);
-                typename range_type::iterator it = histogram.begin();
-                while (this->sum < 0.5 * cnt)
-                {
-                    this->sum += it->second * cnt;
-                    ++it;
-                }
-                --it;
-                float_type over = numeric::average(this->sum - 0.5 * cnt, it->second * cnt);
-                this->median = it->first * over + (it + 1)->first * ( 1. - over );
-            }
-
-            return this->median;
-        }
-
-    private:
-        mutable float_type sum;
-        mutable bool is_dirty;
-        mutable float_type median;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // with_p_square_cumulative_distribution_weighted_median_impl
-    //
-    /**
-        @brief Median estimation for weighted samples based on the \f$P^2\f$ cumulative distribution estimator
-
-        The algorithm determines the first (leftmost) bin with a height exceeding 0.5. It
-        returns the approximate horizontal position of where the cumulative distribution
-        equals 0.5, based on a linear interpolation inside the bin.
-    */
-    template<typename Sample, typename Weight>
-    struct with_p_square_cumulative_distribution_weighted_median_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        typedef iterator_range<typename histogram_type::iterator> range_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        with_p_square_cumulative_distribution_weighted_median_impl(dont_care)
-          : is_dirty(true)
-        {
-        }
-
-        void operator ()(dont_care)
-        {
-            this->is_dirty = true;
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                range_type histogram = weighted_p_square_cumulative_distribution(args);
-                typename range_type::iterator it = histogram.begin();
-                while (it->second < 0.5)
-                {
-                    ++it;
-                }
-                float_type over = numeric::average(it->second - 0.5, it->second - (it - 1)->second);
-                this->median = it->first * over + (it + 1)->first * ( 1. - over );
-            }
-
-            return this->median;
-        }
-    private:
-        mutable bool is_dirty;
-        mutable float_type median;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_median
-// tag::with_density_weighted_median
-// tag::with_p_square_cumulative_distribution_weighted_median
-//
-namespace tag
-{
-    struct weighted_median
-      : depends_on<weighted_p_square_quantile_for_median>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_median_impl<mpl::_1> impl;
-    };
-    struct with_density_weighted_median
-      : depends_on<count, weighted_density>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::with_density_weighted_median_impl<mpl::_1> impl;
-    };
-    struct with_p_square_cumulative_distribution_weighted_median
-      : depends_on<weighted_p_square_cumulative_distribution>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::with_p_square_cumulative_distribution_weighted_median_impl<mpl::_1, mpl::_2> impl;
-    };
-
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_median
-//
-namespace extract
-{
-    extractor<tag::median> const weighted_median = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_median)
-}
-
-using extract::weighted_median;
-// weighted_median(with_p_square_quantile) -> weighted_median
-template<>
-struct as_feature<tag::weighted_median(with_p_square_quantile)>
-{
-    typedef tag::weighted_median type;
-};
-
-// weighted_median(with_density) -> with_density_weighted_median
-template<>
-struct as_feature<tag::weighted_median(with_density)>
-{
-    typedef tag::with_density_weighted_median type;
-};
-
-// weighted_median(with_p_square_cumulative_distribution) -> with_p_square_cumulative_distribution_weighted_median
-template<>
-struct as_feature<tag::weighted_median(with_p_square_cumulative_distribution)>
-{
-    typedef tag::with_p_square_cumulative_distribution_weighted_median type;
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_moment.hpp

@@ -1,96 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_moment.hpp
-//
-//  Copyright 2006, Eric Niebler, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_MOMENT_HPP_EAN_15_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_MOMENT_HPP_EAN_15_11_2005
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/moment.hpp> // for pow()
-#include <boost/accumulators/statistics/sum.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_moment_impl
-    template<typename N, typename Sample, typename Weight>
-    struct weighted_moment_impl
-      : accumulator_base // TODO: also depends_on sum of powers
-    {
-        BOOST_MPL_ASSERT_RELATION(N::value, >, 0);
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
-
-        template<typename Args>
-        weighted_moment_impl(Args const &args)
-          : sum(args[sample | Sample()] * numeric::one<Weight>::value)
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->sum += args[weight] * numeric::pow(args[sample], N());
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return numeric::average(this->sum, sum_of_weights(args));
-        }
-
-    private:
-        weighted_sample sum;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_moment
-//
-namespace tag
-{
-    template<int N>
-    struct weighted_moment
-      : depends_on<count, sum_of_weights>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_moment_impl<mpl::int_<N>, mpl::_1, mpl::_2> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_moment
-//
-namespace extract
-{
-    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, weighted_moment, (int))
-}
-
-using extract::weighted_moment;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp

@@ -1,262 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_p_square_cumulative_distribution.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_DE_01_01_2006
-
-#include <vector>
-#include <functional>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/range.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/p_square_cumulative_distribution.hpp> // for named parameter p_square_cumulative_distribution_num_cells
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_p_square_cumulative_distribution_impl
-    //  cumulative distribution calculation (as histogram)
-    /**
-        @brief Histogram calculation of the cumulative distribution with the \f$P^2\f$ algorithm for weighted samples
-
-        A histogram of the sample cumulative distribution is computed dynamically without storing samples
-        based on the \f$ P^2 \f$ algorithm for weighted samples. The returned histogram has a specifiable
-        amount (num_cells) equiprobable (and not equal-sized) cells.
-
-        Note that applying importance sampling results in regions to be more and other regions to be less
-        accurately estimated than without importance sampling, i.e., with unweighted samples.
-
-        For further details, see
-
-        R. Jain and I. Chlamtac, The P^2 algorithmus for dynamic calculation of quantiles and
-        histograms without storing observations, Communications of the ACM,
-        Volume 28 (October), Number 10, 1985, p. 1076-1085.
-
-        @param p_square_cumulative_distribution_num_cells
-    */
-    template<typename Sample, typename Weight>
-    struct weighted_p_square_cumulative_distribution_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
-        typedef std::vector<std::pair<float_type, float_type> > histogram_type;
-        typedef std::vector<float_type> array_type;
-        // for boost::result_of
-        typedef iterator_range<typename histogram_type::iterator> result_type;
-
-        template<typename Args>
-        weighted_p_square_cumulative_distribution_impl(Args const &args)
-          : num_cells(args[p_square_cumulative_distribution_num_cells])
-          , heights(num_cells + 1)
-          , actual_positions(num_cells + 1)
-          , desired_positions(num_cells + 1)
-          , histogram(num_cells + 1)
-          , is_dirty(true)
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->is_dirty = true;
-
-            std::size_t cnt = count(args);
-            std::size_t sample_cell = 1; // k
-            std::size_t b = this->num_cells;
-
-            // accumulate num_cells + 1 first samples
-            if (cnt <= b + 1)
-            {
-                this->heights[cnt - 1] = args[sample];
-                this->actual_positions[cnt - 1] = args[weight];
-
-                // complete the initialization of heights by sorting
-                if (cnt == b + 1)
-                {
-                    //std::sort(this->heights.begin(), this->heights.end());
-
-                    // TODO: we need to sort the initial samples (in heights) in ascending order and
-                    // sort their weights (in actual_positions) the same way. The following lines do
-                    // it, but there must be a better and more efficient way of doing this.
-                    typename array_type::iterator it_begin, it_end, it_min;
-
-                    it_begin = this->heights.begin();
-                    it_end   = this->heights.end();
-
-                    std::size_t pos = 0;
-
-                    while (it_begin != it_end)
-                    {
-                        it_min = std::min_element(it_begin, it_end);
-                        std::size_t d = std::distance(it_begin, it_min);
-                        std::swap(*it_begin, *it_min);
-                        std::swap(this->actual_positions[pos], this->actual_positions[pos + d]);
-                        ++it_begin;
-                        ++pos;
-                    }
-
-                    // calculate correct initial actual positions
-                    for (std::size_t i = 1; i < b; ++i)
-                    {
-                        this->actual_positions[i] += this->actual_positions[i - 1];
-                    }
-                }
-            }
-            else
-            {
-                // find cell k such that heights[k-1] <= args[sample] < heights[k] and adjust extreme values
-                if (args[sample] < this->heights[0])
-                {
-                    this->heights[0] = args[sample];
-                    this->actual_positions[0] = args[weight];
-                    sample_cell = 1;
-                }
-                else if (this->heights[b] <= args[sample])
-                {
-                    this->heights[b] = args[sample];
-                    sample_cell = b;
-                }
-                else
-                {
-                    typename array_type::iterator it;
-                    it = std::upper_bound(
-                        this->heights.begin()
-                      , this->heights.end()
-                      , args[sample]
-                    );
-
-                    sample_cell = std::distance(this->heights.begin(), it);
-                }
-
-                // increment positions of markers above sample_cell
-                for (std::size_t i = sample_cell; i < b + 1; ++i)
-                {
-                    this->actual_positions[i] += args[weight];
-                }
-
-                // determine desired marker positions
-                for (std::size_t i = 1; i < b + 1; ++i)
-                {
-                    this->desired_positions[i] = this->actual_positions[0]
-                                               + numeric::average((i-1) * (sum_of_weights(args) - this->actual_positions[0]), b);
-                }
-
-                // adjust heights of markers 2 to num_cells if necessary
-                for (std::size_t i = 1; i < b; ++i)
-                {
-                    // offset to desire position
-                    float_type d = this->desired_positions[i] - this->actual_positions[i];
-
-                    // offset to next position
-                    float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
-
-                    // offset to previous position
-                    float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
-
-                    // height ds
-                    float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
-                    float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
-
-                    if ( ( d >= 1. && dp > 1. ) || ( d <= -1. && dm < -1. ) )
-                    {
-                        short sign_d = static_cast<short>(d / std::abs(d));
-
-                        // try adjusting heights[i] using p-squared formula
-                        float_type h = this->heights[i] + sign_d / (dp - dm) * ( (sign_d - dm) * hp + (dp - sign_d) * hm );
-
-                        if ( this->heights[i - 1] < h && h < this->heights[i + 1] )
-                        {
-                            this->heights[i] = h;
-                        }
-                        else
-                        {
-                            // use linear formula
-                            if (d>0)
-                            {
-                                this->heights[i] += hp;
-                            }
-                            if (d<0)
-                            {
-                                this->heights[i] -= hm;
-                            }
-                        }
-                        this->actual_positions[i] += sign_d;
-                    }
-                }
-            }
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty)
-            {
-                this->is_dirty = false;
-
-                // creates a vector of std::pair where each pair i holds
-                // the values heights[i] (x-axis of histogram) and
-                // actual_positions[i] / sum_of_weights (y-axis of histogram)
-
-                for (std::size_t i = 0; i < this->histogram.size(); ++i)
-                {
-                    this->histogram[i] = std::make_pair(this->heights[i], numeric::average(this->actual_positions[i], sum_of_weights(args)));
-                }
-            }
-
-            return make_iterator_range(this->histogram);
-        }
-
-    private:
-        std::size_t num_cells;            // number of cells b
-        array_type  heights;              // q_i
-        array_type  actual_positions;     // n_i
-        array_type  desired_positions;    // n'_i
-        mutable histogram_type histogram; // histogram
-        mutable bool is_dirty;
-    };
-
-} // namespace detail
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_p_square_cumulative_distribution
-//
-namespace tag
-{
-    struct weighted_p_square_cumulative_distribution
-      : depends_on<count, sum_of_weights>
-      , p_square_cumulative_distribution_num_cells
-    {
-        typedef accumulators::impl::weighted_p_square_cumulative_distribution_impl<mpl::_1, mpl::_2> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_p_square_cumulative_distribution
-//
-namespace extract
-{
-    extractor<tag::weighted_p_square_cumulative_distribution> const weighted_p_square_cumulative_distribution = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_p_square_cumulative_distribution)
-}
-
-using extract::weighted_p_square_cumulative_distribution;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_p_square_quantile.hpp

@@ -1,255 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_p_square_quantile.hpp
-//
-//  Copyright 2005 Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_P_SQUARE_QUANTILE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_P_SQUARE_QUANTILE_HPP_DE_01_01_2006
-
-#include <cmath>
-#include <functional>
-#include <boost/array.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl {
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_p_square_quantile_impl
-    //  single quantile estimation with weighted samples
-    /**
-        @brief Single quantile estimation with the \f$P^2\f$ algorithm for weighted samples
-
-        This version of the \f$P^2\f$ algorithm extends the \f$P^2\f$ algorithm to support weighted samples.
-        The \f$P^2\f$ algorithm estimates a quantile dynamically without storing samples. Instead of
-        storing the whole sample cumulative distribution, only five points (markers) are stored. The heights
-        of these markers are the minimum and the maximum of the samples and the current estimates of the
-        \f$(p/2)\f$-, \f$p\f$ - and \f$(1+p)/2\f$ -quantiles. Their positions are equal to the number
-        of samples that are smaller or equal to the markers. Each time a new sample is added, the
-        positions of the markers are updated and if necessary their heights are adjusted using a piecewise-
-        parabolic formula.
-
-        For further details, see
-
-        R. Jain and I. Chlamtac, The P^2 algorithmus for dynamic calculation of quantiles and
-        histograms without storing observations, Communications of the ACM,
-        Volume 28 (October), Number 10, 1985, p. 1076-1085.
-
-        @param quantile_probability
-    */
-    template<typename Sample, typename Weight, typename Impl>
-    struct weighted_p_square_quantile_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
-        typedef array<float_type, 5> array_type;
-        // for boost::result_of
-        typedef float_type result_type;
-
-        template<typename Args>
-        weighted_p_square_quantile_impl(Args const &args)
-          : p(is_same<Impl, for_median>::value ? 0.5 : args[quantile_probability | 0.5])
-          , heights()
-          , actual_positions()
-          , desired_positions()
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-
-            // accumulate 5 first samples
-            if (cnt <= 5)
-            {
-                this->heights[cnt - 1] = args[sample];
-
-                // In this initialization phase, actual_positions stores the weights of the
-                // inital samples that are needed at the end of the initialization phase to
-                // compute the correct initial positions of the markers.
-                this->actual_positions[cnt - 1] = args[weight];
-
-                // complete the initialization of heights and actual_positions by sorting
-                if (cnt == 5)
-                {
-                    // TODO: we need to sort the initial samples (in heights) in ascending order and
-                    // sort their weights (in actual_positions) the same way. The following lines do
-                    // it, but there must be a better and more efficient way of doing this.
-                    typename array_type::iterator it_begin, it_end, it_min;
-
-                    it_begin = this->heights.begin();
-                    it_end   = this->heights.end();
-
-                    std::size_t pos = 0;
-
-                    while (it_begin != it_end)
-                    {
-                        it_min = std::min_element(it_begin, it_end);
-                        std::size_t d = std::distance(it_begin, it_min);
-                        std::swap(*it_begin, *it_min);
-                        std::swap(this->actual_positions[pos], this->actual_positions[pos + d]);
-                        ++it_begin;
-                        ++pos;
-                    }
-
-                    // calculate correct initial actual positions
-                    for (std::size_t i = 1; i < 5; ++i)
-                    {
-                        this->actual_positions[i] += this->actual_positions[i - 1];
-                    }
-                }
-            }
-            else
-            {
-                std::size_t sample_cell = 1; // k
-
-                // find cell k such that heights[k-1] <= args[sample] < heights[k] and adjust extreme values
-                if (args[sample] < this->heights[0])
-                {
-                    this->heights[0] = args[sample];
-                    this->actual_positions[0] = args[weight];
-                    sample_cell = 1;
-                }
-                else if (this->heights[4] <= args[sample])
-                {
-                    this->heights[4] = args[sample];
-                    sample_cell = 4;
-                }
-                else
-                {
-                    typedef typename array_type::iterator iterator;
-                    iterator it = std::upper_bound(
-                        this->heights.begin()
-                      , this->heights.end()
-                      , args[sample]
-                    );
-
-                    sample_cell = std::distance(this->heights.begin(), it);
-                }
-
-                // increment positions of markers above sample_cell
-                for (std::size_t i = sample_cell; i < 5; ++i)
-                {
-                    this->actual_positions[i] += args[weight];
-                }
-
-                // update desired positions for all markers
-                this->desired_positions[0] = this->actual_positions[0];
-                this->desired_positions[1] = (sum_of_weights(args) - this->actual_positions[0])
-                                           * this->p/2. + this->actual_positions[0];
-                this->desired_positions[2] = (sum_of_weights(args) - this->actual_positions[0])
-                                           * this->p + this->actual_positions[0];
-                this->desired_positions[3] = (sum_of_weights(args) - this->actual_positions[0])
-                                           * (1. + this->p)/2. + this->actual_positions[0];
-                this->desired_positions[4] = sum_of_weights(args);
-
-                // adjust height and actual positions of markers 1 to 3 if necessary
-                for (std::size_t i = 1; i <= 3; ++i)
-                {
-                    // offset to desired positions
-                    float_type d = this->desired_positions[i] - this->actual_positions[i];
-
-                    // offset to next position
-                    float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
-
-                    // offset to previous position
-                    float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
-
-                    // height ds
-                    float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
-                    float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
-
-                    if ( ( d >= 1. && dp > 1. ) || ( d <= -1. && dm < -1. ) )
-                    {
-                        short sign_d = static_cast<short>(d / std::abs(d));
-
-                        // try adjusting heights[i] using p-squared formula
-                        float_type h = this->heights[i] + sign_d / (dp - dm) * ( (sign_d - dm) * hp + (dp - sign_d) * hm );
-
-                        if ( this->heights[i - 1] < h && h < this->heights[i + 1] )
-                        {
-                            this->heights[i] = h;
-                        }
-                        else
-                        {
-                            // use linear formula
-                            if (d>0)
-                            {
-                                this->heights[i] += hp;
-                            }
-                            if (d<0)
-                            {
-                                this->heights[i] -= hm;
-                            }
-                        }
-                        this->actual_positions[i] += sign_d;
-                    }
-                }
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->heights[2];
-        }
-
-    private:
-        float_type p;                    // the quantile probability p
-        array_type heights;              // q_i
-        array_type actual_positions;     // n_i
-        array_type desired_positions;    // n'_i
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_p_square_quantile
-//
-namespace tag
-{
-    struct weighted_p_square_quantile
-      : depends_on<count, sum_of_weights>
-    {
-        typedef accumulators::impl::weighted_p_square_quantile_impl<mpl::_1, mpl::_2, regular> impl;
-    };
-    struct weighted_p_square_quantile_for_median
-      : depends_on<count, sum_of_weights>
-    {
-        typedef accumulators::impl::weighted_p_square_quantile_impl<mpl::_1, mpl::_2, for_median> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_p_square_quantile
-// extract::weighted_p_square_quantile_for_median
-//
-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 = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_p_square_quantile)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_p_square_quantile_for_median)
-}
-
-using extract::weighted_p_square_quantile;
-using extract::weighted_p_square_quantile_for_median;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp

@@ -1,288 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_peaks_over_threshold.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_PEAKS_OVER_THRESHOLD_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_PEAKS_OVER_THRESHOLD_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <numeric>
-#include <functional>
-#include <boost/range.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-#include <boost/accumulators/statistics/peaks_over_threshold.hpp> // for named parameters pot_threshold_value and pot_threshold_probability
-#include <boost/accumulators/statistics/sum.hpp>
-#include <boost/accumulators/statistics/tail_variate.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_peaks_over_threshold_impl
-    //  works with an explicit threshold value and does not depend on order statistics of weighted samples
-    /**
-        @brief Weighted Peaks over Threshold Method for Weighted Quantile and Weighted Tail Mean Estimation
-
-        @sa peaks_over_threshold_impl
-
-        @param quantile_probability
-        @param pot_threshold_value
-    */
-    template<typename Sample, typename Weight, typename LeftRight>
-    struct weighted_peaks_over_threshold_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Weight, Sample>::result_type weighted_sample;
-        typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef boost::tuple<float_type, float_type, float_type> result_type;
-
-        template<typename Args>
-        weighted_peaks_over_threshold_impl(Args const &args)
-          : sign_((is_same<LeftRight, left>::value) ? -1 : 1)
-          , mu_(sign_ * numeric::average(args[sample | Sample()], (std::size_t)1))
-          , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
-          , w_sum_(numeric::average(args[weight | Weight()], (std::size_t)1))
-          , threshold_(sign_ * args[pot_threshold_value])
-          , fit_parameters_(boost::make_tuple(0., 0., 0.))
-          , is_dirty_(true)
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            this->is_dirty_ = true;
-
-            if (this->sign_ * args[sample] > this->threshold_)
-            {
-                this->mu_ += args[weight] * args[sample];
-                this->sigma2_ += args[weight] * args[sample] * args[sample];
-                this->w_sum_ += args[weight];
-            }
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty_)
-            {
-                this->is_dirty_ = false;
-
-                this->mu_ = this->sign_ * numeric::average(this->mu_, this->w_sum_);
-                this->sigma2_ = numeric::average(this->sigma2_, this->w_sum_);
-                this->sigma2_ -= this->mu_ * this->mu_;
-
-                float_type threshold_probability = numeric::average(sum_of_weights(args) - this->w_sum_, sum_of_weights(args));
-
-                float_type tmp = numeric::average(( this->mu_ - this->threshold_ )*( this->mu_ - this->threshold_ ), this->sigma2_);
-                float_type xi_hat = 0.5 * ( 1. - tmp );
-                float_type beta_hat = 0.5 * ( this->mu_ - this->threshold_ ) * ( 1. + tmp );
-                float_type beta_bar = beta_hat * std::pow(1. - threshold_probability, xi_hat);
-                float_type u_bar = this->threshold_ - beta_bar * ( std::pow(1. - threshold_probability, -xi_hat) - 1.)/xi_hat;
-                this->fit_parameters_ = boost::make_tuple(u_bar, beta_bar, xi_hat);
-            }
-
-            return this->fit_parameters_;
-        }
-
-    private:
-        short sign_;                         // for left tail fitting, mirror the extreme values
-        mutable float_type mu_;              // mean of samples above threshold
-        mutable float_type sigma2_;          // variance of samples above threshold
-        mutable float_type w_sum_;           // sum of weights of samples above threshold
-        float_type threshold_;
-        mutable result_type fit_parameters_; // boost::tuple that stores fit parameters
-        mutable bool is_dirty_;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_peaks_over_threshold_prob_impl
-    //  determines threshold from a given threshold probability using order statistics
-    /**
-        @brief Peaks over Threshold Method for Quantile and Tail Mean Estimation
-
-        @sa weighted_peaks_over_threshold_impl
-
-        @param quantile_probability
-        @param pot_threshold_probability
-    */
-    template<typename Sample, typename Weight, typename LeftRight>
-    struct weighted_peaks_over_threshold_prob_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Weight, Sample>::result_type weighted_sample;
-        typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef boost::tuple<float_type, float_type, float_type> result_type;
-
-        template<typename Args>
-        weighted_peaks_over_threshold_prob_impl(Args const &args)
-          : sign_((is_same<LeftRight, left>::value) ? -1 : 1)
-          , mu_(sign_ * numeric::average(args[sample | Sample()], (std::size_t)1))
-          , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
-          , threshold_probability_(args[pot_threshold_probability])
-          , fit_parameters_(boost::make_tuple(0., 0., 0.))
-          , is_dirty_(true)
-        {
-        }
-
-        void operator ()(dont_care)
-        {
-            this->is_dirty_ = true;
-        }
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            if (this->is_dirty_)
-            {
-                this->is_dirty_ = false;
-
-                float_type threshold = sum_of_weights(args)
-                             * ( ( is_same<LeftRight, left>::value ) ? this->threshold_probability_ : 1. - this->threshold_probability_ );
-
-                std::size_t n = 0;
-                Weight sum = Weight(0);
-
-                while (sum < threshold)
-                {
-                    if (n < static_cast<std::size_t>(tail_weights(args).size()))
-                    {
-                        mu_ += *(tail_weights(args).begin() + n) * *(tail(args).begin() + n);
-                        sigma2_ += *(tail_weights(args).begin() + n) * *(tail(args).begin() + n) * (*(tail(args).begin() + n));
-                        sum += *(tail_weights(args).begin() + n);
-                        n++;
-                    }
-                    else
-                    {
-                        if (std::numeric_limits<float_type>::has_quiet_NaN)
-                        {
-                            return boost::make_tuple(
-                                std::numeric_limits<float_type>::quiet_NaN()
-                              , std::numeric_limits<float_type>::quiet_NaN()
-                              , std::numeric_limits<float_type>::quiet_NaN()
-                            );
-                        }
-                        else
-                        {
-                            std::ostringstream msg;
-                            msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                            boost::throw_exception(std::runtime_error(msg.str()));
-                            return boost::make_tuple(Sample(0), Sample(0), Sample(0));
-                        }
-                    }
-                }
-
-                float_type u = *(tail(args).begin() + n - 1) * this->sign_;
-
-
-                this->mu_ = this->sign_ * numeric::average(this->mu_, sum);
-                this->sigma2_ = numeric::average(this->sigma2_, sum);
-                this->sigma2_ -= this->mu_ * this->mu_;
-
-                if (is_same<LeftRight, left>::value)
-                    this->threshold_probability_ = 1. - this->threshold_probability_;
-
-                float_type tmp = numeric::average(( this->mu_ - u )*( this->mu_ - u ), this->sigma2_);
-                float_type xi_hat = 0.5 * ( 1. - tmp );
-                float_type beta_hat = 0.5 * ( this->mu_ - u ) * ( 1. + tmp );
-                float_type beta_bar = beta_hat * std::pow(1. - threshold_probability_, xi_hat);
-                float_type u_bar = u - beta_bar * ( std::pow(1. - threshold_probability_, -xi_hat) - 1.)/xi_hat;
-                this->fit_parameters_ = boost::make_tuple(u_bar, beta_bar, xi_hat);
-
-            }
-
-            return this->fit_parameters_;
-        }
-
-    private:
-        short sign_;                                // for left tail fitting, mirror the extreme values
-        mutable float_type mu_;                     // mean of samples above threshold u
-        mutable float_type sigma2_;                 // variance of samples above threshold u
-        mutable float_type threshold_probability_;
-        mutable result_type fit_parameters_;        // boost::tuple that stores fit parameters
-        mutable bool is_dirty_;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_peaks_over_threshold
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct weighted_peaks_over_threshold
-      : depends_on<sum_of_weights>
-      , pot_threshold_value
-    {
-        /// INTERNAL ONLY
-        typedef accumulators::impl::weighted_peaks_over_threshold_impl<mpl::_1, mpl::_2, LeftRight> impl;
-    };
-
-    template<typename LeftRight>
-    struct weighted_peaks_over_threshold_prob
-      : depends_on<sum_of_weights, tail_weights<LeftRight> >
-      , pot_threshold_probability
-    {
-        /// INTERNAL ONLY
-        typedef accumulators::impl::weighted_peaks_over_threshold_prob_impl<mpl::_1, mpl::_2, LeftRight> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_peaks_over_threshold
-//
-namespace extract
-{
-    extractor<tag::abstract_peaks_over_threshold> const weighted_peaks_over_threshold = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_peaks_over_threshold)
-}
-
-using extract::weighted_peaks_over_threshold;
-
-// weighted_peaks_over_threshold<LeftRight>(with_threshold_value) -> weighted_peaks_over_threshold<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::weighted_peaks_over_threshold<LeftRight>(with_threshold_value)>
-{
-    typedef tag::weighted_peaks_over_threshold<LeftRight> type;
-};
-
-// weighted_peaks_over_threshold<LeftRight>(with_threshold_probability) -> weighted_peaks_over_threshold_prob<LeftRight>
-template<typename LeftRight>
-struct as_feature<tag::weighted_peaks_over_threshold<LeftRight>(with_threshold_probability)>
-{
-    typedef tag::weighted_peaks_over_threshold_prob<LeftRight> type;
-};
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/weighted_skewness.hpp

@@ -1,101 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_skewness.hpp
-//
-//  Copyright 2006 Olivier Gygi, Daniel Egloff. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_SKEWNESS_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_SKEWNESS_HPP_EAN_28_10_2005
-
-#include <limits>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/weighted_moment.hpp>
-#include <boost/accumulators/statistics/weighted_mean.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_skewness_impl
-    /**
-        @brief Skewness estimation for weighted samples
-
-        The skewness of a sample distribution is defined as the ratio of the 3rd central moment and the \f$ 3/2 \f$-th power $
-        of the 2nd central moment (the variance) of the samples. The skewness can also be expressed by the simple moments:
-
-        \f[
-            \hat{g}_1 =
-                \frac
-                {\widehat{m}_n^{(3)}-3\widehat{m}_n^{(2)}\hat{\mu}_n+2\hat{\mu}_n^3}
-                {\left(\widehat{m}_n^{(2)} - \hat{\mu}_n^{2}\right)^{3/2}}
-        \f]
-
-        where \f$ \widehat{m}_n^{(i)} \f$ are the \f$ i \f$-th moment and \f$ \hat{\mu}_n \f$ the mean (first moment) of the
-        \f$ n \f$ samples.
-
-        The skewness estimator for weighted samples is formally identical to the estimator for unweighted samples, except that
-        the weighted counterparts of all measures it depends on are to be taken.
-    */
-    template<typename Sample, typename Weight>
-    struct weighted_skewness_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, weighted_sample>::result_type result_type;
-
-        weighted_skewness_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            return numeric::average(
-                        accumulators::weighted_moment<3>(args)
-                        - 3. * accumulators::weighted_moment<2>(args) * weighted_mean(args)
-                        + 2. * weighted_mean(args) * weighted_mean(args) * weighted_mean(args)
-                      , ( accumulators::weighted_moment<2>(args) - weighted_mean(args) * weighted_mean(args) )
-                      * std::sqrt( accumulators::weighted_moment<2>(args) - weighted_mean(args) * weighted_mean(args) )
-                   );
-        }
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_skewness
-//
-namespace tag
-{
-    struct weighted_skewness
-      : depends_on<weighted_mean, weighted_moment<2>, weighted_moment<3> >
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_skewness_impl<mpl::_1, mpl::_2> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_skewness
-//
-namespace extract
-{
-    extractor<tag::weighted_skewness> const weighted_skewness = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_skewness)
-}
-
-using extract::weighted_skewness;
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_sum.hpp

@@ -1,116 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_sum.hpp
-//
-//  Copyright 2006 Eric Niebler, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_SUM_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_SUM_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/parameters/weight.hpp>
-#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_sum_impl
-    template<typename Sample, typename Weight, typename Tag>
-    struct weighted_sum_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-
-        // for boost::result_of
-        typedef weighted_sample result_type;
-
-        template<typename Args>
-        weighted_sum_impl(Args const &args)
-          : weighted_sum_(
-                args[parameter::keyword<Tag>::get() | Sample()]
-                  * numeric::one<Weight>::value
-            )
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            // what about overflow?
-            this->weighted_sum_ += args[parameter::keyword<Tag>::get()] * args[weight];
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->weighted_sum_;
-        }
-
-    private:
-
-        weighted_sample weighted_sum_;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_sum
-//
-namespace tag
-{
-    struct weighted_sum
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_sum_impl<mpl::_1, mpl::_2, tag::sample> impl;
-    };
-
-    template<typename VariateType, typename VariateTag>
-    struct weighted_sum_of_variates
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_sum_impl<VariateType, mpl::_2, VariateTag> impl;
-    };
-
-    struct abstract_weighted_sum_of_variates
-      : depends_on<>
-    {
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_sum
-//
-namespace extract
-{
-    extractor<tag::weighted_sum> const weighted_sum = {};
-    extractor<tag::abstract_weighted_sum_of_variates> const weighted_sum_of_variates = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_sum)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_sum_of_variates)
-}
-
-using extract::weighted_sum;
-using extract::weighted_sum_of_variates;
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::weighted_sum_of_variates<VariateType, VariateTag> >
-  : feature_of<tag::abstract_weighted_sum_of_variates>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_sum_kahan.hpp

@@ -1,138 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_sum_kahan.hpp
-//
-//  Copyright 2011 Simon West. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_SUM_KAHAN_HPP_EAN_11_05_2011
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_SUM_KAHAN_HPP_EAN_11_05_2011
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/parameters/weight.hpp>
-#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/weighted_sum.hpp>
-#include <boost/numeric/conversion/cast.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-#if _MSC_VER > 1400
-# pragma float_control(push)
-# pragma float_control(precise, on)
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_sum_kahan_impl
-    template<typename Sample, typename Weight, typename Tag>
-    struct weighted_sum_kahan_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-
-        // for boost::result_of
-        typedef weighted_sample result_type;
-
-        template<typename Args>
-        weighted_sum_kahan_impl(Args const &args)
-          : weighted_sum_(
-                args[parameter::keyword<Tag>::get() | Sample()] * numeric::one<Weight>::value),
-                compensation(boost::numeric_cast<weighted_sample>(0.0))
-        {
-        }
-
-        template<typename Args>
-        void 
-#if BOOST_ACCUMULATORS_GCC_VERSION > 40305
-        __attribute__((optimize("no-associative-math")))
-#endif
-        operator ()(Args const &args)
-        {
-            const weighted_sample myTmp1 = args[parameter::keyword<Tag>::get()] * args[weight] - this->compensation;
-            const weighted_sample myTmp2 = this->weighted_sum_ + myTmp1;
-            this->compensation = (myTmp2 - this->weighted_sum_) - myTmp1;
-            this->weighted_sum_ = myTmp2;
-
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->weighted_sum_;
-        }
-
-    private:
-        weighted_sample weighted_sum_;
-        weighted_sample compensation;
-    };
-
-#if _MSC_VER > 1400
-# pragma float_control(pop)
-#endif
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_sum_kahan
-// tag::weighted_sum_of_variates_kahan
-//
-namespace tag
-{
-    struct weighted_sum_kahan
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_sum_kahan_impl<mpl::_1, mpl::_2, tag::sample> impl;
-    };
-
-    template<typename VariateType, typename VariateTag>
-    struct weighted_sum_of_variates_kahan
-      : depends_on<>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_sum_kahan_impl<VariateType, mpl::_2, VariateTag> impl;
-    };
-
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_sum_kahan
-// extract::weighted_sum_of_variates_kahan
-//
-namespace extract
-{
-    extractor<tag::weighted_sum_kahan> const weighted_sum_kahan = {};
-    extractor<tag::abstract_weighted_sum_of_variates> const weighted_sum_of_variates_kahan = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_sum_kahan)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_sum_of_variates_kahan)
-}
-
-using extract::weighted_sum_kahan;
-using extract::weighted_sum_of_variates_kahan;
-
-// weighted_sum(kahan) -> weighted_sum_kahan
-template<>
-struct as_feature<tag::weighted_sum(kahan)>
-{
-    typedef tag::weighted_sum_kahan type;
-};
-
-template<typename VariateType, typename VariateTag>
-struct feature_of<tag::weighted_sum_of_variates_kahan<VariateType, VariateTag> >
-  : feature_of<tag::abstract_weighted_sum_of_variates>
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/weighted_tail_mean.hpp

@@ -1,169 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_tail_mean.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_TAIL_MEAN_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_TAIL_MEAN_HPP_DE_01_01_2006
-
-#include <numeric>
-#include <vector>
-#include <limits>
-#include <functional>
-#include <sstream>
-#include <stdexcept>
-#include <boost/throw_exception.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/tail_mean.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // coherent_weighted_tail_mean_impl
-    //
-    // TODO
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // non_coherent_weighted_tail_mean_impl
-    //
-    /**
-        @brief Estimation of the (non-coherent) weighted tail mean based on order statistics (for both left and right tails)
-
-
-
-        An estimation of the non-coherent, weighted tail mean \f$\widehat{NCTM}_{n,\alpha}(X)\f$ is given by the weighted mean
-        of the
-
-        \f[
-            \lambda = \inf\left\{ l \left| \frac{1}{\bar{w}_n}\sum_{i=1}^{l} w_i \geq \alpha \right. \right\}
-        \f]
-
-        smallest samples (left tail) or the weighted mean of the
-
-        \f[
-            n + 1 - \rho = n + 1 - \sup\left\{ r \left| \frac{1}{\bar{w}_n}\sum_{i=r}^{n} w_i \geq (1 - \alpha) \right. \right\}
-        \f]
-
-        largest samples (right tail) above a quantile \f$\hat{q}_{\alpha}\f$ of level \f$\alpha\f$, \f$n\f$ being the total number of sample
-        and \f$\bar{w}_n\f$ the sum of all \f$n\f$ weights:
-
-        \f[
-            \widehat{NCTM}_{n,\alpha}^{\mathrm{left}}(X) = \frac{\sum_{i=1}^{\lambda} w_i X_{i:n}}{\sum_{i=1}^{\lambda} w_i},
-        \f]
-
-        \f[
-            \widehat{NCTM}_{n,\alpha}^{\mathrm{right}}(X) = \frac{\sum_{i=\rho}^n w_i X_{i:n}}{\sum_{i=\rho}^n w_i}.
-        \f]
-
-        @param quantile_probability
-    */
-    template<typename Sample, typename Weight, typename LeftRight>
-    struct non_coherent_weighted_tail_mean_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        typedef typename numeric::functional::average<Weight, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type result_type;
-
-        non_coherent_weighted_tail_mean_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            float_type threshold = sum_of_weights(args)
-                             * ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] );
-
-            std::size_t n = 0;
-            Weight sum = Weight(0);
-
-            while (sum < threshold)
-            {
-                if (n < static_cast<std::size_t>(tail_weights(args).size()))
-                {
-                    sum += *(tail_weights(args).begin() + n);
-                    n++;
-                }
-                else
-                {
-                    if (std::numeric_limits<result_type>::has_quiet_NaN)
-                    {
-                        return std::numeric_limits<result_type>::quiet_NaN();
-                    }
-                    else
-                    {
-                        std::ostringstream msg;
-                        msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                        boost::throw_exception(std::runtime_error(msg.str()));
-                        return result_type(0);
-                    }
-                }
-            }
-
-            return numeric::average(
-                std::inner_product(
-                    tail(args).begin()
-                  , tail(args).begin() + n
-                  , tail_weights(args).begin()
-                  , weighted_sample(0)
-                )
-              , sum
-            );
-        }
-    };
-
-} // namespace impl
-
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::non_coherent_weighted_tail_mean<>
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct non_coherent_weighted_tail_mean
-      : depends_on<sum_of_weights, tail_weights<LeftRight> >
-    {
-        typedef accumulators::impl::non_coherent_weighted_tail_mean_impl<mpl::_1, mpl::_2, LeftRight> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::non_coherent_weighted_tail_mean;
-//
-namespace extract
-{
-    extractor<tag::abstract_non_coherent_tail_mean> const non_coherent_weighted_tail_mean = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(non_coherent_weighted_tail_mean)
-}
-
-using extract::non_coherent_weighted_tail_mean;
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/weighted_tail_quantile.hpp

@@ -1,146 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_tail_quantile.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_TAIL_QUANTILE_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_TAIL_QUANTILE_HPP_DE_01_01_2006
-
-#include <vector>
-#include <limits>
-#include <functional>
-#include <sstream>
-#include <stdexcept>
-#include <boost/throw_exception.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/tail_quantile.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_tail_quantile_impl
-    //  Tail quantile estimation based on order statistics of weighted samples
-    /**
-        @brief Tail quantile estimation based on order statistics of weighted samples (for both left and right tails)
-
-        An estimator \f$\hat{q}\f$ of tail quantiles with level \f$\alpha\f$ based on order statistics
-        \f$X_{1:n} \leq X_{2:n} \leq\dots\leq X_{n:n}\f$ of weighted samples are given by \f$X_{\lambda:n}\f$ (left tail)
-        and \f$X_{\rho:n}\f$ (right tail), where
-
-            \f[
-                \lambda = \inf\left\{ l \left| \frac{1}{\bar{w}_n}\sum_{i=1}^{l} w_i \geq \alpha \right. \right\}
-            \f]
-
-        and
-
-            \f[
-                \rho = \sup\left\{ r \left| \frac{1}{\bar{w}_n}\sum_{i=r}^{n} w_i \geq (1 - \alpha) \right. \right\},
-            \f]
-
-        \f$n\f$ being the number of samples and \f$\bar{w}_n\f$ the sum of all weights.
-
-        @param quantile_probability
-    */
-    template<typename Sample, typename Weight, typename LeftRight>
-    struct weighted_tail_quantile_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Weight, std::size_t>::result_type float_type;
-        // for boost::result_of
-        typedef Sample result_type;
-
-        weighted_tail_quantile_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            float_type threshold = sum_of_weights(args)
-                             * ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] );
-
-            std::size_t n = 0;
-            Weight sum = Weight(0);
-
-            while (sum < threshold)
-            {
-                if (n < static_cast<std::size_t>(tail_weights(args).size()))
-                {
-                    sum += *(tail_weights(args).begin() + n);
-                    n++;
-                }
-                else
-                {
-                    if (std::numeric_limits<result_type>::has_quiet_NaN)
-                    {
-                        return std::numeric_limits<result_type>::quiet_NaN();
-                    }
-                    else
-                    {
-                        std::ostringstream msg;
-                        msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                        boost::throw_exception(std::runtime_error(msg.str()));
-                        return Sample(0);
-                    }
-                }
-            }
-
-            // Note that the cached samples of the left are sorted in ascending order,
-            // whereas the samples of the right tail are sorted in descending order
-            return *(boost::begin(tail(args)) + n - 1);
-        }
-    };
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_tail_quantile<>
-//
-namespace tag
-{
-    template<typename LeftRight>
-    struct weighted_tail_quantile
-      : depends_on<sum_of_weights, tail_weights<LeftRight> >
-    {
-        /// INTERNAL ONLY
-        typedef accumulators::impl::weighted_tail_quantile_impl<mpl::_1, mpl::_2, LeftRight> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_tail_quantile
-//
-namespace extract
-{
-    extractor<tag::quantile> const weighted_tail_quantile = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_tail_quantile)
-}
-
-using extract::weighted_tail_quantile;
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/weighted_tail_variate_means.hpp

@@ -1,242 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_tail_variate_means.hpp
-//
-//  Copyright 2006 Daniel Egloff, Olivier Gygi. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_TAIL_VARIATE_MEANS_HPP_DE_01_01_2006
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_TAIL_VARIATE_MEANS_HPP_DE_01_01_2006
-
-#include <numeric>
-#include <vector>
-#include <limits>
-#include <functional>
-#include <sstream>
-#include <stdexcept>
-#include <boost/throw_exception.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/tail.hpp>
-#include <boost/accumulators/statistics/tail_variate.hpp>
-#include <boost/accumulators/statistics/tail_variate_means.hpp>
-#include <boost/accumulators/statistics/weighted_tail_mean.hpp>
-#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-namespace boost
-{
-    // for _BinaryOperatrion2 in std::inner_product below
-    // mutliplies two values and promotes the result to double
-    namespace numeric { namespace functional
-    {
-        ///////////////////////////////////////////////////////////////////////////////
-        // numeric::functional::multiply_and_promote_to_double
-        template<typename T, typename U>
-        struct multiply_and_promote_to_double
-          : multiplies<T, double const>
-        {
-        };
-    }}
-}
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    /**
-        @brief Estimation of the absolute and relative weighted tail variate means (for both left and right tails)
-
-        For all \f$j\f$-th variates associated to the
-
-        \f[
-            \lambda = \inf\left\{ l \left| \frac{1}{\bar{w}_n}\sum_{i=1}^{l} w_i \geq \alpha \right. \right\}
-        \f]
-
-        smallest samples (left tail) or the weighted mean of the
-
-        \f[
-            n + 1 - \rho = n + 1 - \sup\left\{ r \left| \frac{1}{\bar{w}_n}\sum_{i=r}^{n} w_i \geq (1 - \alpha) \right. \right\}
-        \f]
-
-        largest samples (right tail), the absolute weighted tail means \f$\widehat{ATM}_{n,\alpha}(X, j)\f$
-        are computed and returned as an iterator range. Alternatively, the relative weighted tail means
-        \f$\widehat{RTM}_{n,\alpha}(X, j)\f$ are returned, which are the absolute weighted tail means
-        normalized with the weighted (non-coherent) sample tail mean \f$\widehat{NCTM}_{n,\alpha}(X)\f$.
-
-        \f[
-            \widehat{ATM}_{n,\alpha}^{\mathrm{right}}(X, j) =
-                \frac{1}{\sum_{i=\rho}^n w_i}
-                \sum_{i=\rho}^n w_i \xi_{j,i}
-        \f]
-
-        \f[
-            \widehat{ATM}_{n,\alpha}^{\mathrm{left}}(X, j) =
-                \frac{1}{\sum_{i=1}^{\lambda}}
-                \sum_{i=1}^{\lambda} w_i \xi_{j,i}
-        \f]
-
-        \f[
-            \widehat{RTM}_{n,\alpha}^{\mathrm{right}}(X, j) =
-                \frac{\sum_{i=\rho}^n w_i \xi_{j,i}}
-            {\sum_{i=\rho}^n w_i \widehat{NCTM}_{n,\alpha}^{\mathrm{right}}(X)}
-        \f]
-
-        \f[
-            \widehat{RTM}_{n,\alpha}^{\mathrm{left}}(X, j) =
-                \frac{\sum_{i=1}^{\lambda} w_i \xi_{j,i}}
-            {\sum_{i=1}^{\lambda} w_i \widehat{NCTM}_{n,\alpha}^{\mathrm{left}}(X)}
-        \f]
-    */
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // weighted_tail_variate_means_impl
-    //  by default: absolute weighted_tail_variate_means
-    template<typename Sample, typename Weight, typename Impl, typename LeftRight, typename VariateType>
-    struct weighted_tail_variate_means_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::average<Weight, Weight>::result_type float_type;
-        typedef typename numeric::functional::average<typename numeric::functional::multiplies<VariateType, Weight>::result_type, Weight>::result_type array_type;
-        // for boost::result_of
-        typedef iterator_range<typename array_type::iterator> result_type;
-
-        weighted_tail_variate_means_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            float_type threshold = sum_of_weights(args)
-                             * ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] );
-
-            std::size_t n = 0;
-            Weight sum = Weight(0);
-
-            while (sum < threshold)
-            {
-                if (n < static_cast<std::size_t>(tail_weights(args).size()))
-                {
-                    sum += *(tail_weights(args).begin() + n);
-                    n++;
-                }
-                else
-                {
-                    if (std::numeric_limits<float_type>::has_quiet_NaN)
-                    {
-                        std::fill(
-                            this->tail_means_.begin()
-                          , this->tail_means_.end()
-                          , std::numeric_limits<float_type>::quiet_NaN()
-                        );
-                    }
-                    else
-                    {
-                        std::ostringstream msg;
-                        msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
-                        boost::throw_exception(std::runtime_error(msg.str()));
-                    }
-                }
-            }
-
-            std::size_t num_variates = tail_variate(args).begin()->size();
-
-            this->tail_means_.clear();
-            this->tail_means_.resize(num_variates, Sample(0));
-
-            this->tail_means_ = std::inner_product(
-                tail_variate(args).begin()
-              , tail_variate(args).begin() + n
-              , tail_weights(args).begin()
-              , this->tail_means_
-              , numeric::functional::plus<array_type const, array_type const>()
-              , numeric::functional::multiply_and_promote_to_double<VariateType const, Weight const>()
-            );
-
-            float_type factor = sum * ( (is_same<Impl, relative>::value) ? non_coherent_weighted_tail_mean(args) : 1. );
-
-            std::transform(
-                this->tail_means_.begin()
-              , this->tail_means_.end()
-              , this->tail_means_.begin()
-              , std::bind2nd(numeric::functional::divides<typename array_type::value_type const, float_type const>(), factor)
-            );
-
-            return make_iterator_range(this->tail_means_);
-        }
-
-    private:
-
-        mutable array_type tail_means_;
-
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::absolute_weighted_tail_variate_means
-// tag::relative_weighted_tail_variate_means
-//
-namespace tag
-{
-    template<typename LeftRight, typename VariateType, typename VariateTag>
-    struct absolute_weighted_tail_variate_means
-      : depends_on<non_coherent_weighted_tail_mean<LeftRight>, tail_variate<VariateType, VariateTag, LeftRight>, tail_weights<LeftRight> >
-    {
-        typedef accumulators::impl::weighted_tail_variate_means_impl<mpl::_1, mpl::_2, absolute, LeftRight, VariateType> impl;
-    };
-    template<typename LeftRight, typename VariateType, typename VariateTag>
-    struct relative_weighted_tail_variate_means
-      : depends_on<non_coherent_weighted_tail_mean<LeftRight>, tail_variate<VariateType, VariateTag, LeftRight>, tail_weights<LeftRight> >
-    {
-        typedef accumulators::impl::weighted_tail_variate_means_impl<mpl::_1, mpl::_2, relative, LeftRight, VariateType> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_tail_variate_means
-// extract::relative_weighted_tail_variate_means
-//
-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 = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_tail_variate_means)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(relative_weighted_tail_variate_means)
-}
-
-using extract::weighted_tail_variate_means;
-using extract::relative_weighted_tail_variate_means;
-
-// weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(absolute) -> absolute_weighted_tail_variate_means<LeftRight, VariateType, VariateTag>
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct as_feature<tag::weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(absolute)>
-{
-    typedef tag::absolute_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> type;
-};
-
-// weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(relative) -> relative_weighted_tail_variate_means<LeftRight, VariateType, VariateTag>
-template<typename LeftRight, typename VariateType, typename VariateTag>
-struct as_feature<tag::weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(relative)>
-{
-    typedef tag::relative_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> type;
-};
-
-}} // namespace boost::accumulators
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

test/external/boost/accumulators/statistics/weighted_variance.hpp

@@ -1,186 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// weighted_variance.hpp
-//
-//  Copyright 2005 Daniel Egloff, Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_VARIANCE_HPP_EAN_28_10_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_VARIANCE_HPP_EAN_28_10_2005
-
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/framework/accumulator_base.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-#include <boost/accumulators/numeric/functional.hpp>
-#include <boost/accumulators/framework/parameters/sample.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/count.hpp>
-#include <boost/accumulators/statistics/variance.hpp>
-#include <boost/accumulators/statistics/weighted_sum.hpp>
-#include <boost/accumulators/statistics/weighted_mean.hpp>
-#include <boost/accumulators/statistics/weighted_moment.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace impl
-{
-    //! Lazy calculation of variance of weighted samples.
-    /*!
-        The default implementation of the variance of weighted samples is based on the second moment
-        \f$\widehat{m}_n^{(2)}\f$ (weighted_moment<2>) and the mean\f$ \hat{\mu}_n\f$ (weighted_mean):
-        \f[
-            \hat{\sigma}_n^2 = \widehat{m}_n^{(2)}-\hat{\mu}_n^2,
-        \f]
-        where \f$n\f$ is the number of samples.
-    */
-    template<typename Sample, typename Weight, typename MeanFeature>
-    struct lazy_weighted_variance_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
-
-        lazy_weighted_variance_impl(dont_care) {}
-
-        template<typename Args>
-        result_type result(Args const &args) const
-        {
-            extractor<MeanFeature> const some_mean = {};
-            result_type tmp = some_mean(args);
-            return accumulators::weighted_moment<2>(args) - tmp * tmp;
-        }
-    };
-
-    //! Iterative calculation of variance of weighted samples.
-    /*!
-        Iterative calculation of variance of weighted samples:
-        \f[
-            \hat{\sigma}_n^2 =
-                \frac{\bar{w}_n - w_n}{\bar{w}_n}\hat{\sigma}_{n - 1}^2
-              + \frac{w_n}{\bar{w}_n - w_n}\left(X_n - \hat{\mu}_n\right)^2
-            ,\quad n\ge2,\quad\hat{\sigma}_0^2 = 0.
-        \f]
-        where \f$\bar{w}_n\f$ is the sum of the \f$n\f$ weights \f$w_i\f$ and \f$\hat{\mu}_n\f$
-        the estimate of the mean of the weighted smaples. Note that the sample variance is not defined for
-        \f$n <= 1\f$.
-    */
-    template<typename Sample, typename Weight, typename MeanFeature, typename Tag>
-    struct weighted_variance_impl
-      : accumulator_base
-    {
-        typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
-        // for boost::result_of
-        typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
-
-        template<typename Args>
-        weighted_variance_impl(Args const &args)
-          : weighted_variance(numeric::average(args[sample | Sample()], numeric::one<Weight>::value))
-        {
-        }
-
-        template<typename Args>
-        void operator ()(Args const &args)
-        {
-            std::size_t cnt = count(args);
-
-            if(cnt > 1)
-            {
-                extractor<MeanFeature> const some_mean = {};
-
-                result_type tmp = args[parameter::keyword<Tag>::get()] - some_mean(args);
-
-                this->weighted_variance =
-                    numeric::average(this->weighted_variance * (sum_of_weights(args) - args[weight]), sum_of_weights(args))
-                  + numeric::average(tmp * tmp * args[weight], sum_of_weights(args) - args[weight] );
-            }
-        }
-
-        result_type result(dont_care) const
-        {
-            return this->weighted_variance;
-        }
-
-    private:
-        result_type weighted_variance;
-    };
-
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// tag::weighted_variance
-// tag::immediate_weighted_variance
-//
-namespace tag
-{
-    struct lazy_weighted_variance
-      : depends_on<weighted_moment<2>, weighted_mean>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::lazy_weighted_variance_impl<mpl::_1, mpl::_2, weighted_mean> impl;
-    };
-
-    struct weighted_variance
-      : depends_on<count, immediate_weighted_mean>
-    {
-        /// INTERNAL ONLY
-        ///
-        typedef accumulators::impl::weighted_variance_impl<mpl::_1, mpl::_2, immediate_weighted_mean, sample> impl;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// extract::weighted_variance
-// extract::immediate_weighted_variance
-//
-namespace extract
-{
-    extractor<tag::lazy_weighted_variance> const lazy_weighted_variance = {};
-    extractor<tag::weighted_variance> const weighted_variance = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(lazy_weighted_variance)
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_variance)
-}
-
-using extract::lazy_weighted_variance;
-using extract::weighted_variance;
-
-// weighted_variance(lazy) -> lazy_weighted_variance
-template<>
-struct as_feature<tag::weighted_variance(lazy)>
-{
-    typedef tag::lazy_weighted_variance type;
-};
-
-// weighted_variance(immediate) -> weighted_variance
-template<>
-struct as_feature<tag::weighted_variance(immediate)>
-{
-    typedef tag::weighted_variance type;
-};
-
-////////////////////////////////////////////////////////////////////////////
-//// droppable_accumulator<weighted_variance_impl>
-////  need to specialize droppable lazy weighted_variance to cache the result at the
-////  point the accumulator is dropped.
-///// INTERNAL ONLY
-/////
-//template<typename Sample, typename Weight, typename MeanFeature>
-//struct droppable_accumulator<impl::weighted_variance_impl<Sample, Weight, MeanFeature> >
-//  : droppable_accumulator_base<
-//        with_cached_result<impl::weighted_variance_impl<Sample, Weight, MeanFeature> >
-//    >
-//{
-//    template<typename Args>
-//    droppable_accumulator(Args const &args)
-//      : droppable_accumulator::base(args)
-//    {
-//    }
-//};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics/with_error.hpp

@@ -1,44 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// with_error.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_WITH_ERROR_HPP_EAN_01_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_WITH_ERROR_HPP_EAN_01_11_2005
-
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/transform_view.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/accumulators/statistics_fwd.hpp>
-#include <boost/accumulators/statistics/error_of.hpp>
-
-namespace boost { namespace accumulators
-{
-
-namespace detail
-{
-    template<typename Feature>
-    struct error_of_tag
-    {
-        typedef tag::error_of<Feature> type;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// with_error
-//
-template<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature)>
-struct with_error
-  : mpl::transform_view<
-        mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)>
-      , detail::error_of_tag<mpl::_1>
-    >
-{
-};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/accumulators/statistics_fwd.hpp

@@ -1,432 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// statistics_fwd.hpp
-//
-//  Copyright 2005 Eric Niebler. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ACCUMULATORS_STATISTICS_STATISTICS_FWD_HPP_EAN_23_11_2005
-#define BOOST_ACCUMULATORS_STATISTICS_STATISTICS_FWD_HPP_EAN_23_11_2005
-
-#include <boost/mpl/apply_fwd.hpp> // for mpl::na
-#include <boost/mpl/print.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/accumulators/accumulators_fwd.hpp>
-#include <boost/accumulators/framework/depends_on.hpp>
-#include <boost/accumulators/framework/extractor.hpp>
-
-namespace boost { namespace accumulators
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// base struct and base extractor for quantiles
-namespace tag
-{
-    struct quantile
-      : depends_on<>
-    {
-        typedef mpl::print<class ____MISSING_SPECIFIC_QUANTILE_FEATURE_IN_ACCUMULATOR_SET____ > impl;
-    };
-}
-namespace extract
-{
-    extractor<tag::quantile> const quantile = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(quantile)
-}
-using extract::quantile;
-
-///////////////////////////////////////////////////////////////////////////////
-// base struct and base extractor for *coherent* tail means
-namespace tag
-{
-    struct tail_mean
-      : depends_on<>
-    {
-        typedef mpl::print<class ____MISSING_SPECIFIC_TAIL_MEAN_FEATURE_IN_ACCUMULATOR_SET____ > impl;
-    };
-}
-namespace extract
-{
-    extractor<tag::tail_mean> const tail_mean = {};
-
-    BOOST_ACCUMULATORS_IGNORE_GLOBAL(tail_mean)
-}
-using extract::tail_mean;
-
-namespace tag
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // Variates tags
-    struct weights;
-    struct covariate1;
-    struct covariate2;
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // Statistic tags
-    struct count;
-    template<typename VariateType, typename VariateTag>
-    struct covariance;
-    struct density;
-    template<typename Feature>
-    struct error_of;
-    struct extended_p_square;
-    struct extended_p_square_quantile;
-    struct extended_p_square_quantile_quadratic;
-    struct kurtosis;
-    struct max;
-    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;
-    struct median;
-    struct with_density_median;
-    struct with_p_square_cumulative_distribution_median;
-    struct min;
-    template<int N>
-    struct moment;
-    template<typename LeftRight>
-    struct peaks_over_threshold;
-    template<typename LeftRight>
-    struct peaks_over_threshold_prob;
-    template<typename LeftRight>
-    struct pot_tail_mean;
-    template<typename LeftRight>
-    struct pot_tail_mean_prob;
-    template<typename LeftRight>
-    struct pot_quantile;
-    template<typename LeftRight>
-    struct pot_quantile_prob;
-    struct p_square_cumulative_distribution;
-    struct p_square_quantile;
-    struct p_square_quantile_for_median;
-    struct skewness;
-    struct sum;
-    struct sum_of_weights;
-    template<typename VariateType, typename VariateTag>
-    struct sum_of_variates;
-    struct sum_kahan;
-    struct sum_of_weights_kahan;
-    template<typename VariateType, typename VariateTag>
-    struct sum_of_variates_kahan;
-    template<typename LeftRight>
-    struct tail;
-    template<typename LeftRight>
-    struct coherent_tail_mean;
-    template<typename LeftRight>
-    struct non_coherent_tail_mean;
-    template<typename LeftRight>
-    struct tail_quantile;
-    template<typename VariateType, typename VariateTag, typename LeftRight>
-    struct tail_variate;
-    template<typename LeftRight>
-    struct tail_weights;
-    template<typename VariateType, typename VariateTag, typename LeftRight>
-    struct right_tail_variate;
-    template<typename VariateType, typename VariateTag, typename LeftRight>
-    struct left_tail_variate;
-    template<typename LeftRight, typename VariateType, typename VariateTag>
-    struct tail_variate_means;
-    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 lazy_variance;
-    struct variance;
-    template<typename VariateType, typename VariateTag>
-    struct weighted_covariance;
-    struct weighted_density;
-    struct weighted_kurtosis;
-    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;
-    struct weighted_median;
-    struct with_density_weighted_median;
-    struct with_p_square_cumulative_distribution_weighted_median;
-    struct weighted_extended_p_square;
-    struct weighted_extended_p_square_quantile;
-    struct weighted_extended_p_square_quantile_quadratic;
-    template<int N>
-    struct weighted_moment;
-    template<typename LeftRight>
-    struct weighted_peaks_over_threshold;
-    template<typename LeftRight>
-    struct weighted_peaks_over_threshold_prob;
-    template<typename LeftRight>
-    struct weighted_pot_quantile;
-    template<typename LeftRight>
-    struct weighted_pot_quantile_prob;
-    template<typename LeftRight>
-    struct weighted_pot_tail_mean;
-    template<typename LeftRight>
-    struct weighted_pot_tail_mean_prob;
-    struct weighted_p_square_cumulative_distribution;
-    struct weighted_p_square_quantile;
-    struct weighted_p_square_quantile_for_median;
-    struct weighted_skewness;
-    template<typename LeftRight>
-    struct weighted_tail_quantile;
-    template<typename LeftRight>
-    struct non_coherent_weighted_tail_mean;
-    template<typename LeftRight>
-    struct weighted_tail_quantile;
-    template<typename LeftRight, typename VariateType, typename VariateTag>
-    struct weighted_tail_variate_means;
-    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;
-    struct lazy_weighted_variance;
-    struct weighted_variance;
-    struct weighted_sum;
-    template<typename VariateType, typename VariateTag>
-    struct weighted_sum_of_variates;
-    struct rolling_window_plus1;
-    struct rolling_window;
-    struct rolling_sum;
-    struct rolling_count;
-    struct rolling_mean;
-} // namespace tag
-
-namespace impl
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // Statistics impls
-    struct count_impl;
-
-    template<typename Sample, typename VariateType, typename VariateTag>
-    struct covariance_impl;
-
-    template<typename Sample>
-    struct density_impl;
-
-    template<typename Sample, typename Feature>
-    struct error_of_impl;
-
-    template<typename Sample, typename Variance>
-    struct error_of_mean_impl;
-
-    template<typename Sample>
-    struct extended_p_square_impl;
-
-    template<typename Sample, typename Impl1, typename Impl2>
-    struct extended_p_square_quantile_impl;
-
-    template<typename Sample>
-    struct kurtosis_impl;
-
-    template<typename Sample>
-    struct max_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;
-
-    template<typename Sample>
-    struct min_impl;
-
-    template<typename Sample, typename SumFeature = tag::sum>
-    struct mean_impl;
-
-    template<typename Sample, typename Tag = tag::sample>
-    struct immediate_mean_impl;
-
-    template<typename N, typename Sample>
-    struct moment_impl;
-
-    template<typename Sample, typename LeftRight>
-    struct peaks_over_threshold_prob_impl;
-
-    template<typename Sample, typename Impl, typename LeftRight>
-    struct pot_quantile_impl;
-
-    template<typename Sample, typename Impl, typename LeftRight>
-    struct pot_tail_mean_impl;
-
-    template<typename Sample>
-    struct p_square_cumulative_distribution_impl;
-
-    template<typename Sample, typename Impl>
-    struct p_square_quantile_impl;
-
-    template<typename Sample>
-    struct skewness_impl;
-
-    template<typename Sample, typename Tag = tag::sample>
-    struct sum_impl;
-
-    template<typename Sample, typename Tag>
-    struct sum_kahan_impl;
-
-    template<typename Sample, typename LeftRight>
-    struct tail_impl;
-
-    template<typename Sample, typename LeftRight>
-    struct coherent_tail_mean_impl;
-
-    template<typename Sample, typename LeftRight>
-    struct non_coherent_tail_mean_impl;
-
-    template<typename Sample, typename LeftRight>
-    struct tail_quantile_impl;
-
-    template<typename VariateType, typename VariateTag, typename LeftRight>
-    struct tail_variate_impl;
-
-    template<typename Sample, typename Impl, typename LeftRight, typename VariateTag>
-    struct tail_variate_means_impl;
-
-    template<typename Sample, typename MeanFeature>
-    struct lazy_variance_impl;
-
-    template<typename Sample, typename MeanFeature, typename Tag>
-    struct variance_impl;
-
-    template<typename Sample, typename Weight, typename VariateType, typename VariateTag>
-    struct weighted_covariance_impl;
-
-    template<typename Sample, typename Weight>
-    struct weighted_density_impl;
-
-    template<typename Sample, typename Weight>
-    struct weighted_kurtosis_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;
-
-    template<typename Sample, typename Weight, typename Tag>
-    struct weighted_mean_impl;
-
-    template<typename Sample, typename Weight, typename Tag>
-    struct immediate_weighted_mean_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;
-
-    template<typename Sample, typename Weight>
-    struct with_p_square_cumulative_distribution_weighted_median_impl;
-
-    template<typename Sample, typename Weight>
-    struct weighted_extended_p_square_impl;
-
-    template<typename N, typename Sample, typename Weight>
-    struct weighted_moment_impl;
-
-    template<typename Sample, typename Weight>
-    struct weighted_p_square_cumulative_distribution_impl;
-
-    template<typename Sample, typename Weight, typename Impl>
-    struct weighted_p_square_quantile_impl;
-
-    template<typename Sample, typename Weight>
-    struct weighted_skewness_impl;
-
-    template<typename Sample, typename Weight, typename Tag>
-    struct weighted_sum_impl;
-
-    template<typename Sample, typename Weight, typename Tag>
-    struct weighted_sum_kahan_impl;
-
-    template<typename Sample, typename Weight, typename LeftRight>
-    struct non_coherent_weighted_tail_mean_impl;
-
-    template<typename Sample, typename Weight, typename LeftRight>
-    struct weighted_tail_quantile_impl;
-
-    template<typename Sample, typename Weight, typename Impl, typename LeftRight, typename VariateType>
-    struct weighted_tail_variate_means_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;
-
-    template<typename Sample>
-    struct rolling_window_plus1_impl;
-
-    template<typename Sample>
-    struct rolling_window_impl;
-
-    template<typename Sample>
-    struct rolling_sum_impl;
-
-    template<typename Sample>
-    struct rolling_count_impl;
-
-    template<typename Sample>
-    struct rolling_mean_impl;
-} // namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-// stats
-//      A more descriptive name for an MPL sequence of statistics.
-template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature, mpl::na)>
-struct stats;
-
-template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature, mpl::na)>
-struct with_error;
-
-// modifiers for the mean and variance stats
-struct lazy {};
-struct immediate {};
-
-// modifiers for the variance stat
-// struct fast {};
-// struct accurate {};
-
-// modifiers for order
-struct right {};
-struct left {};
-// typedef right default_order_tag_type;
-
-// modifiers for the tail_variate_means stat
-struct absolute {};
-struct relative {};
-
-// modifiers for median and weighted_median stats
-struct with_density {};
-struct with_p_square_cumulative_distribution {};
-struct with_p_square_quantile {};
-
-// modifiers for peaks_over_threshold stat
-struct with_threshold_value {};
-struct with_threshold_probability {};
-
-// modifiers for extended_p_square_quantile and weighted_extended_p_square_quantile stats
-struct weighted {};
-struct unweighted {};
-struct linear {};
-struct quadratic {};
-
-// modifiers for p_square_quantile
-struct regular {};
-struct for_median {};
-
-// modifier for sum_kahan, sum_of_weights_kahan, sum_of_variates_kahan, weighted_sum_kahan
-struct kahan {};
-
-}} // namespace boost::accumulators
-
-#endif

test/external/boost/algorithm/minmax.hpp

@@ -1,47 +0,0 @@
-//  (C) Copyright Herve Bronnimann 2004.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-/*
- Revision history:
-   1 July 2004
-      Split the code into two headers to lessen dependence on
-      Boost.tuple. (Herve)
-   26 June 2004
-      Added the code for the boost minmax library. (Herve)
-*/
-
-#ifndef BOOST_ALGORITHM_MINMAX_HPP
-#define BOOST_ALGORITHM_MINMAX_HPP
-
-/* PROPOSED STANDARD EXTENSIONS:
- *
- * minmax(a, b)
- * Effect: (b<a) ? std::make_pair(b,a) : std::make_pair(a,b);
- *
- * minmax(a, b, comp)
- * Effect: comp(b,a) ? std::make_pair(b,a) : std::make_pair(a,b);
- *
- */
-
-#include <boost/tuple/tuple.hpp> // for using pairs with boost::cref
-#include <boost/ref.hpp>
-
-namespace boost {
-
-  template <typename T>
-  tuple< T const&, T const& >
-  minmax(T const& a, T const& b) {
-    return (b<a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
-  }
-
-  template <typename T, class BinaryPredicate>
-  tuple< T const&, T const& >
-  minmax(T const& a, T const& b, BinaryPredicate comp) {
-    return comp(b,a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
-  }
-
-} // namespace boost
-
-#endif // BOOST_ALGORITHM_MINMAX_HPP

test/external/boost/algorithm/minmax_element.hpp

@@ -1,551 +0,0 @@
-//  (C) Copyright Herve Bronnimann 2004.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-/*
- Revision history:
-   1 July 2004
-      Split the code into two headers to lessen dependence on
-      Boost.tuple. (Herve)
-   26 June 2004
-      Added the code for the boost minmax library. (Herve)
-*/
-
-#ifndef BOOST_ALGORITHM_MINMAX_ELEMENT_HPP
-#define BOOST_ALGORITHM_MINMAX_ELEMENT_HPP
-
-/* PROPOSED STANDARD EXTENSIONS:
- *
- * minmax_element(first, last)
- * Effect: std::make_pair( std::min_element(first, last),
- *                         std::max_element(first, last) );
- *
- * minmax_element(first, last, comp)
- * Effect: std::make_pair( std::min_element(first, last, comp),
- *                         std::max_element(first, last, comp) );
- */
-
-#include <utility> // for std::pair and std::make_pair
-
-namespace boost {
-
-  namespace detail {  // for obtaining a uniform version of minmax_element
-    // that compiles with VC++ 6.0 -- avoid the iterator_traits by
-    // having comparison object over iterator, not over dereferenced value
-
-    template <typename Iterator>
-    struct less_over_iter {
-      bool operator()(Iterator const& it1,
-                      Iterator const& it2) const { return *it1 < *it2; }
-    };
-
-    template <typename Iterator, class BinaryPredicate>
-    struct binary_pred_over_iter {
-      explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p ) {}
-      bool operator()(Iterator const& it1,
-                      Iterator const& it2) const { return m_p(*it1, *it2); }
-    private:
-      BinaryPredicate m_p;
-    };
-
-    // common base for the two minmax_element overloads
-
-    template <typename ForwardIter, class Compare >
-    std::pair<ForwardIter,ForwardIter>
-    basic_minmax_element(ForwardIter first, ForwardIter last, Compare comp)
-    {
-      if (first == last)
-        return std::make_pair(last,last);
-
-      ForwardIter min_result = first;
-      ForwardIter max_result = first;
-
-      // if only one element
-      ForwardIter second = first; ++second;
-      if (second == last)
-        return std::make_pair(min_result, max_result);
-
-      // treat first pair separately (only one comparison for first two elements)
-      ForwardIter potential_min_result = last;
-      if (comp(first, second))
-        max_result = second;
-      else {
-        min_result = second;
-        potential_min_result = first;
-      }
-
-      // then each element by pairs, with at most 3 comparisons per pair
-      first = ++second; if (first != last) ++second;
-      while (second != last) {
-        if (comp(first, second)) {
-          if (comp(first, min_result)) {
-            min_result = first;
-            potential_min_result = last;
-          }
-          if (comp(max_result, second))
-            max_result = second;
-        } else {
-          if (comp(second, min_result)) {
-            min_result = second;
-            potential_min_result = first;
-          }
-          if (comp(max_result, first))
-            max_result = first;
-        }
-        first = ++second;
-        if (first != last) ++second;
-      }
-
-      // if odd number of elements, treat last element
-      if (first != last) { // odd number of elements
-        if (comp(first, min_result))
-          min_result = first, potential_min_result = last;
-        else if (comp(max_result, first))
-          max_result = first;
-      }
-
-      // resolve min_result being incorrect with one extra comparison
-      // (in which case potential_min_result is necessarily the correct result)
-      if (potential_min_result != last
-        && !comp(min_result, potential_min_result))
-        min_result = potential_min_result;
-
-      return std::make_pair(min_result,max_result);
-    }
-
-  } // namespace detail
-
-  template <typename ForwardIter>
-  std::pair<ForwardIter,ForwardIter>
-  minmax_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_minmax_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  std::pair<ForwardIter,ForwardIter>
-  minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
-  {
-    return detail::basic_minmax_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-}
-
-/* PROPOSED BOOST EXTENSIONS
- * In the description below, [rfirst,rlast) denotes the reversed range
- * of [first,last). Even though the iterator type of first and last may
- * be only a Forward Iterator, it is possible to explain the semantics
- * by assuming that it is a Bidirectional Iterator. In the sequel,
- * reverse(ForwardIterator&) returns the reverse_iterator adaptor.
- * This is not how the functions would be implemented!
- *
- * first_min_element(first, last)
- * Effect: std::min_element(first, last);
- *
- * first_min_element(first, last, comp)
- * Effect: std::min_element(first, last, comp);
- *
- * last_min_element(first, last)
- * Effect: reverse( std::min_element(reverse(last), reverse(first)) );
- *
- * last_min_element(first, last, comp)
- * Effect: reverse( std::min_element(reverse(last), reverse(first), comp) );
- *
- * first_max_element(first, last)
- * Effect: std::max_element(first, last);
- *
- * first_max_element(first, last, comp)
- * Effect: max_element(first, last);
- *
- * last_max_element(first, last)
- * Effect: reverse( std::max_element(reverse(last), reverse(first)) );
- *
- * last_max_element(first, last, comp)
- * Effect: reverse( std::max_element(reverse(last), reverse(first), comp) );
- *
- * first_min_first_max_element(first, last)
- * Effect: std::make_pair( first_min_element(first, last),
- *                         first_max_element(first, last) );
- *
- * first_min_first_max_element(first, last, comp)
- * Effect: std::make_pair( first_min_element(first, last, comp),
- *                         first_max_element(first, last, comp) );
- *
- * first_min_last_max_element(first, last)
- * Effect: std::make_pair( first_min_element(first, last),
- *                         last_max_element(first, last) );
- *
- * first_min_last_max_element(first, last, comp)
- * Effect: std::make_pair( first_min_element(first, last, comp),
- *                         last_max_element(first, last, comp) );
- *
- * last_min_first_max_element(first, last)
- * Effect: std::make_pair( last_min_element(first, last),
- *                         first_max_element(first, last) );
- *
- * last_min_first_max_element(first, last, comp)
- * Effect: std::make_pair( last_min_element(first, last, comp),
- *                         first_max_element(first, last, comp) );
- *
- * last_min_last_max_element(first, last)
- * Effect: std::make_pair( last_min_element(first, last),
- *                         last_max_element(first, last) );
- *
- * last_min_last_max_element(first, last, comp)
- * Effect: std::make_pair( last_min_element(first, last, comp),
- *                         last_max_element(first, last, comp) );
- */
-
-namespace boost {
-
-  // Min_element and max_element variants
-
-  namespace detail {  // common base for the overloads
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  basic_first_min_element(ForwardIter first, ForwardIter last,
-                          BinaryPredicate comp)
-  {
-    if (first == last) return last;
-    ForwardIter min_result = first;
-    while (++first != last)
-      if (comp(first, min_result))
-        min_result = first;
-    return min_result;
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  basic_last_min_element(ForwardIter first, ForwardIter last,
-                         BinaryPredicate comp)
-  {
-    if (first == last) return last;
-    ForwardIter min_result = first;
-    while (++first != last)
-      if (!comp(min_result, first))
-        min_result = first;
-    return min_result;
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  basic_first_max_element(ForwardIter first, ForwardIter last,
-                          BinaryPredicate comp)
-  {
-    if (first == last) return last;
-    ForwardIter max_result = first;
-    while (++first != last)
-      if (comp(max_result, first))
-        max_result = first;
-    return max_result;
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  basic_last_max_element(ForwardIter first, ForwardIter last,
-                         BinaryPredicate comp)
-  {
-    if (first == last) return last;
-    ForwardIter max_result = first;
-    while (++first != last)
-      if (!comp(first, max_result))
-        max_result = first;
-    return max_result;
-  }
-
-  } // namespace detail
-
-  template <typename ForwardIter>
-  ForwardIter
-  first_min_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_first_min_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  first_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
-  {
-    return detail::basic_first_min_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-  template <typename ForwardIter>
-  ForwardIter
-  last_min_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_last_min_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  last_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
-  {
-    return detail::basic_last_min_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-  template <typename ForwardIter>
-  ForwardIter
-  first_max_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_first_max_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
-  {
-    return detail::basic_first_max_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-  template <typename ForwardIter>
-  ForwardIter
-  last_max_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_last_max_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  ForwardIter
-  last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
-  {
-    return detail::basic_last_max_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-
-  // Minmax_element variants -- comments removed
-
-  namespace detail {
-
-  template <typename ForwardIter, class BinaryPredicate>
-  std::pair<ForwardIter,ForwardIter>
-  basic_first_min_last_max_element(ForwardIter first, ForwardIter last,
-                                   BinaryPredicate comp)
-  {
-    if (first == last)
-      return std::make_pair(last,last);
-
-    ForwardIter min_result = first;
-    ForwardIter max_result = first;
-
-    ForwardIter second = ++first;
-    if (second == last)
-      return std::make_pair(min_result, max_result);
-
-    if (comp(second, min_result))
-      min_result = second;
-    else
-      max_result = second;
-
-    first = ++second; if (first != last) ++second;
-    while (second != last) {
-      if (!comp(second, first)) {
-        if (comp(first, min_result))
-                 min_result = first;
-        if (!comp(second, max_result))
-          max_result = second;
-      } else {
-        if (comp(second, min_result))
-          min_result = second;
-        if (!comp(first, max_result))
-              max_result = first;
-      }
-      first = ++second; if (first != last) ++second;
-    }
-
-    if (first != last) {
-      if (comp(first, min_result))
-         min_result = first;
-      else if (!comp(first, max_result))
-               max_result = first;
-    }
-
-    return std::make_pair(min_result, max_result);
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  std::pair<ForwardIter,ForwardIter>
-  basic_last_min_first_max_element(ForwardIter first, ForwardIter last,
-                                   BinaryPredicate comp)
-  {
-    if (first == last) return std::make_pair(last,last);
-
-    ForwardIter min_result = first;
-    ForwardIter max_result = first;
-
-    ForwardIter second = ++first;
-    if (second == last)
-      return std::make_pair(min_result, max_result);
-
-    if (comp(max_result, second))
-      max_result = second;
-    else
-      min_result = second;
-
-    first = ++second; if (first != last) ++second;
-    while (second != last)  {
-      if (comp(first, second)) {
-        if (!comp(min_result, first))
-          min_result = first;
-        if (comp(max_result, second))
-          max_result = second;
-      } else {
-        if (!comp(min_result, second))
-          min_result = second;
-        if (comp(max_result, first))
-          max_result = first;
-      }
-      first = ++second; if (first != last) ++second;
-    }
-
-    if (first != last) {
-      if (!comp(min_result, first))
-        min_result = first;
-      else if (comp(max_result, first))
-        max_result = first;
-    }
-
-    return std::make_pair(min_result, max_result);
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  std::pair<ForwardIter,ForwardIter>
-  basic_last_min_last_max_element(ForwardIter first, ForwardIter last,
-                                  BinaryPredicate comp)
-  {
-    if (first == last) return std::make_pair(last,last);
-
-    ForwardIter min_result = first;
-    ForwardIter max_result = first;
-
-    ForwardIter second = first; ++second;
-    if (second == last)
-      return std::make_pair(min_result,max_result);
-
-    ForwardIter potential_max_result = last;
-    if (comp(first, second))
-      max_result = second;
-    else {
-      min_result = second;
-      potential_max_result = second;
-    }
-
-    first = ++second; if (first != last) ++second;
-    while (second != last) {
-      if (comp(first, second)) {
-        if (!comp(min_result, first))
-          min_result = first;
-        if (!comp(second, max_result)) {
-          max_result = second;
-          potential_max_result = last;
-        }
-      } else {
-        if (!comp(min_result, second))
-          min_result = second;
-        if (!comp(first, max_result)) {
-          max_result = first;
-          potential_max_result = second;
-        }
-      }
-      first = ++second;
-      if (first != last) ++second;
-    }
-
-    if (first != last) {
-      if (!comp(min_result, first))
-        min_result = first;
-      if (!comp(first, max_result)) {
-        max_result = first;
-               potential_max_result = last;
-      }
-    }
-
-    if (potential_max_result != last
-        && !comp(potential_max_result, max_result))
-      max_result = potential_max_result;
-
-    return std::make_pair(min_result,max_result);
-  }
-
-  } // namespace detail
-
-  template <typename ForwardIter>
-  inline std::pair<ForwardIter,ForwardIter>
-  first_min_first_max_element(ForwardIter first, ForwardIter last)
-  {
-    return minmax_element(first, last);
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  inline std::pair<ForwardIter,ForwardIter>
-  first_min_first_max_element(ForwardIter first, ForwardIter last,
-                              BinaryPredicate comp)
-  {
-    return minmax_element(first, last, comp);
-  }
-
-  template <typename ForwardIter>
-  std::pair<ForwardIter,ForwardIter>
-  first_min_last_max_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_first_min_last_max_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  inline std::pair<ForwardIter,ForwardIter>
-  first_min_last_max_element(ForwardIter first, ForwardIter last,
-                              BinaryPredicate comp)
-  {
-    return detail::basic_first_min_last_max_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-  template <typename ForwardIter>
-  std::pair<ForwardIter,ForwardIter>
-  last_min_first_max_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_last_min_first_max_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  inline std::pair<ForwardIter,ForwardIter>
-  last_min_first_max_element(ForwardIter first, ForwardIter last,
-                              BinaryPredicate comp)
-  {
-    return detail::basic_last_min_first_max_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-  template <typename ForwardIter>
-  std::pair<ForwardIter,ForwardIter>
-  last_min_last_max_element(ForwardIter first, ForwardIter last)
-  {
-    return detail::basic_last_min_last_max_element(first, last,
-             detail::less_over_iter<ForwardIter>() );
-  }
-
-  template <typename ForwardIter, class BinaryPredicate>
-  inline std::pair<ForwardIter,ForwardIter>
-  last_min_last_max_element(ForwardIter first, ForwardIter last,
-                              BinaryPredicate comp)
-  {
-    return detail::basic_last_min_last_max_element(first, last,
-             detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
-  }
-
-} // namespace boost
-
-#endif // BOOST_ALGORITHM_MINMAX_ELEMENT_HPP

test/external/boost/algorithm/string.hpp

@@ -1,31 +0,0 @@
-//  Boost string_algo library string_algo.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2004.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_ALGO_HPP
-#define BOOST_STRING_ALGO_HPP
-
-/*! \file
-    Cumulative include for string_algo library
-*/
-
-#include <boost/algorithm/string/std_containers_traits.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/find.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/join.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/erase.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/find_iterator.hpp>
-
-
-#endif  // BOOST_STRING_ALGO_HPP

test/external/boost/algorithm/string/case_conv.hpp

@@ -1,176 +0,0 @@
-//  Boost string_algo library case_conv.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CASE_CONV_HPP
-#define BOOST_STRING_CASE_CONV_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <locale>
-#include <boost/iterator/transform_iterator.hpp>
-
-#include <boost/range/as_literal.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/value_type.hpp>
-
-#include <boost/algorithm/string/detail/case_conv.hpp>
-
-/*! \file
-    Defines sequence case-conversion algorithms.
-    Algorithms convert each element in the input sequence to the
-    desired case using provided locales.
-*/
-
-namespace boost {
-    namespace algorithm {
-
-//  to_lower  -----------------------------------------------//
-
-        //! Convert to lower case
-        /*!
-            Each element of the input sequence is converted to lower
-            case. The result is a copy of the input converted to lower case.
-            It is returned as a sequence or copied to the output iterator.
-
-            \param Output An output iterator to which the result will be copied
-            \param Input An input range
-            \param Loc A locale used for conversion
-            \return 
-                An output iterator pointing just after the last inserted character or
-                a copy of the input
-
-            \note The second variant of this function provides the strong exception-safety guarantee
-                
-        */
-        template<typename OutputIteratorT, typename RangeT>
-        inline OutputIteratorT 
-        to_lower_copy(
-            OutputIteratorT Output,
-            const RangeT& Input,
-            const std::locale& Loc=std::locale())
-        {
-            return ::boost::algorithm::detail::transform_range_copy( 
-               Output,
-               ::boost::as_literal(Input),
-               ::boost::algorithm::detail::to_lowerF<
-                    typename range_value<RangeT>::type >(Loc));
-        }
-
-        //! Convert to lower case
-        /*!
-            \overload
-        */
-        template<typename SequenceT>
-        inline SequenceT to_lower_copy( 
-            const SequenceT& Input, 
-            const std::locale& Loc=std::locale())
-        {
-            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
-                Input,
-                ::boost::algorithm::detail::to_lowerF<
-                    typename range_value<SequenceT>::type >(Loc));
-        }
-
-        //! Convert to lower case
-        /*!
-            Each element of the input sequence is converted to lower
-            case. The input sequence is modified in-place.
-
-            \param Input A range
-            \param Loc a locale used for conversion
-        */
-        template<typename WritableRangeT>
-        inline void to_lower( 
-            WritableRangeT& Input, 
-            const std::locale& Loc=std::locale())
-        {
-            ::boost::algorithm::detail::transform_range(
-                ::boost::as_literal(Input),
-                ::boost::algorithm::detail::to_lowerF<
-                    typename range_value<WritableRangeT>::type >(Loc));
-        }
-        
-//  to_upper  -----------------------------------------------//
-
-        //! Convert to upper case
-        /*!
-            Each element of the input sequence is converted to upper
-            case. The result is a copy of the input converted to upper case.
-            It is returned as a sequence or copied to the output iterator
-
-            \param Output An output iterator to which the result will be copied
-            \param Input An input range
-            \param Loc A locale used for conversion
-            \return 
-                An output iterator pointing just after the last inserted character or
-                a copy of the input
-
-            \note The second variant of this function provides the strong exception-safety guarantee
-        */
-        template<typename OutputIteratorT, typename RangeT>
-        inline OutputIteratorT 
-        to_upper_copy(
-            OutputIteratorT Output,
-            const RangeT& Input,
-            const std::locale& Loc=std::locale())
-        {
-            return ::boost::algorithm::detail::transform_range_copy( 
-               Output,
-               ::boost::as_literal(Input),
-               ::boost::algorithm::detail::to_upperF<
-                    typename range_value<RangeT>::type >(Loc));
-        }
-
-        //! Convert to upper case
-        /*!
-            \overload
-        */
-        template<typename SequenceT>
-        inline SequenceT to_upper_copy( 
-            const SequenceT& Input, 
-            const std::locale& Loc=std::locale())
-        {
-            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
-                Input,
-                ::boost::algorithm::detail::to_upperF<
-                    typename range_value<SequenceT>::type >(Loc));
-        }
-
-        //! Convert to upper case
-        /*!
-            Each element of the input sequence is converted to upper
-            case. The input sequence is modified in-place.
-
-            \param Input An input range
-            \param Loc a locale used for conversion
-        */
-        template<typename WritableRangeT>
-        inline void to_upper( 
-            WritableRangeT& Input, 
-            const std::locale& Loc=std::locale())
-        {
-            ::boost::algorithm::detail::transform_range(
-                ::boost::as_literal(Input),
-                ::boost::algorithm::detail::to_upperF<
-                    typename range_value<WritableRangeT>::type >(Loc));
-        }
-
-    } // namespace algorithm
-
-    // pull names to the boost namespace
-    using algorithm::to_lower;
-    using algorithm::to_lower_copy;
-    using algorithm::to_upper;
-    using algorithm::to_upper_copy;
-
-} // namespace boost
-
-#endif  // BOOST_STRING_CASE_CONV_HPP

test/external/boost/algorithm/string/classification.hpp

@@ -1,312 +0,0 @@
-//  Boost string_algo library classification.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CLASSIFICATION_HPP
-#define BOOST_STRING_CLASSIFICATION_HPP
-
-#include <algorithm>
-#include <locale>
-#include <boost/range/value_type.hpp>
-#include <boost/range/as_literal.hpp>
-#include <boost/algorithm/string/detail/classification.hpp>
-#include <boost/algorithm/string/predicate_facade.hpp>
-
-
-/*! \file
-    Classification predicates are included in the library to give 
-    some more convenience when using algorithms like \c trim() and \c all(). 
-    They wrap functionality of STL classification functions ( e.g. \c std::isspace() )
-    into generic functors. 
-*/
-
-namespace boost {
-    namespace algorithm {
-
-//  classification functor generator -------------------------------------//
-
-        //! is_classified predicate
-        /*!
-            Construct the \c is_classified predicate. This predicate holds if the input is
-            of specified \c std::ctype category.
-
-            \param Type A \c std::ctype category
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF
-        is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(Type, Loc);
-        }
-
-        //! is_space predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::space category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate
-        */
-        inline detail::is_classifiedF 
-        is_space(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::space, Loc);
-        }
-
-        //! is_alnum predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::alnum category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_alnum(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::alnum, Loc);
-        }
-
-        //! is_alpha predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::alpha category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_alpha(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::alpha, Loc);
-        }
-
-        //! is_cntrl predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::cntrl category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_cntrl(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
-        }
-
-        //! is_digit predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::digit category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_digit(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::digit, Loc);
-        }
-
-        //! is_graph predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::graph category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF
-        is_graph(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::graph, Loc);
-        }
-
-        //! is_lower predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::lower category.   
-
-            \param Loc A locale used for classification
-            \return An instance of \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_lower(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::lower, Loc);
-        }
-
-        //! is_print predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::print category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_print(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::print, Loc);
-        }
-
-        //! is_punct predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::punct category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_punct(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::punct, Loc);
-        }
-
-        //! is_upper predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::upper category.   
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_upper(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::upper, Loc);
-        }
-
-        //! is_xdigit predicate
-        /*!
-            Construct the \c is_classified predicate for the \c ctype_base::xdigit category.  
-
-            \param Loc A locale used for classification
-            \return An instance of the \c is_classified predicate 
-        */
-        inline detail::is_classifiedF 
-        is_xdigit(const std::locale& Loc=std::locale())
-        {
-            return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
-        }
-
-        //! is_any_of predicate
-        /*!
-            Construct the \c is_any_of predicate. The predicate holds if the input
-            is included in the specified set of characters.
-
-            \param Set A set of characters to be recognized
-            \return An instance of the \c is_any_of predicate 
-        */
-        template<typename RangeT>
-        inline detail::is_any_ofF<
-            BOOST_STRING_TYPENAME range_value<RangeT>::type> 
-        is_any_of( const RangeT& Set )
-        {
-            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
-            return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); 
-        }
-
-        //! is_from_range predicate
-        /*!
-            Construct the \c is_from_range predicate. The predicate holds if the input
-            is included in the specified range. (i.e. From <= Ch <= To )
-
-            \param From The start of the range
-            \param To The end of the range
-            \return An instance of the \c is_from_range predicate 
-        */
-        template<typename CharT>
-        inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
-        {
-            return detail::is_from_rangeF<CharT>(From,To); 
-        }
-        
-        // predicate combinators ---------------------------------------------------//
-
-        //! predicate 'and' composition predicate
-        /*!
-            Construct the \c class_and predicate. This predicate can be used
-            to logically combine two classification predicates. \c class_and holds,
-            if both predicates return true.
-
-            \param Pred1 The first predicate
-            \param Pred2 The second predicate
-            \return An instance of the \c class_and predicate     
-        */
-        template<typename Pred1T, typename Pred2T>
-        inline detail::pred_andF<Pred1T, Pred2T>
-        operator&&( 
-            const predicate_facade<Pred1T>& Pred1, 
-            const predicate_facade<Pred2T>& Pred2 )
-        {    
-            // Doing the static_cast with the pointer instead of the reference
-            // is a workaround for some compilers which have problems with
-            // static_cast's of template references, i.e. CW8. /grafik/
-            return detail::pred_andF<Pred1T,Pred2T>(
-                *static_cast<const Pred1T*>(&Pred1), 
-                *static_cast<const Pred2T*>(&Pred2) );
-        }
-
-        //! predicate 'or' composition predicate
-        /*!
-            Construct the \c class_or predicate. This predicate can be used
-            to logically combine two classification predicates. \c class_or holds,
-            if one of the predicates return true.
-
-            \param Pred1 The first predicate
-            \param Pred2 The second predicate
-            \return An instance of the \c class_or predicate     
-        */
-        template<typename Pred1T, typename Pred2T>
-        inline detail::pred_orF<Pred1T, Pred2T>
-        operator||( 
-            const predicate_facade<Pred1T>& Pred1, 
-            const predicate_facade<Pred2T>& Pred2 )
-        {    
-            // Doing the static_cast with the pointer instead of the reference
-            // is a workaround for some compilers which have problems with
-            // static_cast's of template references, i.e. CW8. /grafik/
-            return detail::pred_orF<Pred1T,Pred2T>(
-                *static_cast<const Pred1T*>(&Pred1), 
-                *static_cast<const Pred2T*>(&Pred2));
-        }
-
-        //! predicate negation operator
-        /*!
-            Construct the \c class_not predicate. This predicate represents a negation. 
-            \c class_or holds if of the predicates return false.
-
-            \param Pred The predicate to be negated
-            \return An instance of the \c class_not predicate     
-        */
-        template<typename PredT>
-        inline detail::pred_notF<PredT>
-        operator!( const predicate_facade<PredT>& Pred )
-        {
-            // Doing the static_cast with the pointer instead of the reference
-            // is a workaround for some compilers which have problems with
-            // static_cast's of template references, i.e. CW8. /grafik/
-            return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred)); 
-        }
-
-    } // namespace algorithm
-
-    // pull names to the boost namespace
-    using algorithm::is_classified;
-    using algorithm::is_space;
-    using algorithm::is_alnum;
-    using algorithm::is_alpha;
-    using algorithm::is_cntrl;
-    using algorithm::is_digit;
-    using algorithm::is_graph;
-    using algorithm::is_lower;
-    using algorithm::is_upper;
-    using algorithm::is_print;
-    using algorithm::is_punct;
-    using algorithm::is_xdigit;
-    using algorithm::is_any_of;
-    using algorithm::is_from_range;
-
-} // namespace boost
-
-#endif  // BOOST_STRING_PREDICATE_HPP

test/external/boost/algorithm/string/compare.hpp

@@ -1,199 +0,0 @@
-//  Boost string_algo library compare.hpp header file  -------------------------//
-
-//  Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_COMPARE_HPP
-#define BOOST_STRING_COMPARE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <locale>
-
-/*! \file
-    Defines element comparison predicates. Many algorithms in this library can
-    take an additional argument with a predicate used to compare elements.
-    This makes it possible, for instance, to have case insensitive versions
-    of the algorithms.
-*/
-
-namespace boost {
-    namespace algorithm {
-
-        //  is_equal functor  -----------------------------------------------//
-
-        //! is_equal functor
-        /*!
-            Standard STL equal_to only handle comparison between arguments
-            of the same type. This is a less restrictive version which wraps operator ==.
-        */
-        struct is_equal
-        {
-            //! Function operator
-            /*!
-                Compare two operands for equality
-            */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                return Arg1==Arg2;
-            }
-        };
-
-        //! case insensitive version of is_equal
-        /*!
-            Case insensitive comparison predicate. Comparison is done using
-            specified locales.
-        */
-        struct is_iequal
-        {
-            //! Constructor
-            /*!
-                \param Loc locales used for comparison
-            */
-            is_iequal( const std::locale& Loc=std::locale() ) :
-                m_Loc( Loc ) {}
-
-            //! Function operator
-            /*!
-                Compare two operands. Case is ignored.
-            */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                    return std::toupper(Arg1)==std::toupper(Arg2);
-                #else
-                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
-                #endif
-            }
-
-        private:
-            std::locale m_Loc;
-        };
-
-        //  is_less functor  -----------------------------------------------//
-
-        //! is_less functor
-        /*!
-            Convenient version of standard std::less. Operation is templated, therefore it is 
-            not required to specify the exact types upon the construction
-         */
-        struct is_less
-        {
-            //! Functor operation
-            /*!
-                Compare two operands using > operator
-             */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                return Arg1<Arg2;
-            }
-        };
-
-
-        //! case insensitive version of is_less
-        /*!
-            Case insensitive comparison predicate. Comparison is done using
-            specified locales.
-        */
-        struct is_iless
-        {
-            //! Constructor
-            /*!
-                \param Loc locales used for comparison
-            */
-            is_iless( const std::locale& Loc=std::locale() ) :
-                m_Loc( Loc ) {}
-
-            //! Function operator
-            /*!
-                Compare two operands. Case is ignored.
-            */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                    return std::toupper(Arg1)<std::toupper(Arg2);
-                #else
-                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
-                #endif
-            }
-
-        private:
-            std::locale m_Loc;
-        };
-
-        //  is_not_greater functor  -----------------------------------------------//
-
-        //! is_not_greater functor
-        /*!
-            Convenient version of standard std::not_greater_to. Operation is templated, therefore it is 
-            not required to specify the exact types upon the construction
-         */
-        struct is_not_greater
-        {
-            //! Functor operation
-            /*!
-                Compare two operands using > operator
-             */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                return Arg1<=Arg2;
-            }
-        };
-
-
-        //! case insensitive version of is_not_greater
-        /*!
-            Case insensitive comparison predicate. Comparison is done using
-            specified locales.
-        */
-        struct is_not_igreater
-        {
-            //! Constructor
-            /*!
-                \param Loc locales used for comparison
-            */
-            is_not_igreater( const std::locale& Loc=std::locale() ) :
-                m_Loc( Loc ) {}
-
-            //! Function operator
-            /*!
-                Compare two operands. Case is ignored.
-            */
-            template< typename T1, typename T2 >
-                bool operator()( const T1& Arg1, const T2& Arg2 ) const
-            {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                    return std::toupper(Arg1)<=std::toupper(Arg2);
-                #else
-                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
-                #endif
-            }
-
-        private:
-            std::locale m_Loc;
-        };
-
-
-    } // namespace algorithm
-
-    // pull names to the boost namespace
-    using algorithm::is_equal;
-    using algorithm::is_iequal;
-    using algorithm::is_less;
-    using algorithm::is_iless;
-    using algorithm::is_not_greater;
-    using algorithm::is_not_igreater;
-
-} // namespace boost
-
-
-#endif  // BOOST_STRING_COMPARE_HPP

test/external/boost/algorithm/string/concept.hpp

@@ -1,83 +0,0 @@
-//  Boost string_algo library concept.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CONCEPT_HPP
-#define BOOST_STRING_CONCEPT_HPP
-
-#include <boost/concept_check.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-/*! \file 
-    Defines concepts used in string_algo library
-*/
-
-namespace boost {
-    namespace algorithm {
-
-        //! Finder concept
-        /*!
-            Defines the Finder concept. Finder is a functor which selects
-            an arbitrary part of a string. Search is performed on
-            the range specified by starting and ending iterators.
-
-            Result of the find operation must be convertible to iterator_range.
-        */
-        template<typename FinderT, typename IteratorT>
-        struct FinderConcept
-        {
-        private:
-            typedef iterator_range<IteratorT> range;
-        public:
-            void constraints()
-            {
-                // Operation
-                r=(*pF)(i,i);
-            }
-        private:
-            range r;
-            IteratorT i;
-            FinderT* pF;    
-        }; // Finder_concept
-
-        
-        //! Formatter concept
-        /*!
-            Defines the Formatter concept. Formatter is a functor, which
-            takes a result from a finder operation and transforms it
-            in a specific way.
-
-            Result must be a container supported by container_traits, 
-            or a reference to it.
-        */
-        template<typename FormatterT, typename FinderT, typename IteratorT>
-        struct FormatterConcept
-        {
-        public:
-            void constraints()
-            {
-                // Operation
-                ::boost::begin((*pFo)( (*pF)(i,i) ));
-                ::boost::end((*pFo)( (*pF)(i,i) ));
-            }
-        private:
-            IteratorT i;
-            FinderT* pF;
-            FormatterT *pFo;
-        }; // FormatterConcept;
-
-    } // namespace algorithm
-} // namespace boost
-
-
-
-
-#endif  // BOOST_STRING_CONCEPT_HPP

test/external/boost/algorithm/string/config.hpp

@@ -1,28 +0,0 @@
-//  Boost string_algo library config.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CONFIG_HPP
-#define BOOST_STRING_CONFIG_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#ifdef BOOST_STRING_DEDUCED_TYPENAME
-#   error "macro already defined!"
-#endif
-
-#define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME
-
-// Metrowerks workaround
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
-#pragma parse_func_templ off
-#endif
-
-#endif  // BOOST_STRING_CONFIG_HPP

test/external/boost/algorithm/string/constants.hpp

@@ -1,36 +0,0 @@
-//  Boost string_algo library constants.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CONSTANTS_HPP
-#define BOOST_STRING_CONSTANTS_HPP
-
-namespace boost {
-    namespace algorithm {
-
-    //! Token compression mode 
-    /*!
-        Specifies token compression mode for the token_finder.
-    */
-    enum token_compress_mode_type
-    {
-        token_compress_on,    //!< Compress adjacent tokens
-        token_compress_off  //!< Do not compress adjacent tokens
-    };
-    
-    } // namespace algorithm
-
-    // pull the names to the boost namespace
-    using algorithm::token_compress_on;
-    using algorithm::token_compress_off;
-
-} // namespace boost
-
-#endif  // BOOST_STRING_CONSTANTS_HPP
-

test/external/boost/algorithm/string/detail/case_conv.hpp

@@ -1,121 +0,0 @@
-//  Boost string_algo library string_funct.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CASE_CONV_DETAIL_HPP
-#define BOOST_STRING_CASE_CONV_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <locale>
-#include <functional>
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-//  case conversion functors -----------------------------------------------//
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-            // a tolower functor
-            template<typename CharT>
-            struct to_lowerF : public std::unary_function<CharT, CharT>
-            {
-                // Constructor
-                to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
-
-                // Operation
-                CharT operator ()( CharT Ch ) const
-                {
-                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                        return std::tolower( Ch);
-                    #else
-                        return std::tolower<CharT>( Ch, *m_Loc );
-                    #endif
-                }
-            private:
-                const std::locale* m_Loc;
-            };
-
-            // a toupper functor
-            template<typename CharT>
-            struct to_upperF : public std::unary_function<CharT, CharT>
-            {
-                // Constructor
-                to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
-
-                // Operation
-                CharT operator ()( CharT Ch ) const
-                {
-                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                        return std::toupper( Ch);
-                    #else
-                        return std::toupper<CharT>( Ch, *m_Loc );
-                    #endif
-                }
-            private:
-                const std::locale* m_Loc;
-            };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-// algorithm implementation -------------------------------------------------------------------------
-
-            // Transform a range
-            template<typename OutputIteratorT, typename RangeT, typename FunctorT>
-            OutputIteratorT transform_range_copy(
-                OutputIteratorT Output,
-                const RangeT& Input,
-                FunctorT Functor)
-            {
-                return std::transform( 
-                    ::boost::begin(Input), 
-                    ::boost::end(Input), 
-                    Output,
-                    Functor);
-            }
-
-            // Transform a range (in-place)
-            template<typename RangeT, typename FunctorT>
-            void transform_range(
-                const RangeT& Input,
-                FunctorT Functor)
-            {
-                std::transform( 
-                    ::boost::begin(Input), 
-                    ::boost::end(Input), 
-                    ::boost::begin(Input),
-                    Functor);
-            }
-
-            template<typename SequenceT, typename RangeT, typename FunctorT>
-            inline SequenceT transform_range_copy( 
-                const RangeT& Input, 
-                FunctorT Functor)
-            {
-                return SequenceT(
-                    ::boost::make_transform_iterator(
-                        ::boost::begin(Input),
-                        Functor),
-                    ::boost::make_transform_iterator(
-                        ::boost::end(Input), 
-                        Functor));
-            }
-
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-
-#endif  // BOOST_STRING_CASE_CONV_DETAIL_HPP

test/external/boost/algorithm/string/detail/classification.hpp

@@ -1,353 +0,0 @@
-//  Boost string_algo library classification.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-// 
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP
-#define BOOST_STRING_CLASSIFICATION_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <functional>
-#include <locale>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/algorithm/string/predicate_facade.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-//  classification functors -----------------------------------------------//
-
-   // is_classified functor
-            struct is_classifiedF :
-                public predicate_facade<is_classifiedF>
-            {
-                // Boost.ResultOf support
-                typedef bool result_type;
-
-                // Constructor from a locale
-                is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
-                    m_Type(Type), m_Locale(Loc) {}
-                // Operation
-                template<typename CharT>
-                bool operator()( CharT Ch ) const
-                {
-                    return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
-                }
-
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
-                    template<>
-                    bool operator()( char const Ch ) const
-                    {
-                        return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch );
-                    }
-                #endif
-
-            private:
-                std::ctype_base::mask m_Type;
-                std::locale m_Locale;
-            };
-
-
-            // is_any_of functor
-            /*
-                returns true if the value is from the specified set
-            */
-            template<typename CharT>
-            struct is_any_ofF :
-                public predicate_facade<is_any_ofF<CharT> >
-            {
-            private:
-                // set cannot operate on const value-type
-                typedef typename ::boost::remove_const<CharT>::type set_value_type;
-
-            public:     
-                // Boost.ResultOf support
-                typedef bool result_type;
-
-                // Constructor
-                template<typename RangeT>
-                is_any_ofF( const RangeT& Range ) : m_Size(0)
-                {
-                    // Prepare storage
-                    m_Storage.m_dynSet=0;
-
-                    std::size_t Size=::boost::distance(Range);
-                    m_Size=Size;
-                    set_value_type* Storage=0;
-
-                    if(use_fixed_storage(m_Size))
-                    {
-                        // Use fixed storage
-                        Storage=&m_Storage.m_fixSet[0];
-                    }
-                    else
-                    {
-                        // Use dynamic storage
-                        m_Storage.m_dynSet=new set_value_type[m_Size];
-                        Storage=m_Storage.m_dynSet;
-                    }
-
-                    // Use fixed storage
-                    ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
-                    ::std::sort(Storage, Storage+m_Size);
-                }
-
-                // Copy constructor
-                is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
-                {
-                    // Prepare storage
-                    m_Storage.m_dynSet=0;               
-                    const set_value_type* SrcStorage=0;
-                    set_value_type* DestStorage=0;
-
-                    if(use_fixed_storage(m_Size))
-                    {
-                        // Use fixed storage
-                        DestStorage=&m_Storage.m_fixSet[0];
-                        SrcStorage=&Other.m_Storage.m_fixSet[0];
-                    }
-                    else
-                    {
-                        // Use dynamic storage
-                        m_Storage.m_dynSet=new set_value_type[m_Size];
-                        DestStorage=m_Storage.m_dynSet;
-                        SrcStorage=Other.m_Storage.m_dynSet;
-                    }
-
-                    // Use fixed storage
-                    ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
-                }
-
-                // Destructor
-                ~is_any_ofF()
-                {
-                    if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
-                    {
-                        delete [] m_Storage.m_dynSet;
-                    }
-                }
-
-                // Assignment
-                is_any_ofF& operator=(const is_any_ofF& Other)
-                {
-                    // Handle self assignment
-                    if(this==&Other) return *this;
-
-                    // Prepare storage             
-                    const set_value_type* SrcStorage;
-                    set_value_type* DestStorage;
-
-                    if(use_fixed_storage(Other.m_Size))
-                    {
-                        // Use fixed storage
-                        DestStorage=&m_Storage.m_fixSet[0];
-                        SrcStorage=&Other.m_Storage.m_fixSet[0];
-
-                        // Delete old storage if was present
-                        if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
-                        {
-                            delete [] m_Storage.m_dynSet;
-                        }
-
-                        // Set new size
-                        m_Size=Other.m_Size;
-                    }
-                    else
-                    {
-                        // Other uses dynamic storage
-                        SrcStorage=Other.m_Storage.m_dynSet;
-
-                        // Check what kind of storage are we using right now
-                        if(use_fixed_storage(m_Size))
-                        {
-                            // Using fixed storage, allocate new
-                            set_value_type* pTemp=new set_value_type[Other.m_Size];
-                            DestStorage=pTemp;
-                            m_Storage.m_dynSet=pTemp;
-                            m_Size=Other.m_Size;
-                        }
-                        else
-                        {
-                            // Using dynamic storage, check if can reuse
-                            if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
-                            {
-                                // Reuse the current storage
-                                DestStorage=m_Storage.m_dynSet;
-                                m_Size=Other.m_Size;
-                            }
-                            else
-                            {
-                                // Allocate the new one
-                                set_value_type* pTemp=new set_value_type[Other.m_Size];
-                                DestStorage=pTemp;
-                        
-                                // Delete old storage if necessary
-                                if(m_Storage.m_dynSet!=0)
-                                {
-                                    delete [] m_Storage.m_dynSet;
-                                }
-                                // Store the new storage
-                                m_Storage.m_dynSet=pTemp;
-                                // Set new size
-                                m_Size=Other.m_Size;
-                            }
-                        }
-                    }
-
-                    // Copy the data
-                    ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
-
-                    return *this;
-                }
-
-                // Operation
-                template<typename Char2T>
-                bool operator()( Char2T Ch ) const
-                {
-                    const set_value_type* Storage=
-                        (use_fixed_storage(m_Size))
-                        ? &m_Storage.m_fixSet[0]
-                        : m_Storage.m_dynSet;
-
-                    return ::std::binary_search(Storage, Storage+m_Size, Ch);
-                }
-            private:
-                // check if the size is eligible for fixed storage
-                static bool use_fixed_storage(std::size_t size)
-                {
-                    return size<=sizeof(set_value_type*)*2;
-                }
-
-
-            private:
-                // storage
-                // The actual used storage is selected on the type
-                union
-                {
-                    set_value_type* m_dynSet;
-                    set_value_type m_fixSet[sizeof(set_value_type*)*2];
-                } 
-                m_Storage;
-        
-                // storage size
-                ::std::size_t m_Size;
-            };
-
-            // is_from_range functor
-            /*
-                returns true if the value is from the specified range.
-                (i.e. x>=From && x>=To)
-            */
-            template<typename CharT>
-            struct is_from_rangeF :
-                public predicate_facade< is_from_rangeF<CharT> >
-            {
-                // Boost.ResultOf support
-                typedef bool result_type;
-
-                // Constructor
-                is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
-
-                // Operation
-                template<typename Char2T>
-                bool operator()( Char2T Ch ) const
-                {
-                    return ( m_From <= Ch ) && ( Ch <= m_To );
-                }
-
-            private:
-                CharT m_From;
-                CharT m_To;
-            };
-
-            // class_and composition predicate
-            template<typename Pred1T, typename Pred2T>
-            struct pred_andF :
-                public predicate_facade< pred_andF<Pred1T,Pred2T> >
-            {
-            public:
-
-                // Boost.ResultOf support
-                typedef bool result_type;
-
-                // Constructor
-                pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
-                    m_Pred1(Pred1), m_Pred2(Pred2) {}
-
-                // Operation
-                template<typename CharT>
-                bool operator()( CharT Ch ) const
-                {
-                    return m_Pred1(Ch) && m_Pred2(Ch);
-                }
-
-            private:
-                Pred1T m_Pred1;
-                Pred2T m_Pred2;
-            };
-
-            // class_or composition predicate
-            template<typename Pred1T, typename Pred2T>
-            struct pred_orF :
-                public predicate_facade< pred_orF<Pred1T,Pred2T> >
-            {
-            public:
-                // Boost.ResultOf support
-                typedef bool result_type;
-
-                // Constructor
-                pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
-                    m_Pred1(Pred1), m_Pred2(Pred2) {}
-
-                // Operation
-                template<typename CharT>
-                bool operator()( CharT Ch ) const
-                {
-                    return m_Pred1(Ch) || m_Pred2(Ch);
-                }
-
-            private:
-                Pred1T m_Pred1;
-                Pred2T m_Pred2;
-            };
-
-            // class_not composition predicate
-            template< typename PredT >
-            struct pred_notF :
-                public predicate_facade< pred_notF<PredT> >
-            {
-            public:
-                // Boost.ResultOf support
-                typedef bool result_type;
-
-                // Constructor
-                pred_notF( PredT Pred ) : m_Pred(Pred) {}
-
-                // Operation
-                template<typename CharT>
-                bool operator()( CharT Ch ) const
-                {
-                    return !m_Pred(Ch);
-                }
-
-            private:
-                PredT m_Pred;
-            };
-
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-
-#endif  // BOOST_STRING_CLASSIFICATION_DETAIL_HPP

test/external/boost/algorithm/string/detail/find_format.hpp

@@ -1,204 +0,0 @@
-//  Boost string_algo library find_format.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-// 
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_FORMAT_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/algorithm/string/detail/find_format_store.hpp>
-#include <boost/algorithm/string/detail/replace_storage.hpp>
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-// find_format_copy (iterator variant) implementation -------------------------------//
-
-           template< 
-                typename OutputIteratorT,
-                typename InputT,
-                typename FormatterT,
-                typename FindResultT,
-                typename FormatResultT >
-            inline OutputIteratorT find_format_copy_impl2(
-                OutputIteratorT Output,
-                const InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult,
-                const FormatResultT& FormatResult )
-            {       
-                typedef find_format_store<
-                    BOOST_STRING_TYPENAME 
-                        range_const_iterator<InputT>::type, 
-                        FormatterT,
-                        FormatResultT > store_type;
-
-                // Create store for the find result
-                store_type M( FindResult, FormatResult, Formatter );
-
-                if ( !M )
-                {
-                    // Match not found - return original sequence
-                    Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-                    return Output;
-                }
-
-                // Copy the beginning of the sequence
-                Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
-                // Format find result
-                // Copy formated result
-                Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
-                // Copy the rest of the sequence
-                Output = std::copy( M.end(), ::boost::end(Input), Output );
-
-                return Output;
-            }
-
-            template< 
-                typename OutputIteratorT,
-                typename InputT,
-                typename FormatterT,
-                typename FindResultT >
-            inline OutputIteratorT find_format_copy_impl(
-                OutputIteratorT Output,
-                const InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult )
-            {   
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    return ::boost::algorithm::detail::find_format_copy_impl2( 
-                        Output,
-                        Input,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                } else {
-                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-                }
-            }
-
- 
-// find_format_copy implementation --------------------------------------------------//
-
-           template< 
-                typename InputT, 
-                typename FormatterT,
-                typename FindResultT,
-                typename FormatResultT >
-            inline InputT find_format_copy_impl2(
-                const InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult,
-                const FormatResultT& FormatResult)
-            {
-                typedef find_format_store<
-                    BOOST_STRING_TYPENAME 
-                        range_const_iterator<InputT>::type, 
-                        FormatterT,
-                        FormatResultT > store_type;
-
-                // Create store for the find result
-                store_type M( FindResult, FormatResult, Formatter );
-
-                if ( !M )
-                {
-                    // Match not found - return original sequence
-                    return InputT( Input );
-                }
-
-                InputT Output;
-                // Copy the beginning of the sequence
-                insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
-                // Copy formated result
-                insert( Output, ::boost::end(Output), M.format_result() );
-                // Copy the rest of the sequence
-                insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
-
-                return Output;
-            }
-
-            template< 
-                typename InputT, 
-                typename FormatterT,
-                typename FindResultT >
-            inline InputT find_format_copy_impl(
-                const InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult)
-            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    return ::boost::algorithm::detail::find_format_copy_impl2(
-                        Input,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                } else {
-                    return Input;
-                }
-            }
-
- // replace implementation ----------------------------------------------------//
-        
-            template<
-                typename InputT,
-                typename FormatterT,
-                typename FindResultT,
-                typename FormatResultT >
-            inline void find_format_impl2( 
-                InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult,
-                const FormatResultT& FormatResult)
-            {
-                typedef find_format_store<
-                    BOOST_STRING_TYPENAME 
-                        range_iterator<InputT>::type, 
-                        FormatterT,
-                        FormatResultT > store_type;
-
-                // Create store for the find result
-                store_type M( FindResult, FormatResult, Formatter );
-
-                if ( !M )
-                {
-                    // Search not found - return original sequence
-                    return;
-                }
-
-                // Replace match
-                ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
-            }
-
-            template<
-                typename InputT,
-                typename FormatterT,
-                typename FindResultT >
-            inline void find_format_impl( 
-                InputT& Input,
-                FormatterT Formatter,
-                const FindResultT& FindResult)
-            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    ::boost::algorithm::detail::find_format_impl2(
-                        Input,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                }
-            }
-
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-#endif  // BOOST_STRING_FIND_FORMAT_DETAIL_HPP

test/external/boost/algorithm/string/detail/find_format_all.hpp

@@ -1,273 +0,0 @@
-//  Boost string_algo library find_format_all.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/algorithm/string/detail/find_format_store.hpp>
-#include <boost/algorithm/string/detail/replace_storage.hpp>
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-// find_format_all_copy (iterator variant) implementation ---------------------------//
-
-           template< 
-                typename OutputIteratorT,
-                typename InputT,
-                typename FinderT,
-                typename FormatterT,
-                typename FindResultT,
-                typename FormatResultT >
-            inline OutputIteratorT find_format_all_copy_impl2(
-                OutputIteratorT Output,
-                const InputT& Input,
-                FinderT Finder,
-                FormatterT Formatter,
-                const FindResultT& FindResult,
-                const FormatResultT& FormatResult )
-            {       
-                typedef BOOST_STRING_TYPENAME 
-                    range_const_iterator<InputT>::type input_iterator_type; 
-
-                typedef find_format_store<
-                        input_iterator_type, 
-                        FormatterT,
-                        FormatResultT > store_type;
-
-                // Create store for the find result
-                store_type M( FindResult, FormatResult, Formatter );
-
-                // Initialize last match
-                input_iterator_type LastMatch=::boost::begin(Input);
-
-                // Iterate through all matches
-                while( M )
-                {
-                    // Copy the beginning of the sequence
-                    Output = std::copy( LastMatch, M.begin(), Output );
-                    // Copy formated result
-                    Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
-
-                    // Proceed to the next match
-                    LastMatch=M.end();
-                    M=Finder( LastMatch, ::boost::end(Input) );
-                }
-
-                // Copy the rest of the sequence
-                Output = std::copy( LastMatch, ::boost::end(Input), Output );
-
-                return Output;
-            }
-
-            template< 
-                typename OutputIteratorT,
-                typename InputT,
-                typename FinderT,
-                typename FormatterT,
-                typename FindResultT >
-            inline OutputIteratorT find_format_all_copy_impl(
-                OutputIteratorT Output,
-                const InputT& Input,
-                FinderT Finder,
-                FormatterT Formatter,
-                const FindResultT& FindResult )
-            {   
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    return ::boost::algorithm::detail::find_format_all_copy_impl2( 
-                        Output,
-                        Input,
-                        Finder,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                } else {
-                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-                }
-            }
-
- // find_format_all_copy implementation ----------------------------------------------//
-
-           template< 
-                typename InputT, 
-                typename FinderT,
-                typename FormatterT,
-                typename FindResultT,
-                typename FormatResultT >
-            inline InputT find_format_all_copy_impl2(
-                const InputT& Input,
-                FinderT Finder,
-                FormatterT Formatter,
-                const FindResultT& FindResult,
-                const FormatResultT& FormatResult)
-            {
-                typedef BOOST_STRING_TYPENAME 
-                    range_const_iterator<InputT>::type input_iterator_type; 
-
-                typedef find_format_store<
-                        input_iterator_type, 
-                        FormatterT,
-                        FormatResultT > store_type;
-
-                // Create store for the find result
-                store_type M( FindResult, FormatResult, Formatter );
-
-                // Initialize last match
-                input_iterator_type LastMatch=::boost::begin(Input);
-
-                // Output temporary
-                InputT Output;
-
-                // Iterate through all matches
-                while( M )
-                {
-                    // Copy the beginning of the sequence
-                    insert( Output, ::boost::end(Output), LastMatch, M.begin() );
-                    // Copy formated result
-                    insert( Output, ::boost::end(Output), M.format_result() );
-
-                    // Proceed to the next match
-                    LastMatch=M.end();
-                    M=Finder( LastMatch, ::boost::end(Input) );
-                }
-
-                // Copy the rest of the sequence
-                ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
-
-                return Output;
-            }
-
-            template< 
-                typename InputT, 
-                typename FinderT,
-                typename FormatterT,
-                typename FindResultT >
-            inline InputT find_format_all_copy_impl(
-                const InputT& Input,
-                FinderT Finder,
-                FormatterT Formatter,
-                const FindResultT& FindResult)
-            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
-                        Input,
-                        Finder,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                } else {
-                    return Input;
-                }
-            }
-
- // find_format_all implementation ------------------------------------------------//
-        
-            template<
-                typename InputT,
-                typename FinderT,
-                typename FormatterT,
-                typename FindResultT,
-                typename FormatResultT >
-            inline void find_format_all_impl2( 
-                InputT& Input,
-                FinderT Finder,
-                FormatterT Formatter,
-                FindResultT FindResult,
-                FormatResultT FormatResult)
-            {
-                typedef BOOST_STRING_TYPENAME 
-                    range_iterator<InputT>::type input_iterator_type; 
-                typedef find_format_store<
-                        input_iterator_type, 
-                        FormatterT,
-                        FormatResultT > store_type;
-
-                // Create store for the find result
-                store_type M( FindResult, FormatResult, Formatter );
-          
-                // Instantiate replacement storage
-                std::deque<
-                    BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
-
-                // Initialize replacement iterators
-                input_iterator_type InsertIt=::boost::begin(Input);
-                input_iterator_type SearchIt=::boost::begin(Input);
-                
-                while( M )
-                {
-                    // process the segment
-                    InsertIt=process_segment( 
-                        Storage,
-                        Input,
-                        InsertIt,
-                        SearchIt,
-                        M.begin() );
-                    
-                    // Adjust search iterator
-                    SearchIt=M.end();
-
-                    // Copy formated replace to the storage
-                    ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
-
-                    // Find range for a next match
-                    M=Finder( SearchIt, ::boost::end(Input) );
-                }
-
-                // process the last segment
-                InsertIt=::boost::algorithm::detail::process_segment( 
-                    Storage,
-                    Input,
-                    InsertIt,
-                    SearchIt,
-                    ::boost::end(Input) );
-                
-                if ( Storage.empty() )
-                {
-                    // Truncate input
-                    ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
-                }
-                else
-                {
-                    // Copy remaining data to the end of input
-                    ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
-                }
-            }
-
-            template<
-                typename InputT,
-                typename FinderT,
-                typename FormatterT,
-                typename FindResultT >
-            inline void find_format_all_impl( 
-                InputT& Input,
-                FinderT Finder,
-                FormatterT Formatter,
-                FindResultT FindResult)
-            {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                    ::boost::algorithm::detail::find_format_all_impl2(
-                        Input,
-                        Finder,
-                        Formatter,
-                        FindResult,
-                        Formatter(FindResult) );
-                }
-            }
-
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-#endif  // BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP

test/external/boost/algorithm/string/detail/find_format_store.hpp

@@ -1,89 +0,0 @@
-//  Boost string_algo library find_format_store.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range.hpp>
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-//  temporary format and find result storage --------------------------------//
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-            template< 
-                typename ForwardIteratorT,
-                typename FormatterT,
-                typename FormatResultT >
-            class find_format_store : 
-                public iterator_range<ForwardIteratorT>
-            {
-            public:
-                // typedefs
-                typedef iterator_range<ForwardIteratorT> base_type;
-                typedef FormatterT  formatter_type;
-                typedef FormatResultT format_result_type;
-                
-            public:
-                // Construction
-                find_format_store( 
-                        const base_type& FindResult,
-                        const format_result_type& FormatResult,
-                        const formatter_type& Formatter ) :
-                    base_type(FindResult),
-                    m_FormatResult(FormatResult),
-                    m_Formatter(Formatter) {}
-
-                // Assignment
-                template< typename FindResultT >
-                find_format_store& operator=( FindResultT FindResult )
-                {
-                    iterator_range<ForwardIteratorT>::operator=(FindResult);
-                    if( !this->empty() ) {
-                        m_FormatResult=m_Formatter(FindResult);
-                    }
-                    
-                    return *this;
-                }
-
-                // Retrieve format result
-                const format_result_type& format_result()
-                {   
-                    return m_FormatResult;
-                }
-
-            private:
-                format_result_type m_FormatResult;
-                const formatter_type& m_Formatter;
-            };
-
-            template<typename InputT, typename FindResultT>
-            bool check_find_result(InputT&, FindResultT& FindResult)
-            {
-                typedef BOOST_STRING_TYPENAME 
-                    range_const_iterator<InputT>::type input_iterator_type; 
-                iterator_range<input_iterator_type> ResultRange(FindResult);
-                return !ResultRange.empty();
-            }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-#endif  // BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP

test/external/boost/algorithm/string/detail/find_iterator.hpp

@@ -1,87 +0,0 @@
-//  Boost string_algo library find_iterator.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
-#define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/function.hpp>
-
-namespace boost {
-    namespace algorithm { 
-        namespace detail {
-
-//  find_iterator base -----------------------------------------------//
-
-            // Find iterator base
-            template<typename IteratorT>
-            class find_iterator_base
-            {
-            protected:
-                // typedefs
-                typedef IteratorT input_iterator_type;
-                typedef iterator_range<IteratorT> match_type;
-                typedef function2<
-                    match_type, 
-                    input_iterator_type, 
-                    input_iterator_type> finder_type;
-                
-            protected:
-            // Protected construction/destruction
-
-                // Default constructor
-                find_iterator_base() {};
-                // Copy construction
-                find_iterator_base( const find_iterator_base& Other ) :
-                    m_Finder(Other.m_Finder) {}
-                
-                // Constructor
-                template<typename FinderT>
-                find_iterator_base( FinderT Finder, int ) :
-                    m_Finder(Finder) {}
-
-                // Destructor
-                ~find_iterator_base() {}
-
-                // Find operation
-                match_type do_find( 
-                    input_iterator_type Begin,
-                    input_iterator_type End ) const
-                {
-                    if (!m_Finder.empty())
-                    {
-                        return m_Finder(Begin,End);
-                    }
-                    else
-                    {
-                        return match_type(End,End);
-                    }
-                }
-
-                // Check
-                bool is_null() const
-                {
-                    return m_Finder.empty();
-                }
-
-            private:
-                // Finder
-                finder_type m_Finder;
-            };
-
-       } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-
-#endif  // BOOST_STRING_FIND_ITERATOR_DETAIL_HPP

test/external/boost/algorithm/string/detail/finder.hpp

@@ -1,646 +0,0 @@
-//  Boost string_algo library finder.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FINDER_DETAIL_HPP
-#define BOOST_STRING_FINDER_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/constants.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/range/iterator_range.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/empty.hpp>
-#include <boost/range/as_literal.hpp>
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-
-//  find first functor -----------------------------------------------//
-
-            // find a subsequence in the sequence ( functor )
-            /*
-                Returns a pair <begin,end> marking the subsequence in the sequence.
-                If the find fails, functor returns <End,End>
-            */
-            template<typename SearchIteratorT,typename PredicateT>
-            struct first_finderF
-            {
-                typedef SearchIteratorT search_iterator_type;
-
-                // Construction
-                template< typename SearchT >
-                first_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
-                first_finderF(
-                        search_iterator_type SearchBegin,
-                        search_iterator_type SearchEnd,
-                        PredicateT Comp ) :
-                    m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
-
-                // Operation
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                operator()(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End ) const
-                {
-                    typedef iterator_range<ForwardIteratorT> result_type;
-                    typedef ForwardIteratorT input_iterator_type;
-
-                    // Outer loop
-                    for(input_iterator_type OuterIt=Begin;
-                        OuterIt!=End;
-                        ++OuterIt)
-                    {
-                        // Sanity check
-                        if( boost::empty(m_Search) )
-                            return result_type( End, End );
-
-                        input_iterator_type InnerIt=OuterIt;
-                        search_iterator_type SubstrIt=m_Search.begin();
-                        for(;
-                            InnerIt!=End && SubstrIt!=m_Search.end();
-                            ++InnerIt,++SubstrIt)
-                        {
-                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
-                                break;
-                        }
-
-                        // Substring matching succeeded
-                        if ( SubstrIt==m_Search.end() )
-                            return result_type( OuterIt, InnerIt );
-                    }
-
-                    return result_type( End, End );
-                }
-
-            private:
-                iterator_range<search_iterator_type> m_Search;
-                PredicateT m_Comp;
-            };
-
-//  find last functor -----------------------------------------------//
-
-            // find the last match a subseqeunce in the sequence ( functor )
-            /*
-                Returns a pair <begin,end> marking the subsequence in the sequence.
-                If the find fails, returns <End,End>
-            */
-            template<typename SearchIteratorT, typename PredicateT>
-            struct last_finderF
-            {
-                typedef SearchIteratorT search_iterator_type;
-                typedef first_finderF<
-                    search_iterator_type,
-                    PredicateT> first_finder_type;
-
-                // Construction
-                template< typename SearchT >
-                last_finderF( const SearchT& Search, PredicateT Comp ) :
-                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
-                last_finderF(
-                        search_iterator_type SearchBegin,
-                        search_iterator_type SearchEnd,
-                        PredicateT Comp ) :
-                    m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
-
-                // Operation
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                operator()(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End ) const
-                {
-                    typedef iterator_range<ForwardIteratorT> result_type;
-
-                    if( boost::empty(m_Search) )
-                        return result_type( End, End );
-
-                    typedef BOOST_STRING_TYPENAME boost::detail::
-                        iterator_traits<ForwardIteratorT>::iterator_category category;
-
-                    return findit( Begin, End, category() );
-                }
-
-            private:
-                // forward iterator
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                findit(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End,
-                    std::forward_iterator_tag ) const
-                {
-                    typedef ForwardIteratorT input_iterator_type;
-                    typedef iterator_range<ForwardIteratorT> result_type;
-
-                    first_finder_type first_finder(
-                        m_Search.begin(), m_Search.end(), m_Comp );
-
-                    result_type M=first_finder( Begin, End );
-                    result_type Last=M;
-
-                    while( M )
-                    {
-                        Last=M;
-                        M=first_finder( ::boost::end(M), End );
-                    }
-
-                    return Last;
-                }
-
-                // bidirectional iterator
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                findit(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End,
-                    std::bidirectional_iterator_tag ) const
-                {
-                    typedef iterator_range<ForwardIteratorT> result_type;
-                    typedef ForwardIteratorT input_iterator_type;
-
-                    // Outer loop
-                    for(input_iterator_type OuterIt=End;
-                        OuterIt!=Begin; )
-                    {
-                        input_iterator_type OuterIt2=--OuterIt;
-
-                        input_iterator_type InnerIt=OuterIt2;
-                        search_iterator_type SubstrIt=m_Search.begin();
-                        for(;
-                            InnerIt!=End && SubstrIt!=m_Search.end();
-                            ++InnerIt,++SubstrIt)
-                        {
-                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
-                                break;
-                        }
-
-                        // Substring matching succeeded
-                        if( SubstrIt==m_Search.end() )
-                            return result_type( OuterIt2, InnerIt );
-                    }
-
-                    return result_type( End, End );
-                }
-
-            private:
-                iterator_range<search_iterator_type> m_Search;
-                PredicateT m_Comp;
-            };
-
-//  find n-th functor -----------------------------------------------//
-
-            // find the n-th match of a subsequence in the sequence ( functor )
-            /*
-                Returns a pair <begin,end> marking the subsequence in the sequence.
-                If the find fails, returns <End,End>
-            */
-            template<typename SearchIteratorT, typename PredicateT>
-            struct nth_finderF
-            {
-                typedef SearchIteratorT search_iterator_type;
-                typedef first_finderF<
-                    search_iterator_type,
-                    PredicateT> first_finder_type;
-                typedef last_finderF<
-                    search_iterator_type,
-                    PredicateT> last_finder_type;
-
-                // Construction
-                template< typename SearchT >
-                nth_finderF(
-                        const SearchT& Search,
-                        int Nth,
-                        PredicateT Comp) :
-                    m_Search(::boost::begin(Search), ::boost::end(Search)),
-                    m_Nth(Nth),
-                    m_Comp(Comp) {}
-                nth_finderF(
-                        search_iterator_type SearchBegin,
-                        search_iterator_type SearchEnd,
-                        int Nth,
-                        PredicateT Comp) :
-                    m_Search(SearchBegin, SearchEnd),
-                    m_Nth(Nth),
-                    m_Comp(Comp) {}
-
-                // Operation
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                operator()(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End ) const
-                {
-                    if(m_Nth>=0)
-                    {
-                        return find_forward(Begin, End, m_Nth);
-                    }
-                    else
-                    {
-                        return find_backward(Begin, End, -m_Nth);
-                    }
-
-                }
-
-            private:
-                // Implementation helpers
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                find_forward(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End,
-                    unsigned int N) const
-                {
-                    typedef ForwardIteratorT input_iterator_type;
-                    typedef iterator_range<ForwardIteratorT> result_type;
-
-                    // Sanity check
-                    if( boost::empty(m_Search) )
-                        return result_type( End, End );
-
-                    // Instantiate find functor
-                    first_finder_type first_finder(
-                        m_Search.begin(), m_Search.end(), m_Comp );
-
-                    result_type M( Begin, Begin );
-
-                    for( unsigned int n=0; n<=N; ++n )
-                    {
-                        // find next match
-                        M=first_finder( ::boost::end(M), End );
-
-                        if ( !M )
-                        {
-                            // Subsequence not found, return
-                            return M;
-                        }
-                    }
-
-                    return M;
-                }
-
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                find_backward(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End,
-                    unsigned int N) const
-                {
-                    typedef ForwardIteratorT input_iterator_type;
-                    typedef iterator_range<ForwardIteratorT> result_type;
-
-                    // Sanity check
-                    if( boost::empty(m_Search) )
-                        return result_type( End, End );
-
-                    // Instantiate find functor
-                    last_finder_type last_finder(
-                        m_Search.begin(), m_Search.end(), m_Comp );
-
-                    result_type M( End, End );
-
-                    for( unsigned int n=1; n<=N; ++n )
-                    {
-                        // find next match
-                        M=last_finder( Begin, ::boost::begin(M) );
-
-                        if ( !M )
-                        {
-                            // Subsequence not found, return
-                            return M;
-                        }
-                    }
-
-                    return M;
-                }
-
-
-            private:
-                iterator_range<search_iterator_type> m_Search;
-                int m_Nth;
-                PredicateT m_Comp;
-            };
-
-//  find head/tail implementation helpers ---------------------------//
-
-            template<typename ForwardIteratorT>
-                iterator_range<ForwardIteratorT>
-            find_head_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::forward_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                input_iterator_type It=Begin;
-                for(
-                    unsigned int Index=0;
-                    Index<N && It!=End; ++Index,++It ) {};
-
-                return result_type( Begin, It );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_head_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::random_access_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
-                    return result_type( Begin, End );
-
-                return result_type(Begin,Begin+N);
-            }
-
-            // Find head implementation
-            template<typename ForwardIteratorT>
-                iterator_range<ForwardIteratorT>
-            find_head_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N )
-            {
-                typedef BOOST_STRING_TYPENAME boost::detail::
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
-
-                return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::forward_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                unsigned int Index=0;
-                input_iterator_type It=Begin;
-                input_iterator_type It2=Begin;
-
-                // Advance It2 by N increments
-                for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
-
-                // Advance It, It2 to the end
-                for(; It2!=End; ++It,++It2 ) {};
-
-                return result_type( It, It2 );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::bidirectional_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                input_iterator_type It=End;
-                for(
-                    unsigned int Index=0;
-                    Index<N && It!=Begin; ++Index,--It ) {};
-
-                return result_type( It, End );
-            }
-
-            template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N,
-                std::random_access_iterator_tag )
-            {
-                typedef ForwardIteratorT input_iterator_type;
-                typedef iterator_range<ForwardIteratorT> result_type;
-
-                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
-                    return result_type( Begin, End );
-
-                return result_type( End-N, End );
-            }
-
-                        // Operation
-            template< typename ForwardIteratorT >
-            iterator_range<ForwardIteratorT>
-            find_tail_impl(
-                ForwardIteratorT Begin,
-                ForwardIteratorT End,
-                unsigned int N )
-            {
-                typedef BOOST_STRING_TYPENAME boost::detail::
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
-
-                return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
-            }
-
-
-
-//  find head functor -----------------------------------------------//
-
-
-            // find a head in the sequence ( functor )
-            /*
-                This functor find a head of the specified range. For
-                a specified N, the head is a subsequence of N starting
-                elements of the range.
-            */
-            struct head_finderF
-            {
-                // Construction
-                head_finderF( int N ) : m_N(N) {}
-
-                // Operation
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                operator()(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End ) const
-                {
-                    if(m_N>=0)
-                    {
-                        return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
-                    }
-                    else
-                    {
-                        iterator_range<ForwardIteratorT> Res=
-                            ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
-
-                        return ::boost::make_iterator_range(Begin, Res.begin());
-                    }
-                }
-
-            private:
-                int m_N;
-            };
-
-//  find tail functor -----------------------------------------------//
-
-
-            // find a tail in the sequence ( functor )
-            /*
-                This functor find a tail of the specified range. For
-                a specified N, the head is a subsequence of N starting
-                elements of the range.
-            */
-            struct tail_finderF
-            {
-                // Construction
-                tail_finderF( int N ) : m_N(N) {}
-
-                // Operation
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                operator()(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End ) const
-                {
-                    if(m_N>=0)
-                    {
-                        return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
-                    }
-                    else
-                    {
-                        iterator_range<ForwardIteratorT> Res=
-                            ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
-
-                        return ::boost::make_iterator_range(Res.end(), End);
-                    }
-                }
-
-            private:
-                int m_N;
-            };
-
-//  find token functor -----------------------------------------------//
-
-            // find a token in a sequence ( functor )
-            /*
-                This find functor finds a token specified be a predicate
-                in a sequence. It is equivalent of std::find algorithm,
-                with an exception that it return range instead of a single
-                iterator.
-
-                If bCompress is set to true, adjacent matching tokens are
-                concatenated into one match.
-            */
-            template< typename PredicateT >
-            struct token_finderF
-            {
-                // Construction
-                token_finderF(
-                    PredicateT Pred,
-                    token_compress_mode_type eCompress=token_compress_off ) :
-                        m_Pred(Pred), m_eCompress(eCompress) {}
-
-                // Operation
-                template< typename ForwardIteratorT >
-                iterator_range<ForwardIteratorT>
-                operator()(
-                    ForwardIteratorT Begin,
-                    ForwardIteratorT End ) const
-                {
-                    typedef iterator_range<ForwardIteratorT> result_type;
-
-                    ForwardIteratorT It=std::find_if( Begin, End, m_Pred );
-
-                    if( It==End )
-                    {
-                        return result_type( End, End );
-                    }
-                    else
-                    {
-                        ForwardIteratorT It2=It;
-
-                        if( m_eCompress==token_compress_on )
-                        {
-                            // Find first non-matching character
-                            while( It2!=End && m_Pred(*It2) ) ++It2;
-                        }
-                        else
-                        {
-                            // Advance by one position
-                            ++It2;
-                        }
-
-                        return result_type( It, It2 );
-                    }
-                }
-
-            private:
-                PredicateT m_Pred;
-                token_compress_mode_type m_eCompress;
-            };
-
-//  find range functor -----------------------------------------------//
-
-            // find a range in the sequence ( functor )
-            /*
-                This functor actually does not perform any find operation.
-                It always returns given iterator range as a result.
-            */
-            template<typename ForwardIterator1T>
-            struct range_finderF
-            {
-                typedef ForwardIterator1T input_iterator_type;
-                typedef iterator_range<input_iterator_type> result_type;
-
-                // Construction
-                range_finderF(
-                    input_iterator_type Begin,
-                    input_iterator_type End ) : m_Range(Begin, End) {}
-
-                range_finderF(const iterator_range<input_iterator_type>& Range) :
-                    m_Range(Range) {}
-
-                // Operation
-                template< typename ForwardIterator2T >
-                iterator_range<ForwardIterator2T>
-                operator()(
-                    ForwardIterator2T,
-                    ForwardIterator2T ) const
-                {
-#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) 
-                    return iterator_range<const ForwardIterator2T>(this->m_Range);
-#elif BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-                    return iterator_range<ForwardIterator2T>(m_Range.begin(), m_Range.end());
-#else
-                    return m_Range;
-#endif
-                }
-
-            private:
-                iterator_range<input_iterator_type> m_Range;
-            };
-
-
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-#endif  // BOOST_STRING_FINDER_DETAIL_HPP

test/external/boost/algorithm/string/detail/finder_regex.hpp

@@ -1,122 +0,0 @@
-//  Boost string_algo library find_regex.hpp header file  ---------------------------//
-
-//  Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FINDER_REGEX_DETAIL_HPP
-#define BOOST_STRING_FINDER_REGEX_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/regex.hpp>
-
-#include <boost/range/iterator_range.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost {
-    namespace algorithm {
-        namespace detail {
-
-//  regex find functor -----------------------------------------------//
-
-            // regex search result
-            template<typename IteratorT>
-            struct regex_search_result : 
-                public iterator_range<IteratorT>
-            {
-                typedef regex_search_result<IteratorT> type;
-                typedef iterator_range<IteratorT> base_type;
-                typedef BOOST_STRING_TYPENAME base_type::value_type value_type;
-                typedef BOOST_STRING_TYPENAME base_type::difference_type difference_type;
-                typedef BOOST_STRING_TYPENAME base_type::const_iterator const_iterator;
-                typedef BOOST_STRING_TYPENAME base_type::iterator iterator;
-                typedef boost::match_results<iterator> match_results_type;
-
-                // Construction
-
-                // Construction from the match result
-                regex_search_result( const match_results_type& MatchResults ) :
-                    base_type( MatchResults[0].first, MatchResults[0].second ),
-                    m_MatchResults( MatchResults ) {}
-                
-                // Construction of empty match. End iterator has to be specified
-                regex_search_result( IteratorT End ) :
-                    base_type( End, End ) {}
-
-                regex_search_result( const regex_search_result& Other ) :
-                    base_type( Other.begin(), Other.end() ),
-                    m_MatchResults( Other.m_MatchResults ) {}
-
-                // Assignment
-                regex_search_result& operator=( const regex_search_result& Other )
-                {
-                    base_type::operator=( Other );
-                    m_MatchResults=Other.m_MatchResults;
-                    return *this;
-                }
-
-                // Match result retrival
-                const match_results_type& match_results() const
-                {
-                    return m_MatchResults;
-                }
-
-            private:
-                // Saved matchresult
-                match_results_type m_MatchResults;
-            };
-
-            // find_regex
-            /*
-                Regex based search functor
-            */
-            template<typename RegExT>
-            struct find_regexF
-            {
-                typedef RegExT regex_type;
-                typedef const RegExT& regex_reference_type;
-                    
-                // Construction
-                find_regexF( regex_reference_type Rx, match_flag_type MatchFlags = match_default ) : 
-                    m_Rx(Rx), m_MatchFlags(MatchFlags) {}   
-
-                // Operation
-                template< typename ForwardIteratorT >
-                regex_search_result<ForwardIteratorT>
-                operator()( 
-                    ForwardIteratorT Begin, 
-                    ForwardIteratorT End ) const
-                {
-                    typedef ForwardIteratorT input_iterator_type;
-                    typedef regex_search_result<ForwardIteratorT> result_type;
-
-                    // instantiate match result
-                    match_results<input_iterator_type> result;
-                    // search for a match
-                    if ( ::boost::regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
-                    {
-                        // construct a result
-                        return result_type( result );
-                    }
-                    else
-                    {
-                        // empty result
-                        return result_type( End );
-                    }
-                }
-
-            private:
-                regex_reference_type m_Rx; // Regexp
-                match_flag_type m_MatchFlags;     // match flags
-            };
-
-        } // namespace detail
-    } // namespace algorithm
-} // namespace boost
-
-#endif  // BOOST_STRING_FIND_DETAIL_HPP