Merge lp:~mordred/maria/oqgraph-build into lp:~maria-captains/maria/5.1.39-oqgraph

[Monty Taylor]

[Monty Taylor (mordred)]

Removed the boost dir and put in some autoconf checks for boost per conversation with Arjen on IRC. It seems to build on my laptop at least.

=== modified file 'storage/oqgraph/Makefile.am'
--- storage/oqgraph/Makefile.am	2009-11-23 21:22:01 +0000
+++ storage/oqgraph/Makefile.am	2009-12-23 02:41:21 +0000
@@ -45,16 +45,14 @@
 
 EXTRA_DIST =	ha_oqgraph.h ha_oqgraph.cc graphcore.cc \
 		graphcore-graph.h graphcore-types.h graphcore.h \
-		CMakeFiles.txt plug.in oqgraph_probes.d \
-		boost
+		CMakeFiles.txt plug.in oqgraph_probes.d
 
 DTRACE =                @DTRACE@
 DTRACEFLAGS =           @DTRACEFLAGS@
 DTRACEFILES =           .libs/liboqgraph_engine_la-ha_oqgraph.o
 
-ORIG_CXXFLAGS= @CXXFLAGS@
+ORIG_CXXFLAGS=$(CXXFLAGS)
 CXXFLAGS=
-
 noinst_HEADERS = ha_oqgraph.h \
 		 graphcore-graph.h graphcore-types.h graphcore.h \
 		 oqgraph_probes.h
@@ -74,7 +72,7 @@
 EXTRA_LTLIBRARIES = oqgraph_engine.la
 mysqlplugin_LTLIBRARIES = @plugin_oqgraph_shared_target@
 oqgraph_engine_la_SOURCES = ha_oqgraph.cc
-oqgraph_engine_la_LIBADD = libgraphcore.la
+oqgraph_engine_la_LIBADD = libgraphcore.la ${BOOST_LIBS}
 
 if HAVE_DTRACE
   oqgraph_engine_la_LIBADD += oqgraph_probes.o

=== removed directory 'storage/oqgraph/boost'
=== removed file 'storage/oqgraph/boost/LICENSE_1_0.txt'
--- storage/oqgraph/boost/LICENSE_1_0.txt	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/LICENSE_1_0.txt	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

=== removed directory 'storage/oqgraph/boost/accumulators'
=== removed file 'storage/oqgraph/boost/accumulators/accumulators.hpp'
--- storage/oqgraph/boost/accumulators/accumulators.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/accumulators.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/accumulators_fwd.hpp'
--- storage/oqgraph/boost/accumulators/accumulators_fwd.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/accumulators_fwd.hpp	1970-01-01 00:00:00 +0000
@@ -1,211 +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
-
-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;
-}
-
-}} // 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

=== removed directory 'storage/oqgraph/boost/accumulators/framework'
=== removed file 'storage/oqgraph/boost/accumulators/framework/accumulator_base.hpp'
--- storage/oqgraph/boost/accumulators/framework/accumulator_base.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/accumulator_base.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/accumulator_concept.hpp'
--- storage/oqgraph/boost/accumulators/framework/accumulator_concept.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/accumulator_concept.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/accumulator_set.hpp'
--- storage/oqgraph/boost/accumulators/framework/accumulator_set.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/accumulator_set.hpp	1970-01-01 00:00:00 +0000
@@ -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 &args)
-          : args(args)
-        {
-        }
-
-        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

=== removed directory 'storage/oqgraph/boost/accumulators/framework/accumulators'
=== removed file 'storage/oqgraph/boost/accumulators/framework/accumulators/droppable_accumulator.hpp'
--- storage/oqgraph/boost/accumulators/framework/accumulators/droppable_accumulator.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/accumulators/droppable_accumulator.hpp	1970-01-01 00:00:00 +0000
@@ -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 &result)
-        {
-            ::new(this->cache.address()) result_type(result);
-        }
-
-        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

