Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,64 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2005-2012 Joel de Guzman
|
||||
Copyright (c) 2005-2006 Dan Marsden
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139)
|
||||
#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139
|
||||
|
||||
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
|
||||
#error "C++03 only! This file should not have been included"
|
||||
#endif
|
||||
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/mpl/find.hpp>
|
||||
#include <boost/mpl/begin.hpp>
|
||||
#include <boost/mpl/distance.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/vector.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct void_;
|
||||
}}
|
||||
|
||||
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
|
||||
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size.hpp>
|
||||
#else
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque_initial_size" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
|
||||
#endif
|
||||
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
|
||||
struct deque_initial_size
|
||||
{
|
||||
typedef mpl::vector<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)> args;
|
||||
typedef typename mpl::find<args, void_>::type first_void;
|
||||
typedef typename mpl::distance<typename mpl::begin<args>::type, first_void>::type type;
|
||||
};
|
||||
}}}
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,92 @@
|
||||
// (C) Copyright 2007-2009 Andrew Sutton
|
||||
//
|
||||
// Use, modification and distribution are subject to the
|
||||
// Boost Software License, Version 1.0 (See accompanying file
|
||||
// LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_GRAPH_CONSTANT_PROPERTY_HPP
|
||||
#define BOOST_GRAPH_CONSTANT_PROPERTY_HPP
|
||||
|
||||
#include <boost/property_map/property_map.hpp>
|
||||
|
||||
|
||||
// TODO: This should really be part of the property maps library rather than
|
||||
// the Boost.Graph library.
|
||||
|
||||
namespace boost {
|
||||
|
||||
/**
|
||||
* A constant property is one, that regardless of the edge or vertex given,
|
||||
* will always return a constant value.
|
||||
*/
|
||||
template <typename Key, typename Value>
|
||||
struct constant_property_map
|
||||
: public boost::put_get_helper<
|
||||
const Value&,
|
||||
constant_property_map<Key, Value>
|
||||
>
|
||||
{
|
||||
typedef Key key_type;
|
||||
typedef Value value_type;
|
||||
typedef const Value& reference;
|
||||
typedef boost::readable_property_map_tag category;
|
||||
|
||||
constant_property_map()
|
||||
: m_value()
|
||||
{ }
|
||||
|
||||
constant_property_map(const value_type &value)
|
||||
: m_value(value)
|
||||
{ }
|
||||
|
||||
constant_property_map(const constant_property_map& copy)
|
||||
: m_value(copy.m_value)
|
||||
{ }
|
||||
|
||||
inline reference operator [](const key_type&) const
|
||||
{ return m_value; }
|
||||
|
||||
value_type m_value;
|
||||
};
|
||||
|
||||
template <typename Key, typename Value>
|
||||
inline constant_property_map<Key, Value>
|
||||
make_constant_property(const Value& value)
|
||||
{ return constant_property_map<Key, Value>(value); }
|
||||
|
||||
/**
|
||||
* Same as above, but pretends to be writable as well.
|
||||
*/
|
||||
template <typename Key, typename Value>
|
||||
struct constant_writable_property_map {
|
||||
typedef Key key_type;
|
||||
typedef Value value_type;
|
||||
typedef Value& reference;
|
||||
typedef boost::read_write_property_map_tag category;
|
||||
|
||||
constant_writable_property_map()
|
||||
: m_value()
|
||||
{ }
|
||||
|
||||
constant_writable_property_map(const value_type &value)
|
||||
: m_value(value)
|
||||
{ }
|
||||
|
||||
constant_writable_property_map(const constant_writable_property_map& copy)
|
||||
: m_value(copy.m_value)
|
||||
{ }
|
||||
|
||||
friend Value get(const constant_writable_property_map& me, Key) {return me.m_value;}
|
||||
friend void put(const constant_writable_property_map&, Key, Value) {}
|
||||
|
||||
value_type m_value;
|
||||
};
|
||||
|
||||
template <typename Key, typename Value>
|
||||
inline constant_writable_property_map<Key, Value>
|
||||
make_constant_writable_property(const Value& value)
|
||||
{ return constant_writable_property_map<Key, Value>(value); }
|
||||
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
Binary file not shown.
@@ -0,0 +1,171 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename T0>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0&>
|
||||
tie(T0 & arg0)
|
||||
{
|
||||
return tuple<T0&>(
|
||||
arg0);
|
||||
}
|
||||
template <typename T0 , typename T1>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1&>
|
||||
tie(T0 & arg0 , T1 & arg1)
|
||||
{
|
||||
return tuple<T0& , T1&>(
|
||||
arg0 , arg1);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2)
|
||||
{
|
||||
return tuple<T0& , T1& , T2&>(
|
||||
arg0 , arg1 , arg2);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3&>(
|
||||
arg0 , arg1 , arg2 , arg3);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19);
|
||||
}
|
||||
}}
|
||||
@@ -0,0 +1,19 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_VERSION_HPP_VP_2004_04_05
|
||||
#define BOOST_PROGRAM_OPTIONS_VERSION_HPP_VP_2004_04_05
|
||||
|
||||
/** The version of the source interface.
|
||||
The value will be incremented whenever a change is made which might
|
||||
cause compilation errors for existing code.
|
||||
*/
|
||||
#ifdef BOOST_PROGRAM_OPTIONS_VERSION
|
||||
#error BOOST_PROGRAM_OPTIONS_VERSION already defined
|
||||
#endif
|
||||
#define BOOST_PROGRAM_OPTIONS_VERSION 2
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,305 @@
|
||||
/* Boost interval/arith2.hpp template implementation file
|
||||
*
|
||||
* This header provides some auxiliary arithmetic
|
||||
* functions: fmod, sqrt, square, pov, inverse and
|
||||
* a multi-interval division.
|
||||
*
|
||||
* Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
|
||||
*
|
||||
* 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_INTERVAL_ARITH2_HPP
|
||||
#define BOOST_NUMERIC_INTERVAL_ARITH2_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/numeric/interval/detail/interval_prototype.hpp>
|
||||
#include <boost/numeric/interval/detail/test_input.hpp>
|
||||
#include <boost/numeric/interval/detail/bugs.hpp>
|
||||
#include <boost/numeric/interval/detail/division.hpp>
|
||||
#include <boost/numeric/interval/arith.hpp>
|
||||
#include <boost/numeric/interval/policies.hpp>
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <boost/config/no_tr1/cmath.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> fmod(const interval<T, Policies>& x,
|
||||
const interval<T, Policies>& y)
|
||||
{
|
||||
if (interval_lib::detail::test_input(x, y))
|
||||
return interval<T, Policies>::empty();
|
||||
typename Policies::rounding rnd;
|
||||
typedef typename interval_lib::unprotect<interval<T, Policies> >::type I;
|
||||
T const &yb = interval_lib::user::is_neg(x.lower()) ? y.lower() : y.upper();
|
||||
T n = rnd.int_down(rnd.div_down(x.lower(), yb));
|
||||
return (const I&)x - n * (const I&)y;
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> fmod(const interval<T, Policies>& x, const T& y)
|
||||
{
|
||||
if (interval_lib::detail::test_input(x, y))
|
||||
return interval<T, Policies>::empty();
|
||||
typename Policies::rounding rnd;
|
||||
typedef typename interval_lib::unprotect<interval<T, Policies> >::type I;
|
||||
T n = rnd.int_down(rnd.div_down(x.lower(), y));
|
||||
return (const I&)x - n * I(y);
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> fmod(const T& x, const interval<T, Policies>& y)
|
||||
{
|
||||
if (interval_lib::detail::test_input(x, y))
|
||||
return interval<T, Policies>::empty();
|
||||
typename Policies::rounding rnd;
|
||||
typedef typename interval_lib::unprotect<interval<T, Policies> >::type I;
|
||||
T const &yb = interval_lib::user::is_neg(x) ? y.lower() : y.upper();
|
||||
T n = rnd.int_down(rnd.div_down(x, yb));
|
||||
return x - n * (const I&)y;
|
||||
}
|
||||
|
||||
namespace interval_lib {
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> division_part1(const interval<T, Policies>& x,
|
||||
const interval<T, Policies>& y, bool& b)
|
||||
{
|
||||
typedef interval<T, Policies> I;
|
||||
b = false;
|
||||
if (detail::test_input(x, y))
|
||||
return I::empty();
|
||||
if (zero_in(y))
|
||||
if (!user::is_zero(y.lower()))
|
||||
if (!user::is_zero(y.upper()))
|
||||
return detail::div_zero_part1(x, y, b);
|
||||
else
|
||||
return detail::div_negative(x, y.lower());
|
||||
else
|
||||
if (!user::is_zero(y.upper()))
|
||||
return detail::div_positive(x, y.upper());
|
||||
else
|
||||
return I::empty();
|
||||
else
|
||||
return detail::div_non_zero(x, y);
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> division_part2(const interval<T, Policies>& x,
|
||||
const interval<T, Policies>& y, bool b = true)
|
||||
{
|
||||
if (!b) return interval<T, Policies>::empty();
|
||||
return detail::div_zero_part2(x, y);
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> multiplicative_inverse(const interval<T, Policies>& x)
|
||||
{
|
||||
typedef interval<T, Policies> I;
|
||||
if (detail::test_input(x))
|
||||
return I::empty();
|
||||
T one = static_cast<T>(1);
|
||||
typename Policies::rounding rnd;
|
||||
if (zero_in(x)) {
|
||||
typedef typename Policies::checking checking;
|
||||
if (!user::is_zero(x.lower()))
|
||||
if (!user::is_zero(x.upper()))
|
||||
return I::whole();
|
||||
else
|
||||
return I(checking::neg_inf(), rnd.div_up(one, x.lower()), true);
|
||||
else
|
||||
if (!user::is_zero(x.upper()))
|
||||
return I(rnd.div_down(one, x.upper()), checking::pos_inf(), true);
|
||||
else
|
||||
return I::empty();
|
||||
} else
|
||||
return I(rnd.div_down(one, x.upper()), rnd.div_up(one, x.lower()), true);
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T, class Rounding> inline
|
||||
T pow_dn(const T& x_, int pwr, Rounding& rnd) // x and pwr are positive
|
||||
{
|
||||
T x = x_;
|
||||
T y = (pwr & 1) ? x_ : static_cast<T>(1);
|
||||
pwr >>= 1;
|
||||
while (pwr > 0) {
|
||||
x = rnd.mul_down(x, x);
|
||||
if (pwr & 1) y = rnd.mul_down(x, y);
|
||||
pwr >>= 1;
|
||||
}
|
||||
return y;
|
||||
}
|
||||
|
||||
template<class T, class Rounding> inline
|
||||
T pow_up(const T& x_, int pwr, Rounding& rnd) // x and pwr are positive
|
||||
{
|
||||
T x = x_;
|
||||
T y = (pwr & 1) ? x_ : static_cast<T>(1);
|
||||
pwr >>= 1;
|
||||
while (pwr > 0) {
|
||||
x = rnd.mul_up(x, x);
|
||||
if (pwr & 1) y = rnd.mul_up(x, y);
|
||||
pwr >>= 1;
|
||||
}
|
||||
return y;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace interval_lib
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> pow(const interval<T, Policies>& x, int pwr)
|
||||
{
|
||||
BOOST_USING_STD_MAX();
|
||||
using interval_lib::detail::pow_dn;
|
||||
using interval_lib::detail::pow_up;
|
||||
typedef interval<T, Policies> I;
|
||||
|
||||
if (interval_lib::detail::test_input(x))
|
||||
return I::empty();
|
||||
|
||||
if (pwr == 0)
|
||||
if (interval_lib::user::is_zero(x.lower())
|
||||
&& interval_lib::user::is_zero(x.upper()))
|
||||
return I::empty();
|
||||
else
|
||||
return I(static_cast<T>(1));
|
||||
else if (pwr < 0)
|
||||
return interval_lib::multiplicative_inverse(pow(x, -pwr));
|
||||
|
||||
typename Policies::rounding rnd;
|
||||
|
||||
if (interval_lib::user::is_neg(x.upper())) { // [-2,-1]
|
||||
T yl = pow_dn(static_cast<T>(-x.upper()), pwr, rnd);
|
||||
T yu = pow_up(static_cast<T>(-x.lower()), pwr, rnd);
|
||||
if (pwr & 1) // [-2,-1]^1
|
||||
return I(-yu, -yl, true);
|
||||
else // [-2,-1]^2
|
||||
return I(yl, yu, true);
|
||||
} else if (interval_lib::user::is_neg(x.lower())) { // [-1,1]
|
||||
if (pwr & 1) { // [-1,1]^1
|
||||
return I(-pow_up(static_cast<T>(-x.lower()), pwr, rnd), pow_up(x.upper(), pwr, rnd), true);
|
||||
} else { // [-1,1]^2
|
||||
return I(static_cast<T>(0), pow_up(max BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<T>(-x.lower()), x.upper()), pwr, rnd), true);
|
||||
}
|
||||
} else { // [1,2]
|
||||
return I(pow_dn(x.lower(), pwr, rnd), pow_up(x.upper(), pwr, rnd), true);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> sqrt(const interval<T, Policies>& x)
|
||||
{
|
||||
typedef interval<T, Policies> I;
|
||||
if (interval_lib::detail::test_input(x) || interval_lib::user::is_neg(x.upper()))
|
||||
return I::empty();
|
||||
typename Policies::rounding rnd;
|
||||
T l = !interval_lib::user::is_pos(x.lower()) ? static_cast<T>(0) : rnd.sqrt_down(x.lower());
|
||||
return I(l, rnd.sqrt_up(x.upper()), true);
|
||||
}
|
||||
|
||||
template<class T, class Policies> inline
|
||||
interval<T, Policies> square(const interval<T, Policies>& x)
|
||||
{
|
||||
typedef interval<T, Policies> I;
|
||||
if (interval_lib::detail::test_input(x))
|
||||
return I::empty();
|
||||
typename Policies::rounding rnd;
|
||||
const T& xl = x.lower();
|
||||
const T& xu = x.upper();
|
||||
if (interval_lib::user::is_neg(xu))
|
||||
return I(rnd.mul_down(xu, xu), rnd.mul_up(xl, xl), true);
|
||||
else if (interval_lib::user::is_pos(x.lower()))
|
||||
return I(rnd.mul_down(xl, xl), rnd.mul_up(xu, xu), true);
|
||||
else
|
||||
return I(static_cast<T>(0), (-xl > xu ? rnd.mul_up(xl, xl) : rnd.mul_up(xu, xu)), true);
|
||||
}
|
||||
|
||||
namespace interval_lib {
|
||||
namespace detail {
|
||||
|
||||
template< class I > inline
|
||||
I root_aux(typename I::base_type const &x, int k) // x and k are bigger than one
|
||||
{
|
||||
typedef typename I::base_type T;
|
||||
T tk(k);
|
||||
I y(static_cast<T>(1), x, true);
|
||||
for(;;) {
|
||||
T y0 = median(y);
|
||||
I yy = intersect(y, y0 - (pow(I(y0, y0, true), k) - x) / (tk * pow(y, k - 1)));
|
||||
if (equal(y, yy)) return y;
|
||||
y = yy;
|
||||
}
|
||||
}
|
||||
|
||||
template< class I > inline // x is positive and k bigger than one
|
||||
typename I::base_type root_aux_dn(typename I::base_type const &x, int k)
|
||||
{
|
||||
typedef typename I::base_type T;
|
||||
typedef typename I::traits_type Policies;
|
||||
typename Policies::rounding rnd;
|
||||
T one(1);
|
||||
if (x > one) return root_aux<I>(x, k).lower();
|
||||
if (x == one) return one;
|
||||
return rnd.div_down(one, root_aux<I>(rnd.div_up(one, x), k).upper());
|
||||
}
|
||||
|
||||
template< class I > inline // x is positive and k bigger than one
|
||||
typename I::base_type root_aux_up(typename I::base_type const &x, int k)
|
||||
{
|
||||
typedef typename I::base_type T;
|
||||
typedef typename I::traits_type Policies;
|
||||
typename Policies::rounding rnd;
|
||||
T one(1);
|
||||
if (x > one) return root_aux<I>(x, k).upper();
|
||||
if (x == one) return one;
|
||||
return rnd.div_up(one, root_aux<I>(rnd.div_down(one, x), k).lower());
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace interval_lib
|
||||
|
||||
template< class T, class Policies > inline
|
||||
interval<T, Policies> nth_root(interval<T, Policies> const &x, int k)
|
||||
{
|
||||
typedef interval<T, Policies> I;
|
||||
if (interval_lib::detail::test_input(x)) return I::empty();
|
||||
assert(k > 0);
|
||||
if (k == 1) return x;
|
||||
typename Policies::rounding rnd;
|
||||
typedef typename interval_lib::unprotect<I>::type R;
|
||||
if (!interval_lib::user::is_pos(x.upper())) {
|
||||
if (interval_lib::user::is_zero(x.upper())) {
|
||||
T zero(0);
|
||||
if (!(k & 1) || interval_lib::user::is_zero(x.lower())) // [-1,0]^/2 or [0,0]
|
||||
return I(zero, zero, true);
|
||||
else // [-1,0]^/3
|
||||
return I(-interval_lib::detail::root_aux_up<R>(-x.lower(), k), zero, true);
|
||||
} else if (!(k & 1)) // [-2,-1]^/2
|
||||
return I::empty();
|
||||
else { // [-2,-1]^/3
|
||||
return I(-interval_lib::detail::root_aux_up<R>(-x.lower(), k),
|
||||
-interval_lib::detail::root_aux_dn<R>(-x.upper(), k), true);
|
||||
}
|
||||
}
|
||||
T u = interval_lib::detail::root_aux_up<R>(x.upper(), k);
|
||||
if (!interval_lib::user::is_pos(x.lower()))
|
||||
if (!(k & 1) || interval_lib::user::is_zero(x.lower())) // [-1,1]^/2 or [0,1]
|
||||
return I(static_cast<T>(0), u, true);
|
||||
else // [-1,1]^/3
|
||||
return I(-interval_lib::detail::root_aux_up<R>(-x.lower(), k), u, true);
|
||||
else // [1,2]
|
||||
return I(interval_lib::detail::root_aux_dn<R>(x.lower(), k), u, true);
|
||||
}
|
||||
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NUMERIC_INTERVAL_ARITH2_HPP
|
||||
@@ -0,0 +1,43 @@
|
||||
//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
|
||||
|
||||
//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 UUID_7E83C166200811DE885E826156D89593
|
||||
#define UUID_7E83C166200811DE885E826156D89593
|
||||
#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(push,1)
|
||||
#endif
|
||||
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
template <class E>
|
||||
inline
|
||||
E *
|
||||
current_exception_cast()
|
||||
{
|
||||
try
|
||||
{
|
||||
throw;
|
||||
}
|
||||
catch(
|
||||
E & e )
|
||||
{
|
||||
return &e;
|
||||
}
|
||||
catch(
|
||||
...)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,15 @@
|
||||
// Copyright David Abrahams 2002.
|
||||
// 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 LIFE_SUPPORT_DWA200222_HPP
|
||||
# define LIFE_SUPPORT_DWA200222_HPP
|
||||
# include <boost/python/detail/prefix.hpp>
|
||||
|
||||
namespace boost { namespace python { namespace objects {
|
||||
|
||||
BOOST_PYTHON_DECL PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient);
|
||||
|
||||
}}} // namespace boost::python::object
|
||||
|
||||
#endif // LIFE_SUPPORT_DWA200222_HPP
|
||||
@@ -0,0 +1,655 @@
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Copyright 2012 John Maddock. 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_
|
||||
//
|
||||
// Comparison operators for cpp_int_backend:
|
||||
//
|
||||
#ifndef BOOST_MP_CPP_INT_DIV_HPP
|
||||
#define BOOST_MP_CPP_INT_DIV_HPP
|
||||
|
||||
namespace boost{ namespace multiprecision{ namespace backends{
|
||||
|
||||
template <class CppInt1, class CppInt2, class CppInt3>
|
||||
void divide_unsigned_helper(
|
||||
CppInt1* result,
|
||||
const CppInt2& x,
|
||||
const CppInt3& y,
|
||||
CppInt1& r)
|
||||
{
|
||||
if(((void*)result == (void*)&x) || ((void*)&r == (void*)&x))
|
||||
{
|
||||
CppInt2 t(x);
|
||||
divide_unsigned_helper(result, t, y, r);
|
||||
return;
|
||||
}
|
||||
if(((void*)result == (void*)&y) || ((void*)&r == (void*)&y))
|
||||
{
|
||||
CppInt3 t(y);
|
||||
divide_unsigned_helper(result, x, t, r);
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
Very simple, fairly braindead long division.
|
||||
Start by setting the remainder equal to x, and the
|
||||
result equal to 0. Then in each loop we calculate our
|
||||
"best guess" for how many times y divides into r,
|
||||
add our guess to the result, and subtract guess*y
|
||||
from the remainder r. One wrinkle is that the remainder
|
||||
may go negative, in which case we subtract the current guess
|
||||
from the result rather than adding. The value of the guess
|
||||
is determined by dividing the most-significant-limb of the
|
||||
current remainder by the most-significant-limb of y.
|
||||
|
||||
Note that there are more efficient algorithms than this
|
||||
available, in particular see Knuth Vol 2. However for small
|
||||
numbers of limbs this generally outperforms the alternatives
|
||||
and avoids the normalisation step which would require extra storage.
|
||||
*/
|
||||
|
||||
|
||||
using default_ops::eval_subtract;
|
||||
|
||||
if(result == &r)
|
||||
{
|
||||
CppInt1 rem;
|
||||
divide_unsigned_helper(result, x, y, rem);
|
||||
r = rem;
|
||||
return;
|
||||
}
|
||||
|
||||
//
|
||||
// Find the most significant words of numerator and denominator.
|
||||
//
|
||||
limb_type y_order = y.size() - 1;
|
||||
|
||||
if(y_order == 0)
|
||||
{
|
||||
//
|
||||
// Only a single non-zero limb in the denominator, in this case
|
||||
// we can use a specialized divide-by-single-limb routine which is
|
||||
// much faster. This also handles division by zero:
|
||||
//
|
||||
divide_unsigned_helper(result, x, y.limbs()[y_order], r);
|
||||
return;
|
||||
}
|
||||
|
||||
typename CppInt2::const_limb_pointer px = x.limbs();
|
||||
typename CppInt3::const_limb_pointer py = y.limbs();
|
||||
|
||||
limb_type r_order = x.size() - 1;
|
||||
if((r_order == 0) && (*px == 0))
|
||||
{
|
||||
// x is zero, so is the result:
|
||||
r = x;
|
||||
if(result)
|
||||
*result = x;
|
||||
return;
|
||||
}
|
||||
|
||||
r = x;
|
||||
r.sign(false);
|
||||
if(result)
|
||||
*result = static_cast<limb_type>(0u);
|
||||
//
|
||||
// Check if the remainder is already less than the divisor, if so
|
||||
// we already have the result. Note we try and avoid a full compare
|
||||
// if we can:
|
||||
//
|
||||
if(r_order <= y_order)
|
||||
{
|
||||
if((r_order < y_order) || (r.compare_unsigned(y) < 0))
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
CppInt1 t;
|
||||
bool r_neg = false;
|
||||
|
||||
//
|
||||
// See if we can short-circuit long division, and use basic arithmetic instead:
|
||||
//
|
||||
if(r_order == 0)
|
||||
{
|
||||
if(result)
|
||||
{
|
||||
*result = px[0] / py[0];
|
||||
}
|
||||
r = px[0] % py[0];
|
||||
return;
|
||||
}
|
||||
else if(r_order == 1)
|
||||
{
|
||||
double_limb_type a, b;
|
||||
a = (static_cast<double_limb_type>(px[1]) << CppInt1::limb_bits) | px[0];
|
||||
b = y_order ?
|
||||
(static_cast<double_limb_type>(py[1]) << CppInt1::limb_bits) | py[0]
|
||||
: py[0];
|
||||
if(result)
|
||||
{
|
||||
*result = a / b;
|
||||
}
|
||||
r = a % b;
|
||||
return;
|
||||
}
|
||||
//
|
||||
// prepare result:
|
||||
//
|
||||
if(result)
|
||||
result->resize(1 + r_order - y_order, 1 + r_order - y_order);
|
||||
typename CppInt1::const_limb_pointer prem = r.limbs();
|
||||
// This is initialised just to keep the compiler from emitting useless warnings later on:
|
||||
typename CppInt1::limb_pointer pr
|
||||
= typename CppInt1::limb_pointer();
|
||||
if(result)
|
||||
{
|
||||
pr = result->limbs();
|
||||
for(unsigned i = 1; i < 1 + r_order - y_order; ++i)
|
||||
pr[i] = 0;
|
||||
}
|
||||
bool first_pass = true;
|
||||
|
||||
do
|
||||
{
|
||||
//
|
||||
// Calculate our best guess for how many times y divides into r:
|
||||
//
|
||||
limb_type guess;
|
||||
if((prem[r_order] <= py[y_order]) && (r_order > 0))
|
||||
{
|
||||
double_limb_type a, b, v;
|
||||
a = (static_cast<double_limb_type>(prem[r_order]) << CppInt1::limb_bits) | prem[r_order - 1];
|
||||
b = py[y_order];
|
||||
v = a / b;
|
||||
if(v > CppInt1::max_limb_value)
|
||||
guess = 1;
|
||||
else
|
||||
{
|
||||
guess = static_cast<limb_type>(v);
|
||||
--r_order;
|
||||
}
|
||||
}
|
||||
else if(r_order == 0)
|
||||
{
|
||||
guess = prem[0] / py[y_order];
|
||||
}
|
||||
else
|
||||
{
|
||||
double_limb_type a, b, v;
|
||||
a = (static_cast<double_limb_type>(prem[r_order]) << CppInt1::limb_bits) | prem[r_order - 1];
|
||||
b = (y_order > 0) ? (static_cast<double_limb_type>(py[y_order]) << CppInt1::limb_bits) | py[y_order - 1] : (static_cast<double_limb_type>(py[y_order]) << CppInt1::limb_bits);
|
||||
v = a / b;
|
||||
guess = static_cast<limb_type>(v);
|
||||
}
|
||||
BOOST_ASSERT(guess); // If the guess ever gets to zero we go on forever....
|
||||
//
|
||||
// Update result:
|
||||
//
|
||||
limb_type shift = r_order - y_order;
|
||||
if(result)
|
||||
{
|
||||
if(r_neg)
|
||||
{
|
||||
if(pr[shift] > guess)
|
||||
pr[shift] -= guess;
|
||||
else
|
||||
{
|
||||
t.resize(shift + 1, shift + 1);
|
||||
t.limbs()[shift] = guess;
|
||||
for(unsigned i = 0; i < shift; ++i)
|
||||
t.limbs()[i] = 0;
|
||||
eval_subtract(*result, t);
|
||||
}
|
||||
}
|
||||
else if(CppInt1::max_limb_value - pr[shift] > guess)
|
||||
pr[shift] += guess;
|
||||
else
|
||||
{
|
||||
t.resize(shift + 1, shift + 1);
|
||||
t.limbs()[shift] = guess;
|
||||
for(unsigned i = 0; i < shift; ++i)
|
||||
t.limbs()[i] = 0;
|
||||
eval_add(*result, t);
|
||||
}
|
||||
}
|
||||
//
|
||||
// Calculate guess * y, we use a fused mutiply-shift O(N) for this
|
||||
// rather than a full O(N^2) multiply:
|
||||
//
|
||||
double_limb_type carry = 0;
|
||||
t.resize(y.size() + shift + 1, y.size() + shift);
|
||||
bool truncated_t = !CppInt1::variable && (t.size() != y.size() + shift + 1);
|
||||
typename CppInt1::limb_pointer pt = t.limbs();
|
||||
for(unsigned i = 0; i < shift; ++i)
|
||||
pt[i] = 0;
|
||||
for(unsigned i = 0; i < y.size(); ++i)
|
||||
{
|
||||
carry += static_cast<double_limb_type>(py[i]) * static_cast<double_limb_type>(guess);
|
||||
#ifdef __MSVC_RUNTIME_CHECKS
|
||||
pt[i + shift] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
|
||||
#else
|
||||
pt[i + shift] = static_cast<limb_type>(carry);
|
||||
#endif
|
||||
carry >>= CppInt1::limb_bits;
|
||||
}
|
||||
if(carry && !truncated_t)
|
||||
{
|
||||
#ifdef __MSVC_RUNTIME_CHECKS
|
||||
pt[t.size() - 1] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
|
||||
#else
|
||||
pt[t.size() - 1] = static_cast<limb_type>(carry);
|
||||
#endif
|
||||
}
|
||||
else if(!truncated_t)
|
||||
{
|
||||
t.resize(t.size() - 1, t.size() - 1);
|
||||
}
|
||||
//
|
||||
// Update r in a way that won't actually produce a negative result
|
||||
// in case the argument types are unsigned:
|
||||
//
|
||||
if(truncated_t && carry)
|
||||
{
|
||||
// We need to calculate 2^n + t - r
|
||||
// where n is the number of bits in this type.
|
||||
// Simplest way is to get 2^n - r by complementing
|
||||
// r, then add t to it. Note that we can't call eval_complement
|
||||
// in case this is a signed checked type:
|
||||
for(unsigned i = 0; i <= r_order; ++i)
|
||||
r.limbs()[i] = ~prem[i];
|
||||
r.normalize();
|
||||
eval_increment(r);
|
||||
eval_add(r, t);
|
||||
r_neg = !r_neg;
|
||||
}
|
||||
else if(r.compare(t) > 0)
|
||||
{
|
||||
eval_subtract(r, t);
|
||||
}
|
||||
else
|
||||
{
|
||||
r.swap(t);
|
||||
eval_subtract(r, t);
|
||||
prem = r.limbs();
|
||||
r_neg = !r_neg;
|
||||
}
|
||||
//
|
||||
// First time through we need to strip any leading zero, otherwise
|
||||
// the termination condition goes belly-up:
|
||||
//
|
||||
if(result && first_pass)
|
||||
{
|
||||
first_pass = false;
|
||||
while(pr[result->size() - 1] == 0)
|
||||
result->resize(result->size() - 1, result->size() - 1);
|
||||
}
|
||||
//
|
||||
// Update r_order:
|
||||
//
|
||||
r_order = r.size() - 1;
|
||||
if(r_order < y_order)
|
||||
break;
|
||||
}
|
||||
// Termination condition is really just a check that r > y, but with a common
|
||||
// short-circuit case handled first:
|
||||
while((r_order > y_order) || (r.compare_unsigned(y) >= 0));
|
||||
|
||||
//
|
||||
// We now just have to normalise the result:
|
||||
//
|
||||
if(r_neg && eval_get_sign(r))
|
||||
{
|
||||
// We have one too many in the result:
|
||||
if(result)
|
||||
eval_decrement(*result);
|
||||
if(y.sign())
|
||||
{
|
||||
r.negate();
|
||||
eval_subtract(r, y);
|
||||
}
|
||||
else
|
||||
eval_subtract(r, y, r);
|
||||
}
|
||||
|
||||
BOOST_ASSERT(r.compare_unsigned(y) < 0); // remainder must be less than the divisor or our code has failed
|
||||
}
|
||||
|
||||
template <class CppInt1, class CppInt2>
|
||||
void divide_unsigned_helper(
|
||||
CppInt1* result,
|
||||
const CppInt2& x,
|
||||
limb_type y,
|
||||
CppInt1& r)
|
||||
{
|
||||
if(((void*)result == (void*)&x) || ((void*)&r == (void*)&x))
|
||||
{
|
||||
CppInt2 t(x);
|
||||
divide_unsigned_helper(result, t, y, r);
|
||||
return;
|
||||
}
|
||||
|
||||
if(result == &r)
|
||||
{
|
||||
CppInt1 rem;
|
||||
divide_unsigned_helper(result, x, y, rem);
|
||||
r = rem;
|
||||
return;
|
||||
}
|
||||
|
||||
// As above, but simplified for integer divisor:
|
||||
|
||||
using default_ops::eval_subtract;
|
||||
|
||||
if(y == 0)
|
||||
{
|
||||
BOOST_THROW_EXCEPTION(std::overflow_error("Integer Division by zero."));
|
||||
}
|
||||
//
|
||||
// Find the most significant word of numerator.
|
||||
//
|
||||
limb_type r_order = x.size() - 1;
|
||||
|
||||
//
|
||||
// Set remainder and result to their initial values:
|
||||
//
|
||||
r = x;
|
||||
r.sign(false);
|
||||
typename CppInt1::limb_pointer pr = r.limbs();
|
||||
|
||||
//
|
||||
// check for x < y, try to do this without actually having to
|
||||
// do a full comparison:
|
||||
//
|
||||
if((r_order == 0) && (*pr < y))
|
||||
{
|
||||
if(result)
|
||||
*result = static_cast<limb_type>(0u);
|
||||
return;
|
||||
}
|
||||
|
||||
//
|
||||
// See if we can short-circuit long division, and use basic arithmetic instead:
|
||||
//
|
||||
if(r_order == 0)
|
||||
{
|
||||
if(result)
|
||||
{
|
||||
*result = *pr / y;
|
||||
result->sign(x.sign());
|
||||
}
|
||||
*pr %= y;
|
||||
r.sign(x.sign());
|
||||
return;
|
||||
}
|
||||
else if(r_order == 1)
|
||||
{
|
||||
double_limb_type a;
|
||||
a = (static_cast<double_limb_type>(pr[r_order]) << CppInt1::limb_bits) | pr[0];
|
||||
if(result)
|
||||
{
|
||||
*result = a / y;
|
||||
result->sign(x.sign());
|
||||
}
|
||||
r = a % y;
|
||||
r.sign(x.sign());
|
||||
return;
|
||||
}
|
||||
|
||||
// This is initialised just to keep the compiler from emitting useless warnings later on:
|
||||
typename CppInt1::limb_pointer pres = typename CppInt1::limb_pointer();
|
||||
if(result)
|
||||
{
|
||||
result->resize(r_order + 1, r_order + 1);
|
||||
pres = result->limbs();
|
||||
if(result->size() > r_order)
|
||||
pres[r_order] = 0; // just in case we don't set the most significant limb below.
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
//
|
||||
// Calculate our best guess for how many times y divides into r:
|
||||
//
|
||||
if((pr[r_order] < y) && r_order)
|
||||
{
|
||||
double_limb_type a, b;
|
||||
a = (static_cast<double_limb_type>(pr[r_order]) << CppInt1::limb_bits) | pr[r_order - 1];
|
||||
b = a % y;
|
||||
r.resize(r.size() - 1, r.size() - 1);
|
||||
--r_order;
|
||||
pr[r_order] = static_cast<limb_type>(b);
|
||||
if(result)
|
||||
pres[r_order] = static_cast<limb_type>(a / y);
|
||||
if(r_order && pr[r_order] == 0)
|
||||
{
|
||||
--r_order; // No remainder, division was exact.
|
||||
r.resize(r.size() - 1, r.size() - 1);
|
||||
if(result)
|
||||
pres[r_order] = static_cast<limb_type>(0u);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(result)
|
||||
pres[r_order] = pr[r_order] / y;
|
||||
pr[r_order] %= y;
|
||||
if(r_order && pr[r_order] == 0)
|
||||
{
|
||||
--r_order; // No remainder, division was exact.
|
||||
r.resize(r.size() - 1, r.size() - 1);
|
||||
if(result)
|
||||
pres[r_order] = static_cast<limb_type>(0u);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Termination condition is really just a check that r >= y, but with two common
|
||||
// short-circuit cases handled first:
|
||||
while(r_order || (pr[r_order] >= y));
|
||||
|
||||
if(result)
|
||||
{
|
||||
result->normalize();
|
||||
result->sign(x.sign());
|
||||
}
|
||||
r.normalize();
|
||||
r.sign(x.sign());
|
||||
|
||||
BOOST_ASSERT(r.compare(y) < 0); // remainder must be less than the divisor or our code has failed
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, unsigned MinBits3, unsigned MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value >::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
|
||||
const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b)
|
||||
{
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> r;
|
||||
bool s = a.sign() != b.sign();
|
||||
divide_unsigned_helper(&result, a, b, r);
|
||||
result.sign(s);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
|
||||
limb_type& b)
|
||||
{
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> r;
|
||||
bool s = a.sign();
|
||||
divide_unsigned_helper(&result, a, b, r);
|
||||
result.sign(s);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
|
||||
signed_limb_type& b)
|
||||
{
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> r;
|
||||
bool s = a.sign() != (b < 0);
|
||||
divide_unsigned_helper(&result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(b)), r);
|
||||
result.sign(s);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& b)
|
||||
{
|
||||
// There is no in place divide:
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
|
||||
eval_divide(result, a, b);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
limb_type b)
|
||||
{
|
||||
// There is no in place divide:
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
|
||||
eval_divide(result, a, b);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
signed_limb_type b)
|
||||
{
|
||||
// There is no in place divide:
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
|
||||
eval_divide(result, a, b);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, unsigned MinBits3, unsigned MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value >::type
|
||||
eval_modulus(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
|
||||
const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b)
|
||||
{
|
||||
bool s = a.sign();
|
||||
divide_unsigned_helper(static_cast<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>* >(0), a, b, result);
|
||||
result.sign(s);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type
|
||||
eval_modulus(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a, limb_type b)
|
||||
{
|
||||
bool s = a.sign();
|
||||
divide_unsigned_helper(static_cast<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>* >(0), a, b, result);
|
||||
result.sign(s);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type
|
||||
eval_modulus(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
|
||||
signed_limb_type b)
|
||||
{
|
||||
bool s = a.sign();
|
||||
divide_unsigned_helper(static_cast<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>* >(0), a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(b)), result);
|
||||
result.sign(s);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type
|
||||
eval_modulus(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& b)
|
||||
{
|
||||
// There is no in place divide:
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
|
||||
eval_modulus(result, a, b);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
|
||||
eval_modulus(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
limb_type b)
|
||||
{
|
||||
// There is no in place divide:
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
|
||||
eval_modulus(result, a, b);
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
|
||||
eval_modulus(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
signed_limb_type b)
|
||||
{
|
||||
// There is no in place divide:
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
|
||||
eval_modulus(result, a, b);
|
||||
}
|
||||
|
||||
//
|
||||
// Over again for trivial cpp_int's:
|
||||
//
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<
|
||||
is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
&& is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
&& (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
|| is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)
|
||||
>::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o)
|
||||
{
|
||||
if(!*o.limbs())
|
||||
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
|
||||
*result.limbs() /= *o.limbs();
|
||||
result.sign(result.sign() != o.sign());
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<
|
||||
is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
&& is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
&& is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
&& is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
>::type
|
||||
eval_divide(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o)
|
||||
{
|
||||
if(!*o.limbs())
|
||||
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
|
||||
*result.limbs() /= *o.limbs();
|
||||
}
|
||||
|
||||
template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
|
||||
BOOST_MP_FORCEINLINE typename enable_if_c<
|
||||
is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
&& is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value
|
||||
>::type
|
||||
eval_modulus(
|
||||
cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
|
||||
const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o)
|
||||
{
|
||||
if(!*o.limbs())
|
||||
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
|
||||
*result.limbs() %= *o.limbs();
|
||||
result.sign(result.sign());
|
||||
}
|
||||
|
||||
}}} // namespaces
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2014-2015 Kohei Takahashi
|
||||
|
||||
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 FUSION_TUPLE_FORWARD_14122014_0051
|
||||
#define FUSION_TUPLE_FORWARD_14122014_0051
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/container/vector/detail/config.hpp>
|
||||
|
||||
#if !defined(BOOST_FUSION_HAS_VARIADIC_VECTOR) \
|
||||
|| (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
|
||||
# if defined(BOOST_FUSION_HAS_VARIADIC_TUPLE)
|
||||
# undef BOOST_FUSION_HAS_VARIADIC_TUPLE
|
||||
# endif
|
||||
#else
|
||||
# if !defined(BOOST_FUSION_HAS_VARIADIC_TUPLE)
|
||||
# define BOOST_FUSION_HAS_VARIADIC_TUPLE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// With no variadics, we will use the C++03 version
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#if !defined(BOOST_FUSION_HAS_VARIADIC_TUPLE)
|
||||
# include <boost/fusion/tuple/detail/tuple_fwd.hpp>
|
||||
#else
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// C++11 interface
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename ...T>
|
||||
struct tuple;
|
||||
}}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
// (C) Copyright 2009-2011 Frederic Bron.
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License,
|
||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt).
|
||||
//
|
||||
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
|
||||
|
||||
#ifndef BOOST_TT_HAS_DIVIDES_ASSIGN_HPP_INCLUDED
|
||||
#define BOOST_TT_HAS_DIVIDES_ASSIGN_HPP_INCLUDED
|
||||
|
||||
#define BOOST_TT_TRAIT_NAME has_divides_assign
|
||||
#define BOOST_TT_TRAIT_OP /=
|
||||
#define BOOST_TT_FORBIDDEN_IF\
|
||||
(\
|
||||
/* Lhs==fundamental and Lhs==const and Rhs==fundamental */\
|
||||
(\
|
||||
::boost::is_fundamental< Lhs_nocv >::value && \
|
||||
::boost::is_const< Lhs_noref >::value && \
|
||||
::boost::is_fundamental< Rhs_nocv >::value\
|
||||
) || \
|
||||
/* Lhs==pointer and (Rhs==fundamental or Rhs==pointer) */\
|
||||
(\
|
||||
::boost::is_pointer< Lhs_noref >::value && \
|
||||
( \
|
||||
::boost::is_fundamental< Rhs_nocv >::value || \
|
||||
::boost::is_pointer< Rhs_noref >::value\
|
||||
)\
|
||||
)||\
|
||||
/* Rhs==pointer and (Lhs==fundamental or Lhs==pointer) */\
|
||||
(\
|
||||
::boost::is_pointer< Rhs_noref >::value && \
|
||||
( \
|
||||
::boost::is_fundamental< Lhs_nocv >::value || \
|
||||
::boost::is_pointer< Lhs_noref >::value\
|
||||
)\
|
||||
)\
|
||||
)
|
||||
|
||||
|
||||
#include <boost/type_traits/detail/has_binary_operator.hpp>
|
||||
|
||||
#undef BOOST_TT_TRAIT_NAME
|
||||
#undef BOOST_TT_TRAIT_OP
|
||||
#undef BOOST_TT_FORBIDDEN_IF
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,411 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename T0>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0&>
|
||||
tie(T0 & arg0)
|
||||
{
|
||||
return tuple<T0&>(
|
||||
arg0);
|
||||
}
|
||||
template <typename T0 , typename T1>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1&>
|
||||
tie(T0 & arg0 , T1 & arg1)
|
||||
{
|
||||
return tuple<T0& , T1&>(
|
||||
arg0 , arg1);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2)
|
||||
{
|
||||
return tuple<T0& , T1& , T2&>(
|
||||
arg0 , arg1 , arg2);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3&>(
|
||||
arg0 , arg1 , arg2 , arg3);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42 , T43 & arg43)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42 , arg43);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42 , T43 & arg43 , T44 & arg44)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42 , arg43 , arg44);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42 , T43 & arg43 , T44 & arg44 , T45 & arg45)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42 , arg43 , arg44 , arg45);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42 , T43 & arg43 , T44 & arg44 , T45 & arg45 , T46 & arg46)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42 , arg43 , arg44 , arg45 , arg46);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46& , T47&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42 , T43 & arg43 , T44 & arg44 , T45 & arg45 , T46 & arg46 , T47 & arg47)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46& , T47&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42 , arg43 , arg44 , arg45 , arg46 , arg47);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46& , T47& , T48&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42 , T43 & arg43 , T44 & arg44 , T45 & arg45 , T46 & arg46 , T47 & arg47 , T48 & arg48)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46& , T47& , T48&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42 , arg43 , arg44 , arg45 , arg46 , arg47 , arg48);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46& , T47& , T48& , T49&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39 , T40 & arg40 , T41 & arg41 , T42 & arg42 , T43 & arg43 , T44 & arg44 , T45 & arg45 , T46 & arg46 , T47 & arg47 , T48 & arg48 , T49 & arg49)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39& , T40& , T41& , T42& , T43& , T44& , T45& , T46& , T47& , T48& , T49&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39 , arg40 , arg41 , arg42 , arg43 , arg44 , arg45 , arg46 , arg47 , arg48 , arg49);
|
||||
}
|
||||
}}
|
||||
@@ -0,0 +1,120 @@
|
||||
/* Boost interval/rounded_arith.hpp template implementation file
|
||||
*
|
||||
* Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
|
||||
*
|
||||
* 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_INTERVAL_ROUNDED_ARITH_HPP
|
||||
#define BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP
|
||||
|
||||
#include <boost/numeric/interval/rounding.hpp>
|
||||
#include <boost/numeric/interval/detail/bugs.hpp>
|
||||
#include <boost/config/no_tr1/cmath.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace interval_lib {
|
||||
|
||||
/*
|
||||
* Three classes of rounding: exact, std, opp
|
||||
* See documentation for details.
|
||||
*/
|
||||
|
||||
template<class T, class Rounding>
|
||||
struct rounded_arith_exact: Rounding {
|
||||
void init() { }
|
||||
template<class U> T conv_down(U const &v) { return v; }
|
||||
template<class U> T conv_up (U const &v) { return v; }
|
||||
T add_down (const T& x, const T& y) { return x + y; }
|
||||
T add_up (const T& x, const T& y) { return x + y; }
|
||||
T sub_down (const T& x, const T& y) { return x - y; }
|
||||
T sub_up (const T& x, const T& y) { return x - y; }
|
||||
T mul_down (const T& x, const T& y) { return x * y; }
|
||||
T mul_up (const T& x, const T& y) { return x * y; }
|
||||
T div_down (const T& x, const T& y) { return x / y; }
|
||||
T div_up (const T& x, const T& y) { return x / y; }
|
||||
T median (const T& x, const T& y) { return (x + y) / 2; }
|
||||
T sqrt_down(const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); return sqrt(x); }
|
||||
T sqrt_up (const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); return sqrt(x); }
|
||||
T int_down (const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(floor); return floor(x); }
|
||||
T int_up (const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(ceil); return ceil(x); }
|
||||
};
|
||||
|
||||
template<class T, class Rounding>
|
||||
struct rounded_arith_std: Rounding {
|
||||
# define BOOST_DN(EXPR) this->downward(); return this->force_rounding(EXPR)
|
||||
# define BOOST_NR(EXPR) this->to_nearest(); return this->force_rounding(EXPR)
|
||||
# define BOOST_UP(EXPR) this->upward(); return this->force_rounding(EXPR)
|
||||
void init() { }
|
||||
template<class U> T conv_down(U const &v) { BOOST_DN(v); }
|
||||
template<class U> T conv_up (U const &v) { BOOST_UP(v); }
|
||||
T add_down(const T& x, const T& y) { BOOST_DN(x + y); }
|
||||
T sub_down(const T& x, const T& y) { BOOST_DN(x - y); }
|
||||
T mul_down(const T& x, const T& y) { BOOST_DN(x * y); }
|
||||
T div_down(const T& x, const T& y) { BOOST_DN(x / y); }
|
||||
T add_up (const T& x, const T& y) { BOOST_UP(x + y); }
|
||||
T sub_up (const T& x, const T& y) { BOOST_UP(x - y); }
|
||||
T mul_up (const T& x, const T& y) { BOOST_UP(x * y); }
|
||||
T div_up (const T& x, const T& y) { BOOST_UP(x / y); }
|
||||
T median(const T& x, const T& y) { BOOST_NR((x + y) / 2); }
|
||||
T sqrt_down(const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_DN(sqrt(x)); }
|
||||
T sqrt_up (const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_UP(sqrt(x)); }
|
||||
T int_down(const T& x) { this->downward(); return this->to_int(x); }
|
||||
T int_up (const T& x) { this->upward(); return this->to_int(x); }
|
||||
# undef BOOST_DN
|
||||
# undef BOOST_NR
|
||||
# undef BOOST_UP
|
||||
};
|
||||
|
||||
template<class T, class Rounding>
|
||||
struct rounded_arith_opp: Rounding {
|
||||
void init() { this->upward(); }
|
||||
# define BOOST_DN(EXPR) \
|
||||
this->downward(); \
|
||||
T r = this->force_rounding(EXPR); \
|
||||
this->upward(); \
|
||||
return r
|
||||
# define BOOST_NR(EXPR) \
|
||||
this->to_nearest(); \
|
||||
T r = this->force_rounding(EXPR); \
|
||||
this->upward(); \
|
||||
return r
|
||||
# define BOOST_UP(EXPR) return this->force_rounding(EXPR)
|
||||
# define BOOST_UP_NEG(EXPR) return -this->force_rounding(EXPR)
|
||||
template<class U> T conv_down(U const &v) { BOOST_UP_NEG(-v); }
|
||||
template<class U> T conv_up (U const &v) { BOOST_UP(v); }
|
||||
T add_down(const T& x, const T& y) { BOOST_UP_NEG((-x) - y); }
|
||||
T sub_down(const T& x, const T& y) { BOOST_UP_NEG(y - x); }
|
||||
T mul_down(const T& x, const T& y) { BOOST_UP_NEG(x * (-y)); }
|
||||
T div_down(const T& x, const T& y) { BOOST_UP_NEG(x / (-y)); }
|
||||
T add_up (const T& x, const T& y) { BOOST_UP(x + y); }
|
||||
T sub_up (const T& x, const T& y) { BOOST_UP(x - y); }
|
||||
T mul_up (const T& x, const T& y) { BOOST_UP(x * y); }
|
||||
T div_up (const T& x, const T& y) { BOOST_UP(x / y); }
|
||||
T median (const T& x, const T& y) { BOOST_NR((x + y) / 2); }
|
||||
T sqrt_down(const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_DN(sqrt(x)); }
|
||||
T sqrt_up (const T& x)
|
||||
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_UP(sqrt(x)); }
|
||||
T int_down(const T& x) { return -this->to_int(-x); }
|
||||
T int_up (const T& x) { return this->to_int(x); }
|
||||
# undef BOOST_DN
|
||||
# undef BOOST_NR
|
||||
# undef BOOST_UP
|
||||
# undef BOOST_UP_NEG
|
||||
};
|
||||
|
||||
} // namespace interval_lib
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP
|
||||
@@ -0,0 +1,604 @@
|
||||
// (C) Copyright Jeremy Siek 1999-2001.
|
||||
// Copyright (C) 2006 Trustees of Indiana University
|
||||
// Authors: Douglas Gregor and Jeremy Siek
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org/libs/property_map for documentation.
|
||||
|
||||
#ifndef BOOST_PROPERTY_MAP_HPP
|
||||
#define BOOST_PROPERTY_MAP_HPP
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <cstddef>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/concept/assert.hpp>
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/concept_archetype.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
#include <boost/mpl/has_xxx.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
//=========================================================================
|
||||
// property_traits class
|
||||
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(key_type)
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(category)
|
||||
|
||||
template<class PA>
|
||||
struct is_property_map :
|
||||
boost::mpl::and_<
|
||||
has_key_type<PA>,
|
||||
has_value_type<PA>,
|
||||
has_reference<PA>,
|
||||
has_category<PA>
|
||||
>
|
||||
{};
|
||||
|
||||
template <typename PA>
|
||||
struct default_property_traits {
|
||||
typedef typename PA::key_type key_type;
|
||||
typedef typename PA::value_type value_type;
|
||||
typedef typename PA::reference reference;
|
||||
typedef typename PA::category category;
|
||||
};
|
||||
|
||||
struct null_property_traits {};
|
||||
|
||||
template <typename PA>
|
||||
struct property_traits :
|
||||
boost::mpl::if_<is_property_map<PA>,
|
||||
default_property_traits<PA>,
|
||||
null_property_traits>::type
|
||||
{};
|
||||
|
||||
#if 0
|
||||
template <typename PA>
|
||||
struct property_traits {
|
||||
typedef typename PA::key_type key_type;
|
||||
typedef typename PA::value_type value_type;
|
||||
typedef typename PA::reference reference;
|
||||
typedef typename PA::category category;
|
||||
};
|
||||
#endif
|
||||
|
||||
//=========================================================================
|
||||
// property_traits category tags
|
||||
|
||||
namespace detail {
|
||||
enum ePropertyMapID { READABLE_PA, WRITABLE_PA,
|
||||
READ_WRITE_PA, LVALUE_PA, OP_BRACKET_PA,
|
||||
RAND_ACCESS_ITER_PA, LAST_PA };
|
||||
}
|
||||
struct readable_property_map_tag { enum { id = detail::READABLE_PA }; };
|
||||
struct writable_property_map_tag { enum { id = detail::WRITABLE_PA }; };
|
||||
struct read_write_property_map_tag :
|
||||
public readable_property_map_tag,
|
||||
public writable_property_map_tag
|
||||
{ enum { id = detail::READ_WRITE_PA }; };
|
||||
|
||||
struct lvalue_property_map_tag : public read_write_property_map_tag
|
||||
{ enum { id = detail::LVALUE_PA }; };
|
||||
|
||||
//=========================================================================
|
||||
// property_traits specialization for pointers
|
||||
|
||||
template <class T>
|
||||
struct property_traits<T*> {
|
||||
// BOOST_STATIC_ASSERT(boost::is_same<T, T*>::value && !"Using pointers as property maps is deprecated");
|
||||
typedef T value_type;
|
||||
typedef value_type& reference;
|
||||
typedef std::ptrdiff_t key_type;
|
||||
typedef lvalue_property_map_tag category;
|
||||
};
|
||||
template <class T>
|
||||
struct property_traits<const T*> {
|
||||
// BOOST_STATIC_ASSERT(boost::is_same<T, T*>::value && !"Using pointers as property maps is deprecated");
|
||||
typedef T value_type;
|
||||
typedef const value_type& reference;
|
||||
typedef std::ptrdiff_t key_type;
|
||||
typedef lvalue_property_map_tag category;
|
||||
};
|
||||
|
||||
#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
|
||||
// MSVC doesn't have Koenig lookup, so the user has to
|
||||
// do boost::get() anyways, and the using clause
|
||||
// doesn't really work for MSVC.
|
||||
} // namespace boost
|
||||
#endif
|
||||
|
||||
// These need to go in global namespace because Koenig
|
||||
// lookup does not apply to T*.
|
||||
|
||||
// V must be convertible to T
|
||||
template <class T, class V>
|
||||
inline void put(T* pa, std::ptrdiff_t k, const V& val) { pa[k] = val; }
|
||||
|
||||
template <class T>
|
||||
inline const T& get(const T* pa, std::ptrdiff_t k) { return pa[k]; }
|
||||
|
||||
#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
|
||||
namespace boost {
|
||||
using ::put;
|
||||
using ::get;
|
||||
#endif
|
||||
|
||||
//=========================================================================
|
||||
// concept checks for property maps
|
||||
|
||||
template <class PMap, class Key>
|
||||
struct ReadablePropertyMapConcept
|
||||
{
|
||||
typedef typename property_traits<PMap>::key_type key_type;
|
||||
typedef typename property_traits<PMap>::reference reference;
|
||||
typedef typename property_traits<PMap>::category Category;
|
||||
typedef boost::readable_property_map_tag ReadableTag;
|
||||
void constraints() {
|
||||
BOOST_CONCEPT_ASSERT((ConvertibleConcept<Category, ReadableTag>));
|
||||
|
||||
val = get(pmap, k);
|
||||
}
|
||||
PMap pmap;
|
||||
Key k;
|
||||
typename property_traits<PMap>::value_type val;
|
||||
};
|
||||
template <typename KeyArchetype, typename ValueArchetype>
|
||||
struct readable_property_map_archetype {
|
||||
typedef KeyArchetype key_type;
|
||||
typedef ValueArchetype value_type;
|
||||
typedef convertible_to_archetype<ValueArchetype> reference;
|
||||
typedef readable_property_map_tag category;
|
||||
};
|
||||
template <typename K, typename V>
|
||||
const typename readable_property_map_archetype<K,V>::reference&
|
||||
get(const readable_property_map_archetype<K,V>&,
|
||||
const typename readable_property_map_archetype<K,V>::key_type&)
|
||||
{
|
||||
typedef typename readable_property_map_archetype<K,V>::reference R;
|
||||
return static_object<R>::get();
|
||||
}
|
||||
|
||||
|
||||
template <class PMap, class Key>
|
||||
struct WritablePropertyMapConcept
|
||||
{
|
||||
typedef typename property_traits<PMap>::key_type key_type;
|
||||
typedef typename property_traits<PMap>::category Category;
|
||||
typedef boost::writable_property_map_tag WritableTag;
|
||||
void constraints() {
|
||||
BOOST_CONCEPT_ASSERT((ConvertibleConcept<Category, WritableTag>));
|
||||
put(pmap, k, val);
|
||||
}
|
||||
PMap pmap;
|
||||
Key k;
|
||||
typename property_traits<PMap>::value_type val;
|
||||
};
|
||||
template <typename KeyArchetype, typename ValueArchetype>
|
||||
struct writable_property_map_archetype {
|
||||
typedef KeyArchetype key_type;
|
||||
typedef ValueArchetype value_type;
|
||||
typedef void reference;
|
||||
typedef writable_property_map_tag category;
|
||||
};
|
||||
template <typename K, typename V>
|
||||
void put(const writable_property_map_archetype<K,V>&,
|
||||
const typename writable_property_map_archetype<K,V>::key_type&,
|
||||
const typename writable_property_map_archetype<K,V>::value_type&) { }
|
||||
|
||||
|
||||
template <class PMap, class Key>
|
||||
struct ReadWritePropertyMapConcept
|
||||
{
|
||||
typedef typename property_traits<PMap>::category Category;
|
||||
typedef boost::read_write_property_map_tag ReadWriteTag;
|
||||
void constraints() {
|
||||
BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<PMap, Key>));
|
||||
BOOST_CONCEPT_ASSERT((WritablePropertyMapConcept<PMap, Key>));
|
||||
BOOST_CONCEPT_ASSERT((ConvertibleConcept<Category, ReadWriteTag>));
|
||||
}
|
||||
};
|
||||
template <typename KeyArchetype, typename ValueArchetype>
|
||||
struct read_write_property_map_archetype
|
||||
: public readable_property_map_archetype<KeyArchetype, ValueArchetype>,
|
||||
public writable_property_map_archetype<KeyArchetype, ValueArchetype>
|
||||
{
|
||||
typedef KeyArchetype key_type;
|
||||
typedef ValueArchetype value_type;
|
||||
typedef convertible_to_archetype<ValueArchetype> reference;
|
||||
typedef read_write_property_map_tag category;
|
||||
};
|
||||
|
||||
|
||||
template <class PMap, class Key>
|
||||
struct LvaluePropertyMapConcept
|
||||
{
|
||||
typedef typename property_traits<PMap>::category Category;
|
||||
typedef boost::lvalue_property_map_tag LvalueTag;
|
||||
typedef typename property_traits<PMap>::reference reference;
|
||||
|
||||
void constraints() {
|
||||
BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<PMap, Key>));
|
||||
BOOST_CONCEPT_ASSERT((ConvertibleConcept<Category, LvalueTag>));
|
||||
|
||||
typedef typename property_traits<PMap>::value_type value_type;
|
||||
BOOST_MPL_ASSERT((boost::mpl::or_<
|
||||
boost::is_same<const value_type&, reference>,
|
||||
boost::is_same<value_type&, reference> >));
|
||||
|
||||
reference ref = pmap[k];
|
||||
ignore_unused_variable_warning(ref);
|
||||
}
|
||||
PMap pmap;
|
||||
Key k;
|
||||
};
|
||||
template <typename KeyArchetype, typename ValueArchetype>
|
||||
struct lvalue_property_map_archetype
|
||||
: public readable_property_map_archetype<KeyArchetype, ValueArchetype>
|
||||
{
|
||||
typedef KeyArchetype key_type;
|
||||
typedef ValueArchetype value_type;
|
||||
typedef const ValueArchetype& reference;
|
||||
typedef lvalue_property_map_tag category;
|
||||
const value_type& operator[](const key_type&) const {
|
||||
return static_object<value_type>::get();
|
||||
}
|
||||
};
|
||||
|
||||
template <class PMap, class Key>
|
||||
struct Mutable_LvaluePropertyMapConcept
|
||||
{
|
||||
typedef typename property_traits<PMap>::category Category;
|
||||
typedef boost::lvalue_property_map_tag LvalueTag;
|
||||
typedef typename property_traits<PMap>::reference reference;
|
||||
void constraints() {
|
||||
BOOST_CONCEPT_ASSERT((ReadWritePropertyMapConcept<PMap, Key>));
|
||||
BOOST_CONCEPT_ASSERT((ConvertibleConcept<Category, LvalueTag>));
|
||||
|
||||
typedef typename property_traits<PMap>::value_type value_type;
|
||||
BOOST_MPL_ASSERT((boost::is_same<value_type&, reference>));
|
||||
|
||||
reference ref = pmap[k];
|
||||
ignore_unused_variable_warning(ref);
|
||||
}
|
||||
PMap pmap;
|
||||
Key k;
|
||||
};
|
||||
template <typename KeyArchetype, typename ValueArchetype>
|
||||
struct mutable_lvalue_property_map_archetype
|
||||
: public readable_property_map_archetype<KeyArchetype, ValueArchetype>,
|
||||
public writable_property_map_archetype<KeyArchetype, ValueArchetype>
|
||||
{
|
||||
typedef KeyArchetype key_type;
|
||||
typedef ValueArchetype value_type;
|
||||
typedef ValueArchetype& reference;
|
||||
typedef lvalue_property_map_tag category;
|
||||
value_type& operator[](const key_type&) const {
|
||||
return static_object<value_type>::get();
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct typed_identity_property_map;
|
||||
|
||||
// A helper class for constructing a property map
|
||||
// from a class that implements operator[]
|
||||
|
||||
template <class Reference, class LvaluePropertyMap>
|
||||
struct put_get_helper { };
|
||||
|
||||
template <class PropertyMap, class Reference, class K>
|
||||
inline Reference
|
||||
get(const put_get_helper<Reference, PropertyMap>& pa, const K& k)
|
||||
{
|
||||
Reference v = static_cast<const PropertyMap&>(pa)[k];
|
||||
return v;
|
||||
}
|
||||
template <class PropertyMap, class Reference, class K, class V>
|
||||
inline void
|
||||
put(const put_get_helper<Reference, PropertyMap>& pa, K k, const V& v)
|
||||
{
|
||||
static_cast<const PropertyMap&>(pa)[k] = v;
|
||||
}
|
||||
|
||||
//=========================================================================
|
||||
// Adapter to turn a RandomAccessIterator into a property map
|
||||
|
||||
template <class RandomAccessIterator,
|
||||
class IndexMap
|
||||
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
|
||||
, class T, class R
|
||||
#else
|
||||
, class T = typename std::iterator_traits<RandomAccessIterator>::value_type
|
||||
, class R = typename std::iterator_traits<RandomAccessIterator>::reference
|
||||
#endif
|
||||
>
|
||||
class iterator_property_map
|
||||
: public boost::put_get_helper< R,
|
||||
iterator_property_map<RandomAccessIterator, IndexMap,
|
||||
T, R> >
|
||||
{
|
||||
public:
|
||||
typedef typename property_traits<IndexMap>::key_type key_type;
|
||||
typedef T value_type;
|
||||
typedef R reference;
|
||||
typedef boost::lvalue_property_map_tag category;
|
||||
|
||||
inline iterator_property_map(
|
||||
RandomAccessIterator cc = RandomAccessIterator(),
|
||||
const IndexMap& _id = IndexMap() )
|
||||
: iter(cc), index(_id) { }
|
||||
inline R operator[](key_type v) const { return *(iter + get(index, v)) ; }
|
||||
protected:
|
||||
RandomAccessIterator iter;
|
||||
IndexMap index;
|
||||
};
|
||||
|
||||
#if !defined BOOST_NO_STD_ITERATOR_TRAITS
|
||||
template <class RAIter, class ID>
|
||||
inline iterator_property_map<
|
||||
RAIter, ID,
|
||||
typename std::iterator_traits<RAIter>::value_type,
|
||||
typename std::iterator_traits<RAIter>::reference>
|
||||
make_iterator_property_map(RAIter iter, ID id) {
|
||||
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<RAIter>));
|
||||
typedef iterator_property_map<
|
||||
RAIter, ID,
|
||||
typename std::iterator_traits<RAIter>::value_type,
|
||||
typename std::iterator_traits<RAIter>::reference> PA;
|
||||
return PA(iter, id);
|
||||
}
|
||||
#endif
|
||||
template <class RAIter, class Value, class ID>
|
||||
inline iterator_property_map<RAIter, ID, Value, Value&>
|
||||
make_iterator_property_map(RAIter iter, ID id, Value) {
|
||||
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<RAIter>));
|
||||
typedef iterator_property_map<RAIter, ID, Value, Value&> PMap;
|
||||
return PMap(iter, id);
|
||||
}
|
||||
|
||||
template <class RandomAccessIterator,
|
||||
class IndexMap
|
||||
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
|
||||
, class T, class R
|
||||
#else
|
||||
, class T = typename std::iterator_traits<RandomAccessIterator>::value_type
|
||||
, class R = typename std::iterator_traits<RandomAccessIterator>::reference
|
||||
#endif
|
||||
>
|
||||
class safe_iterator_property_map
|
||||
: public boost::put_get_helper< R,
|
||||
safe_iterator_property_map<RandomAccessIterator, IndexMap,
|
||||
T, R> >
|
||||
{
|
||||
public:
|
||||
typedef typename property_traits<IndexMap>::key_type key_type;
|
||||
typedef T value_type;
|
||||
typedef R reference;
|
||||
typedef boost::lvalue_property_map_tag category;
|
||||
|
||||
inline safe_iterator_property_map(
|
||||
RandomAccessIterator first,
|
||||
std::size_t n_ = 0,
|
||||
const IndexMap& _id = IndexMap() )
|
||||
: iter(first), n(n_), index(_id) { }
|
||||
inline safe_iterator_property_map() { }
|
||||
inline R operator[](key_type v) const {
|
||||
BOOST_ASSERT(get(index, v) < n);
|
||||
return *(iter + get(index, v)) ;
|
||||
}
|
||||
typename property_traits<IndexMap>::value_type size() const { return n; }
|
||||
protected:
|
||||
RandomAccessIterator iter;
|
||||
typename property_traits<IndexMap>::value_type n;
|
||||
IndexMap index;
|
||||
};
|
||||
|
||||
template <class RAIter, class ID>
|
||||
inline safe_iterator_property_map<
|
||||
RAIter, ID,
|
||||
typename boost::detail::iterator_traits<RAIter>::value_type,
|
||||
typename boost::detail::iterator_traits<RAIter>::reference>
|
||||
make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id) {
|
||||
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<RAIter>));
|
||||
typedef safe_iterator_property_map<
|
||||
RAIter, ID,
|
||||
typename boost::detail::iterator_traits<RAIter>::value_type,
|
||||
typename boost::detail::iterator_traits<RAIter>::reference> PA;
|
||||
return PA(iter, n, id);
|
||||
}
|
||||
template <class RAIter, class Value, class ID>
|
||||
inline safe_iterator_property_map<RAIter, ID, Value, Value&>
|
||||
make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id, Value) {
|
||||
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<RAIter>));
|
||||
typedef safe_iterator_property_map<RAIter, ID, Value, Value&> PMap;
|
||||
return PMap(iter, n, id);
|
||||
}
|
||||
|
||||
//=========================================================================
|
||||
// An adaptor to turn a Unique Pair Associative Container like std::map or
|
||||
// std::hash_map into an Lvalue Property Map.
|
||||
|
||||
template <typename UniquePairAssociativeContainer>
|
||||
class associative_property_map
|
||||
: public boost::put_get_helper<
|
||||
typename UniquePairAssociativeContainer::value_type::second_type&,
|
||||
associative_property_map<UniquePairAssociativeContainer> >
|
||||
{
|
||||
typedef UniquePairAssociativeContainer C;
|
||||
public:
|
||||
typedef typename C::key_type key_type;
|
||||
typedef typename C::value_type::second_type value_type;
|
||||
typedef value_type& reference;
|
||||
typedef lvalue_property_map_tag category;
|
||||
associative_property_map() : m_c(0) { }
|
||||
associative_property_map(C& c) : m_c(&c) { }
|
||||
reference operator[](const key_type& k) const {
|
||||
return (*m_c)[k];
|
||||
}
|
||||
private:
|
||||
C* m_c;
|
||||
};
|
||||
|
||||
template <class UniquePairAssociativeContainer>
|
||||
associative_property_map<UniquePairAssociativeContainer>
|
||||
make_assoc_property_map(UniquePairAssociativeContainer& c)
|
||||
{
|
||||
return associative_property_map<UniquePairAssociativeContainer>(c);
|
||||
}
|
||||
|
||||
template <typename UniquePairAssociativeContainer>
|
||||
class const_associative_property_map
|
||||
: public boost::put_get_helper<
|
||||
const typename UniquePairAssociativeContainer::value_type::second_type&,
|
||||
const_associative_property_map<UniquePairAssociativeContainer> >
|
||||
{
|
||||
typedef UniquePairAssociativeContainer C;
|
||||
public:
|
||||
typedef typename C::key_type key_type;
|
||||
typedef typename C::value_type::second_type value_type;
|
||||
typedef const value_type& reference;
|
||||
typedef lvalue_property_map_tag category;
|
||||
const_associative_property_map() : m_c(0) { }
|
||||
const_associative_property_map(const C& c) : m_c(&c) { }
|
||||
reference operator[](const key_type& k) const {
|
||||
return m_c->find(k)->second;
|
||||
}
|
||||
private:
|
||||
C const* m_c;
|
||||
};
|
||||
|
||||
template <class UniquePairAssociativeContainer>
|
||||
const_associative_property_map<UniquePairAssociativeContainer>
|
||||
make_assoc_property_map(const UniquePairAssociativeContainer& c)
|
||||
{
|
||||
return const_associative_property_map<UniquePairAssociativeContainer>(c);
|
||||
}
|
||||
|
||||
//=========================================================================
|
||||
// A property map that always returns the same object by value.
|
||||
//
|
||||
template <typename ValueType, typename KeyType = void>
|
||||
class static_property_map :
|
||||
public
|
||||
boost::put_get_helper<ValueType,static_property_map<ValueType> >
|
||||
{
|
||||
ValueType value;
|
||||
public:
|
||||
typedef KeyType key_type;
|
||||
typedef ValueType value_type;
|
||||
typedef ValueType reference;
|
||||
typedef readable_property_map_tag category;
|
||||
static_property_map(ValueType v) : value(v) {}
|
||||
|
||||
template<typename T>
|
||||
inline reference operator[](T) const { return value; }
|
||||
};
|
||||
|
||||
template <typename KeyType, typename ValueType>
|
||||
static_property_map<ValueType, KeyType>
|
||||
make_static_property_map(const ValueType& v) {
|
||||
return static_property_map<ValueType, KeyType>(v);
|
||||
}
|
||||
|
||||
//=========================================================================
|
||||
// A property map that always returns a reference to the same object.
|
||||
//
|
||||
template <typename KeyType, typename ValueType>
|
||||
class ref_property_map :
|
||||
public
|
||||
boost::put_get_helper<ValueType&,ref_property_map<KeyType,ValueType> >
|
||||
{
|
||||
ValueType* value;
|
||||
public:
|
||||
typedef KeyType key_type;
|
||||
typedef ValueType value_type;
|
||||
typedef ValueType& reference;
|
||||
typedef lvalue_property_map_tag category;
|
||||
ref_property_map(ValueType& v) : value(&v) {}
|
||||
ValueType& operator[](key_type const&) const { return *value; }
|
||||
};
|
||||
|
||||
//=========================================================================
|
||||
// A generalized identity property map
|
||||
template <typename T>
|
||||
struct typed_identity_property_map
|
||||
: public boost::put_get_helper<T, typed_identity_property_map<T> >
|
||||
{
|
||||
typedef T key_type;
|
||||
typedef T value_type;
|
||||
typedef T reference;
|
||||
typedef boost::readable_property_map_tag category;
|
||||
|
||||
inline value_type operator[](const key_type& v) const { return v; }
|
||||
};
|
||||
|
||||
//=========================================================================
|
||||
// A property map that applies the identity function to integers
|
||||
typedef typed_identity_property_map<std::size_t> identity_property_map;
|
||||
|
||||
//=========================================================================
|
||||
// A property map that does not do anything, for
|
||||
// when you have to supply a property map, but don't need it.
|
||||
namespace detail {
|
||||
struct dummy_pmap_reference {
|
||||
template <class T>
|
||||
dummy_pmap_reference& operator=(const T&) { return *this; }
|
||||
operator int() { return 0; }
|
||||
};
|
||||
}
|
||||
class dummy_property_map
|
||||
: public boost::put_get_helper<detail::dummy_pmap_reference,
|
||||
dummy_property_map >
|
||||
{
|
||||
public:
|
||||
typedef void key_type;
|
||||
typedef int value_type;
|
||||
typedef detail::dummy_pmap_reference reference;
|
||||
typedef boost::read_write_property_map_tag category;
|
||||
inline dummy_property_map() : c(0) { }
|
||||
inline dummy_property_map(value_type cc) : c(cc) { }
|
||||
inline dummy_property_map(const dummy_property_map& x)
|
||||
: c(x.c) { }
|
||||
template <class Vertex>
|
||||
inline reference operator[](Vertex) const { return reference(); }
|
||||
protected:
|
||||
value_type c;
|
||||
};
|
||||
|
||||
// Convert a Readable property map into a function object
|
||||
template <typename PropMap>
|
||||
class property_map_function {
|
||||
PropMap pm;
|
||||
typedef typename property_traits<PropMap>::key_type param_type;
|
||||
public:
|
||||
explicit property_map_function(const PropMap& pm): pm(pm) {}
|
||||
typedef typename property_traits<PropMap>::value_type result_type;
|
||||
result_type operator()(const param_type& k) const {return get(pm, k);}
|
||||
};
|
||||
|
||||
template <typename PropMap>
|
||||
property_map_function<PropMap>
|
||||
make_property_map_function(const PropMap& pm) {
|
||||
return property_map_function<PropMap>(pm);
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_GRAPH_USE_MPI
|
||||
#include <boost/property_map/parallel/parallel_property_maps.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/property_map/vector_property_map.hpp>
|
||||
|
||||
#endif /* BOOST_PROPERTY_MAP_HPP */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,51 @@
|
||||
|
||||
#ifndef BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED
|
||||
#define BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED
|
||||
|
||||
// Copyright Peter Dimov and Multi Media Ltd 2001, 2002
|
||||
// Copyright David Abrahams 2001
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org/libs/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/aux_/config/gpu.hpp>
|
||||
|
||||
namespace boost { namespace mpl { namespace aux {
|
||||
|
||||
template< typename F >
|
||||
BOOST_MPL_CFG_GPU_ENABLED
|
||||
inline
|
||||
F& unwrap(F& f, long)
|
||||
{
|
||||
return f;
|
||||
}
|
||||
|
||||
template< typename F >
|
||||
BOOST_MPL_CFG_GPU_ENABLED
|
||||
inline
|
||||
F&
|
||||
unwrap(reference_wrapper<F>& f, int)
|
||||
{
|
||||
return f;
|
||||
}
|
||||
|
||||
template< typename F >
|
||||
BOOST_MPL_CFG_GPU_ENABLED
|
||||
inline
|
||||
F&
|
||||
unwrap(reference_wrapper<F> const& f, int)
|
||||
{
|
||||
return f;
|
||||
}
|
||||
|
||||
}}}
|
||||
|
||||
#endif // BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED
|
||||
@@ -0,0 +1,98 @@
|
||||
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
|
||||
// unit/quantity manipulation and conversion
|
||||
//
|
||||
// Copyright (C) 2003-2008 Matthias Christian Schabel
|
||||
// Copyright (C) 2008 Steven Watanabe
|
||||
//
|
||||
// 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_UNITS_CONFIG_HPP
|
||||
#define BOOST_UNITS_CONFIG_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/version.hpp>
|
||||
|
||||
#ifndef BOOST_UNITS_HAS_BOOST_TYPEOF
|
||||
#if (BOOST_VERSION >= 103400)
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_BOOST_TYPEOF 1
|
||||
#else
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_BOOST_TYPEOF 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if (BOOST_UNITS_HAS_BOOST_TYPEOF)
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_TYPEOF 1
|
||||
#else
|
||||
#if (__GNUC__ && __cplusplus)
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_TYPEOF 1
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_GNU_TYPEOF 1
|
||||
#elif defined(__MWERKS__)
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_TYPEOF 1
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_MWERKS_TYPEOF 1
|
||||
#else
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_HAS_TYPEOF 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// uncomment this to test without typeof support at all
|
||||
//#undef BOOST_UNITS_HAS_TYPEOF
|
||||
//#define BOOST_UNITS_HAS_TYPEOF 0
|
||||
|
||||
#ifndef BOOST_UNITS_NO_COMPILER_CHECK
|
||||
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATES
|
||||
#error Boost.Units requires member template
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
|
||||
#error Boost.Units requires member template keyword
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
#error Boost.Units requires in class member initialization
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
#error Boost.Units requires function template partial ordering
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_UNITS_REQUIRE_LAYOUT_COMPATIBILITY
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(a, b) BOOST_STATIC_ASSERT((sizeof(a) == sizeof(b)))
|
||||
#else
|
||||
///INTERNAL ONLY
|
||||
#define BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(a, b) ((void)0)
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_UNITS_DOXYGEN
|
||||
|
||||
/// If defined will trigger a static assertion if quantity<Unit, T>
|
||||
/// is not layout compatible with T
|
||||
#define BOOST_UNITS_REQUIRE_LAYOUT_COMPATIBILITY
|
||||
|
||||
/// If defined will disable a preprocessor check that the
|
||||
/// compiler is able to handle the library.
|
||||
#define BOOST_UNITS_NO_COMPILER_CHECK
|
||||
|
||||
/// Enable checking to verify that a homogeneous system
|
||||
/// is actually capable of representing all the dimensions
|
||||
/// that it is used with. Off by default.
|
||||
#define BOOST_UNITS_CHECK_HOMOGENEOUS_UNITS
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 234 KiB |
@@ -0,0 +1,279 @@
|
||||
// (C) Copyright Gennadiy Rozental 2001.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org/libs/test for the library home page.
|
||||
//
|
||||
// File : $RCSfile$
|
||||
//
|
||||
// Version : $Revision$
|
||||
//
|
||||
// Description : implements Unit Test results collecting facility.
|
||||
// ***************************************************************************
|
||||
|
||||
#ifndef BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
|
||||
#define BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
|
||||
|
||||
// Boost.Test
|
||||
#include <boost/test/unit_test_log.hpp>
|
||||
#include <boost/test/results_collector.hpp>
|
||||
#include <boost/test/framework.hpp>
|
||||
|
||||
#include <boost/test/tree/test_unit.hpp>
|
||||
#include <boost/test/tree/visitor.hpp>
|
||||
#include <boost/test/tree/test_case_counter.hpp>
|
||||
#include <boost/test/tree/traverse.hpp>
|
||||
|
||||
// Boost
|
||||
#include <boost/cstdlib.hpp>
|
||||
|
||||
// STL
|
||||
#include <map>
|
||||
|
||||
#include <boost/test/detail/suppress_warnings.hpp>
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
namespace boost {
|
||||
namespace unit_test {
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** test_results ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
test_results::test_results()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
bool
|
||||
test_results::passed() const
|
||||
{
|
||||
return !p_skipped &&
|
||||
p_test_cases_failed == 0 &&
|
||||
p_assertions_failed <= p_expected_failures &&
|
||||
p_test_cases_skipped == 0 &&
|
||||
!p_aborted;
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
int
|
||||
test_results::result_code() const
|
||||
{
|
||||
return passed() ? exit_success
|
||||
: ( (p_assertions_failed > p_expected_failures || p_skipped )
|
||||
? exit_test_failure
|
||||
: exit_exception_failure );
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
test_results::operator+=( test_results const& tr )
|
||||
{
|
||||
p_assertions_passed.value += tr.p_assertions_passed;
|
||||
p_assertions_failed.value += tr.p_assertions_failed;
|
||||
p_warnings_failed.value += tr.p_warnings_failed;
|
||||
p_test_cases_passed.value += tr.p_test_cases_passed;
|
||||
p_test_cases_warned.value += tr.p_test_cases_warned;
|
||||
p_test_cases_failed.value += tr.p_test_cases_failed;
|
||||
p_test_cases_skipped.value += tr.p_test_cases_skipped;
|
||||
p_test_cases_aborted.value += tr.p_test_cases_aborted;
|
||||
p_duration_microseconds.value += tr.p_duration_microseconds;
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
test_results::clear()
|
||||
{
|
||||
p_assertions_passed.value = 0;
|
||||
p_assertions_failed.value = 0;
|
||||
p_warnings_failed.value = 0;
|
||||
p_expected_failures.value = 0;
|
||||
p_test_cases_passed.value = 0;
|
||||
p_test_cases_warned.value = 0;
|
||||
p_test_cases_failed.value = 0;
|
||||
p_test_cases_skipped.value = 0;
|
||||
p_test_cases_aborted.value = 0;
|
||||
p_duration_microseconds.value= 0;
|
||||
p_aborted.value = false;
|
||||
p_skipped.value = false;
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** results_collector ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
namespace {
|
||||
|
||||
struct results_collector_impl {
|
||||
std::map<test_unit_id,test_results> m_results_store;
|
||||
};
|
||||
|
||||
results_collector_impl& s_rc_impl() { static results_collector_impl the_inst; return the_inst; }
|
||||
|
||||
} // local namespace
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
results_collector_t::test_start( counter_t )
|
||||
{
|
||||
s_rc_impl().m_results_store.clear();
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
results_collector_t::test_unit_start( test_unit const& tu )
|
||||
{
|
||||
// init test_results entry
|
||||
test_results& tr = s_rc_impl().m_results_store[tu.p_id];
|
||||
|
||||
tr.clear();
|
||||
|
||||
tr.p_expected_failures.value = tu.p_expected_failures;
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
class results_collect_helper : public test_tree_visitor {
|
||||
public:
|
||||
explicit results_collect_helper( test_results& tr, test_unit const& ts ) : m_tr( tr ), m_ts( ts ) {}
|
||||
|
||||
void visit( test_case const& tc )
|
||||
{
|
||||
test_results const& tr = results_collector.results( tc.p_id );
|
||||
m_tr += tr;
|
||||
|
||||
if( tr.passed() ) {
|
||||
if( tr.p_warnings_failed )
|
||||
m_tr.p_test_cases_warned.value++;
|
||||
else
|
||||
m_tr.p_test_cases_passed.value++;
|
||||
}
|
||||
else if( tr.p_skipped )
|
||||
m_tr.p_test_cases_skipped.value++;
|
||||
else {
|
||||
if( tr.p_aborted )
|
||||
m_tr.p_test_cases_aborted.value++;
|
||||
|
||||
m_tr.p_test_cases_failed.value++;
|
||||
}
|
||||
}
|
||||
bool test_suite_start( test_suite const& ts )
|
||||
{
|
||||
if( m_ts.p_id == ts.p_id )
|
||||
return true;
|
||||
|
||||
m_tr += results_collector.results( ts.p_id );
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
// Data members
|
||||
test_results& m_tr;
|
||||
test_unit const& m_ts;
|
||||
};
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
results_collector_t::test_unit_finish( test_unit const& tu, unsigned long elapsed_in_microseconds )
|
||||
{
|
||||
if( tu.p_type == TUT_SUITE ) {
|
||||
results_collect_helper ch( s_rc_impl().m_results_store[tu.p_id], tu );
|
||||
|
||||
traverse_test_tree( tu, ch );
|
||||
}
|
||||
else {
|
||||
test_results & tr = s_rc_impl().m_results_store[tu.p_id];
|
||||
tr.p_duration_microseconds.value = elapsed_in_microseconds;
|
||||
|
||||
bool num_failures_match = tr.p_aborted || tr.p_assertions_failed >= tr.p_expected_failures;
|
||||
if( !num_failures_match )
|
||||
BOOST_TEST_FRAMEWORK_MESSAGE( "Test case " << tu.full_name() << " has fewer failures than expected" );
|
||||
|
||||
bool check_any_assertions = tr.p_aborted || (tr.p_assertions_failed != 0) || (tr.p_assertions_passed != 0);
|
||||
if( !check_any_assertions )
|
||||
BOOST_TEST_FRAMEWORK_MESSAGE( "Test case " << tu.full_name() << " did not check any assertions" );
|
||||
}
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
results_collector_t::test_unit_skipped( test_unit const& tu, const_string /*reason*/ )
|
||||
{
|
||||
test_results& tr = s_rc_impl().m_results_store[tu.p_id];
|
||||
|
||||
tr.clear();
|
||||
|
||||
tr.p_skipped.value = true;
|
||||
|
||||
if( tu.p_type == TUT_SUITE ) {
|
||||
test_case_counter tcc;
|
||||
traverse_test_tree( tu, tcc );
|
||||
|
||||
tr.p_test_cases_skipped.value = tcc.p_count;
|
||||
}
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
results_collector_t::assertion_result( unit_test::assertion_result ar )
|
||||
{
|
||||
test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
|
||||
|
||||
switch( ar ) {
|
||||
case AR_PASSED: tr.p_assertions_passed.value++; break;
|
||||
case AR_FAILED: tr.p_assertions_failed.value++; break;
|
||||
case AR_TRIGGERED: tr.p_warnings_failed.value++; break;
|
||||
}
|
||||
|
||||
if( tr.p_assertions_failed == 1 )
|
||||
first_failed_assertion();
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
results_collector_t::exception_caught( execution_exception const& )
|
||||
{
|
||||
test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
|
||||
|
||||
tr.p_assertions_failed.value++;
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
void
|
||||
results_collector_t::test_unit_aborted( test_unit const& tu )
|
||||
{
|
||||
s_rc_impl().m_results_store[tu.p_id].p_aborted.value = true;
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
test_results const&
|
||||
results_collector_t::results( test_unit_id id ) const
|
||||
{
|
||||
return s_rc_impl().m_results_store[id];
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
} // namespace unit_test
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/test/detail/enable_warnings.hpp>
|
||||
|
||||
#endif // BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
|
||||
Reference in New Issue
Block a user