Added boost header

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

@@ -0,0 +1,75 @@
+// 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

@@ -0,0 +1,10 @@
+// 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

@@ -0,0 +1,10 @@
+// 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

@@ -0,0 +1,10 @@
+// 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

@@ -0,0 +1,148 @@
+// 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

@@ -0,0 +1,20 @@
+// 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

@@ -0,0 +1,497 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \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

@@ -0,0 +1,82 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \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

@@ -0,0 +1,360 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \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

@@ -0,0 +1,329 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \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

@@ -0,0 +1,221 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \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