=== removed file 'storage/oqgraph/boost/accumulators/framework/accumulators/external_accumulator.hpp'
--- storage/oqgraph/boost/accumulators/framework/accumulators/external_accumulator.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/accumulators/external_accumulator.hpp	1970-01-01 00:00:00 +0000
@@ -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(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

=== removed file 'storage/oqgraph/boost/accumulators/framework/accumulators/reference_accumulator.hpp'
--- storage/oqgraph/boost/accumulators/framework/accumulators/reference_accumulator.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/accumulators/reference_accumulator.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/accumulators/value_accumulator.hpp'
--- storage/oqgraph/boost/accumulators/framework/accumulators/value_accumulator.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/accumulators/value_accumulator.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/depends_on.hpp'
--- storage/oqgraph/boost/accumulators/framework/depends_on.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/depends_on.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/external.hpp'
--- storage/oqgraph/boost/accumulators/framework/external.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/external.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/extractor.hpp'
--- storage/oqgraph/boost/accumulators/framework/extractor.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/extractor.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/features.hpp'
--- storage/oqgraph/boost/accumulators/framework/features.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/features.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed directory 'storage/oqgraph/boost/accumulators/framework/parameters'
=== removed file 'storage/oqgraph/boost/accumulators/framework/parameters/accumulator.hpp'
--- storage/oqgraph/boost/accumulators/framework/parameters/accumulator.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/parameters/accumulator.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/parameters/sample.hpp'
--- storage/oqgraph/boost/accumulators/framework/parameters/sample.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/parameters/sample.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/parameters/weight.hpp'
--- storage/oqgraph/boost/accumulators/framework/parameters/weight.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/parameters/weight.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/framework/parameters/weights.hpp'
--- storage/oqgraph/boost/accumulators/framework/parameters/weights.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/framework/parameters/weights.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed directory 'storage/oqgraph/boost/accumulators/numeric'
=== removed directory 'storage/oqgraph/boost/accumulators/numeric/detail'
=== removed file 'storage/oqgraph/boost/accumulators/numeric/detail/function1.hpp'
--- storage/oqgraph/boost/accumulators/numeric/detail/function1.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/detail/function1.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/numeric/detail/function2.hpp'
--- storage/oqgraph/boost/accumulators/numeric/detail/function2.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/detail/function2.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/numeric/detail/function3.hpp'
--- storage/oqgraph/boost/accumulators/numeric/detail/function3.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/detail/function3.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/numeric/detail/function4.hpp'
--- storage/oqgraph/boost/accumulators/numeric/detail/function4.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/detail/function4.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/numeric/detail/function_n.hpp'
--- storage/oqgraph/boost/accumulators/numeric/detail/function_n.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/detail/function_n.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/numeric/detail/pod_singleton.hpp'
--- storage/oqgraph/boost/accumulators/numeric/detail/pod_singleton.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/detail/pod_singleton.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed directory 'storage/oqgraph/boost/accumulators/numeric/functional'
=== removed file 'storage/oqgraph/boost/accumulators/numeric/functional.hpp'
--- storage/oqgraph/boost/accumulators/numeric/functional.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/functional.hpp	1970-01-01 00:00:00 +0000
@@ -1,490 +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/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>
-        {
-            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>
-        {
-            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>
-        {
-            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

=== removed file 'storage/oqgraph/boost/accumulators/numeric/functional/complex.hpp'
--- storage/oqgraph/boost/accumulators/numeric/functional/complex.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/functional/complex.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/numeric/functional/valarray.hpp'
--- storage/oqgraph/boost/accumulators/numeric/functional/valarray.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/functional/valarray.hpp	1970-01-01 00:00:00 +0000
@@ -1,351 +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
-    {
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle valarray<Left> / Right where Right is a scalar and Right != Left.
-        template<typename Left, typename Right>
-        typename enable_if<
-            mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
-          , std::valarray<typename functional::divides<Left, Right>::result_type>
-        >::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 enable_if<
-            mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
-          , std::valarray<typename functional::multiplies<Left, Right>::result_type>
-        >::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 disable_if<
-            is_same<Left, Right>
-          , std::valarray<typename functional::plus<Left, Right>::result_type>
-        >::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
-

=== removed file 'storage/oqgraph/boost/accumulators/numeric/functional/vector.hpp'
--- storage/oqgraph/boost/accumulators/numeric/functional/vector.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/functional/vector.hpp	1970-01-01 00:00:00 +0000
@@ -1,320 +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
-    {
-        ///////////////////////////////////////////////////////////////////////////////
-        // Handle vector<Left> / Right where Right is a scalar.
-        template<typename Left, typename Right>
-        typename enable_if<
-            is_scalar<Right>
-          , std::vector<typename functional::divides<Left, Right>::result_type>
-        >::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 enable_if<
-            is_scalar<Right>
-          , std::vector<typename functional::multiplies<Left, Right>::result_type>
-        >::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 enable_if<
-            is_scalar<Left>
-          , std::vector<typename functional::multiplies<Left, Right>::result_type>
-        >::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
-

=== removed file 'storage/oqgraph/boost/accumulators/numeric/functional_fwd.hpp'
--- storage/oqgraph/boost/accumulators/numeric/functional_fwd.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/numeric/functional_fwd.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed directory 'storage/oqgraph/boost/accumulators/statistics'
=== removed file 'storage/oqgraph/boost/accumulators/statistics.hpp'
--- storage/oqgraph/boost/accumulators/statistics.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/statistics.hpp	1970-01-01 00:00:00 +0000
@@ -1,59 +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/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_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

=== removed file 'storage/oqgraph/boost/accumulators/statistics/count.hpp'
--- storage/oqgraph/boost/accumulators/statistics/count.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/statistics/count.hpp	1970-01-01 00:00:00 +0000
@@ -1,78 +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 = {};
-}
-
-using extract::count;
-
-}} // namespace boost::accumulators
-
-#endif

=== removed file 'storage/oqgraph/boost/accumulators/statistics/covariance.hpp'
--- storage/oqgraph/boost/accumulators/statistics/covariance.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/statistics/covariance.hpp	1970-01-01 00:00:00 +0000
@@ -1,218 +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 = {};
-}
-
-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

=== removed file 'storage/oqgraph/boost/accumulators/statistics/density.hpp'
--- storage/oqgraph/boost/accumulators/statistics/density.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/statistics/density.hpp	1970-01-01 00:00:00 +0000
@@ -1,241 +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]);
-                }
-            }
-        }
-
-        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 = {};
-}
-
-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

=== removed file 'storage/oqgraph/boost/accumulators/statistics/error_of.hpp'
--- storage/oqgraph/boost/accumulators/statistics/error_of.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/statistics/error_of.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/statistics/error_of_mean.hpp'
--- storage/oqgraph/boost/accumulators/statistics/error_of_mean.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/statistics/error_of_mean.hpp	1970-01-01 00:00:00 +0000
@@ -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

=== removed file 'storage/oqgraph/boost/accumulators/statistics/extended_p_square.hpp'
--- storage/oqgraph/boost/accumulators/statistics/extended_p_square.hpp	2009-11-09 11:51:39 +0000
+++ storage/oqgraph/boost/accumulators/statistics/extended_p_square.hpp	1970-01-01 00:00:00 +0000
@@ -1,291 +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());
-                }