Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,45 @@
|
||||
/*=============================================================================
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(FUSION_FRONT_09162005_0343)
|
||||
#define FUSION_FRONT_09162005_0343
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/begin.hpp>
|
||||
#include <boost/fusion/iterator/deref.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct fusion_sequence_tag;
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct front
|
||||
: result_of::deref<typename result_of::begin<Sequence>::type>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::front<Sequence>::type
|
||||
front(Sequence& seq)
|
||||
{
|
||||
return *fusion::begin(seq);
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::front<Sequence const>::type
|
||||
front(Sequence const& seq)
|
||||
{
|
||||
return *fusion::begin(seq);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,53 @@
|
||||
/*=============================================================================
|
||||
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_BACK_EXTENDED_DEQUE_26112006_2209)
|
||||
#define BOOST_FUSION_BACK_EXTENDED_DEQUE_26112006_2209
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
|
||||
#include <boost/fusion/sequence/intrinsic/size.hpp>
|
||||
#include <boost/fusion/support/sequence_base.hpp>
|
||||
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename Deque, typename T>
|
||||
struct back_extended_deque
|
||||
: detail::keyed_element<typename Deque::next_up, T, Deque>
|
||||
, sequence_base<back_extended_deque<Deque, T> >
|
||||
{
|
||||
typedef detail::keyed_element<typename Deque::next_up, T, Deque> base;
|
||||
typedef typename Deque::next_down next_down;
|
||||
typedef mpl::int_<(Deque::next_up::value + 1)> next_up;
|
||||
typedef mpl::int_<(result_of::size<Deque>::value + 1)> size;
|
||||
|
||||
template <typename Arg>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
back_extended_deque(Deque const& deque, Arg const& val)
|
||||
: base(val, deque)
|
||||
{}
|
||||
|
||||
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename Arg>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
back_extended_deque(Deque const& deque, Arg& val)
|
||||
: base(val, deque)
|
||||
{}
|
||||
#else
|
||||
template <typename Arg>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
back_extended_deque(Deque const& deque, Arg&& val)
|
||||
: base(BOOST_FUSION_FWD_ELEM(Arg, val), deque)
|
||||
{}
|
||||
#endif
|
||||
};
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,328 @@
|
||||
// (C) Copyright John Maddock 2006.
|
||||
// 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)
|
||||
|
||||
//
|
||||
// This is not a complete header file, it is included by beta.hpp
|
||||
// after it has defined it's definitions. This inverts the incomplete
|
||||
// beta functions ibeta and ibetac on the first parameters "a"
|
||||
// and "b" using a generic root finding algorithm (TOMS Algorithm 748).
|
||||
//
|
||||
|
||||
#ifndef BOOST_MATH_SP_DETAIL_BETA_INV_AB
|
||||
#define BOOST_MATH_SP_DETAIL_BETA_INV_AB
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/math/tools/toms748_solve.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
namespace boost{ namespace math{ namespace detail{
|
||||
|
||||
template <class T, class Policy>
|
||||
struct beta_inv_ab_t
|
||||
{
|
||||
beta_inv_ab_t(T b_, T z_, T p_, bool invert_, bool swap_ab_) : b(b_), z(z_), p(p_), invert(invert_), swap_ab(swap_ab_) {}
|
||||
T operator()(T a)
|
||||
{
|
||||
return invert ?
|
||||
p - boost::math::ibetac(swap_ab ? b : a, swap_ab ? a : b, z, Policy())
|
||||
: boost::math::ibeta(swap_ab ? b : a, swap_ab ? a : b, z, Policy()) - p;
|
||||
}
|
||||
private:
|
||||
T b, z, p;
|
||||
bool invert, swap_ab;
|
||||
};
|
||||
|
||||
template <class T, class Policy>
|
||||
T inverse_negative_binomial_cornish_fisher(T n, T sf, T sfc, T p, T q, const Policy& pol)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
// mean:
|
||||
T m = n * (sfc) / sf;
|
||||
T t = sqrt(n * (sfc));
|
||||
// standard deviation:
|
||||
T sigma = t / sf;
|
||||
// skewness
|
||||
T sk = (1 + sfc) / t;
|
||||
// kurtosis:
|
||||
T k = (6 - sf * (5+sfc)) / (n * (sfc));
|
||||
// Get the inverse of a std normal distribution:
|
||||
T x = boost::math::erfc_inv(p > q ? 2 * q : 2 * p, pol) * constants::root_two<T>();
|
||||
// Set the sign:
|
||||
if(p < 0.5)
|
||||
x = -x;
|
||||
T x2 = x * x;
|
||||
// w is correction term due to skewness
|
||||
T w = x + sk * (x2 - 1) / 6;
|
||||
//
|
||||
// Add on correction due to kurtosis.
|
||||
//
|
||||
if(n >= 10)
|
||||
w += k * x * (x2 - 3) / 24 + sk * sk * x * (2 * x2 - 5) / -36;
|
||||
|
||||
w = m + sigma * w;
|
||||
if(w < tools::min_value<T>())
|
||||
return tools::min_value<T>();
|
||||
return w;
|
||||
}
|
||||
|
||||
template <class T, class Policy>
|
||||
T ibeta_inv_ab_imp(const T& b, const T& z, const T& p, const T& q, bool swap_ab, const Policy& pol)
|
||||
{
|
||||
BOOST_MATH_STD_USING // for ADL of std lib math functions
|
||||
//
|
||||
// Special cases first:
|
||||
//
|
||||
BOOST_MATH_INSTRUMENT_CODE("b = " << b << " z = " << z << " p = " << p << " q = " << " swap = " << swap_ab);
|
||||
if(p == 0)
|
||||
{
|
||||
return swap_ab ? tools::min_value<T>() : tools::max_value<T>();
|
||||
}
|
||||
if(q == 0)
|
||||
{
|
||||
return swap_ab ? tools::max_value<T>() : tools::min_value<T>();
|
||||
}
|
||||
//
|
||||
// Function object, this is the functor whose root
|
||||
// we have to solve:
|
||||
//
|
||||
beta_inv_ab_t<T, Policy> f(b, z, (p < q) ? p : q, (p < q) ? false : true, swap_ab);
|
||||
//
|
||||
// Tolerance: full precision.
|
||||
//
|
||||
tools::eps_tolerance<T> tol(policies::digits<T, Policy>());
|
||||
//
|
||||
// Now figure out a starting guess for what a may be,
|
||||
// we'll start out with a value that'll put p or q
|
||||
// right bang in the middle of their range, the functions
|
||||
// are quite sensitive so we should need too many steps
|
||||
// to bracket the root from there:
|
||||
//
|
||||
T guess = 0;
|
||||
T factor = 5;
|
||||
//
|
||||
// Convert variables to parameters of a negative binomial distribution:
|
||||
//
|
||||
T n = b;
|
||||
T sf = swap_ab ? z : 1-z;
|
||||
T sfc = swap_ab ? 1-z : z;
|
||||
T u = swap_ab ? p : q;
|
||||
T v = swap_ab ? q : p;
|
||||
if(u <= pow(sf, n))
|
||||
{
|
||||
//
|
||||
// Result is less than 1, negative binomial approximation
|
||||
// is useless....
|
||||
//
|
||||
if((p < q) != swap_ab)
|
||||
{
|
||||
guess = (std::min)(T(b * 2), T(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
guess = (std::min)(T(b / 2), T(1));
|
||||
}
|
||||
}
|
||||
if(n * n * n * u * sf > 0.005)
|
||||
guess = 1 + inverse_negative_binomial_cornish_fisher(n, sf, sfc, u, v, pol);
|
||||
|
||||
if(guess < 10)
|
||||
{
|
||||
//
|
||||
// Negative binomial approximation not accurate in this area:
|
||||
//
|
||||
if((p < q) != swap_ab)
|
||||
{
|
||||
guess = (std::min)(T(b * 2), T(10));
|
||||
}
|
||||
else
|
||||
{
|
||||
guess = (std::min)(T(b / 2), T(10));
|
||||
}
|
||||
}
|
||||
else
|
||||
factor = (v < sqrt(tools::epsilon<T>())) ? 2 : (guess < 20 ? 1.2f : 1.1f);
|
||||
BOOST_MATH_INSTRUMENT_CODE("guess = " << guess);
|
||||
//
|
||||
// Max iterations permitted:
|
||||
//
|
||||
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
|
||||
std::pair<T, T> r = bracket_and_solve_root(f, guess, factor, swap_ab ? true : false, tol, max_iter, pol);
|
||||
if(max_iter >= policies::get_max_root_iterations<Policy>())
|
||||
return policies::raise_evaluation_error<T>("boost::math::ibeta_invab_imp<%1%>(%1%,%1%,%1%)", "Unable to locate the root within a reasonable number of iterations, closest approximation so far was %1%", r.first, pol);
|
||||
return (r.first + r.second) / 2;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class RT1, class RT2, class RT3, class Policy>
|
||||
typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibeta_inva(RT1 b, RT2 x, RT3 p, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
|
||||
typedef typename policies::evaluation<result_type, Policy>::type value_type;
|
||||
typedef typename policies::normalise<
|
||||
Policy,
|
||||
policies::promote_float<false>,
|
||||
policies::promote_double<false>,
|
||||
policies::discrete_quantile<>,
|
||||
policies::assert_undefined<> >::type forwarding_policy;
|
||||
|
||||
static const char* function = "boost::math::ibeta_inva<%1%>(%1%,%1%,%1%)";
|
||||
if(p == 0)
|
||||
{
|
||||
return policies::raise_overflow_error<result_type>(function, 0, Policy());
|
||||
}
|
||||
if(p == 1)
|
||||
{
|
||||
return tools::min_value<result_type>();
|
||||
}
|
||||
|
||||
return policies::checked_narrowing_cast<result_type, forwarding_policy>(
|
||||
detail::ibeta_inv_ab_imp(
|
||||
static_cast<value_type>(b),
|
||||
static_cast<value_type>(x),
|
||||
static_cast<value_type>(p),
|
||||
static_cast<value_type>(1 - static_cast<value_type>(p)),
|
||||
false, pol),
|
||||
function);
|
||||
}
|
||||
|
||||
template <class RT1, class RT2, class RT3, class Policy>
|
||||
typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibetac_inva(RT1 b, RT2 x, RT3 q, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
|
||||
typedef typename policies::evaluation<result_type, Policy>::type value_type;
|
||||
typedef typename policies::normalise<
|
||||
Policy,
|
||||
policies::promote_float<false>,
|
||||
policies::promote_double<false>,
|
||||
policies::discrete_quantile<>,
|
||||
policies::assert_undefined<> >::type forwarding_policy;
|
||||
|
||||
static const char* function = "boost::math::ibetac_inva<%1%>(%1%,%1%,%1%)";
|
||||
if(q == 1)
|
||||
{
|
||||
return policies::raise_overflow_error<result_type>(function, 0, Policy());
|
||||
}
|
||||
if(q == 0)
|
||||
{
|
||||
return tools::min_value<result_type>();
|
||||
}
|
||||
|
||||
return policies::checked_narrowing_cast<result_type, forwarding_policy>(
|
||||
detail::ibeta_inv_ab_imp(
|
||||
static_cast<value_type>(b),
|
||||
static_cast<value_type>(x),
|
||||
static_cast<value_type>(1 - static_cast<value_type>(q)),
|
||||
static_cast<value_type>(q),
|
||||
false, pol),
|
||||
function);
|
||||
}
|
||||
|
||||
template <class RT1, class RT2, class RT3, class Policy>
|
||||
typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibeta_invb(RT1 a, RT2 x, RT3 p, const Policy& pol)
|
||||
{
|
||||
typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
|
||||
typedef typename policies::evaluation<result_type, Policy>::type value_type;
|
||||
typedef typename policies::normalise<
|
||||
Policy,
|
||||
policies::promote_float<false>,
|
||||
policies::promote_double<false>,
|
||||
policies::discrete_quantile<>,
|
||||
policies::assert_undefined<> >::type forwarding_policy;
|
||||
|
||||
static const char* function = "boost::math::ibeta_invb<%1%>(%1%,%1%,%1%)";
|
||||
if(p == 0)
|
||||
{
|
||||
return tools::min_value<result_type>();
|
||||
}
|
||||
if(p == 1)
|
||||
{
|
||||
return policies::raise_overflow_error<result_type>(function, 0, Policy());
|
||||
}
|
||||
|
||||
return policies::checked_narrowing_cast<result_type, forwarding_policy>(
|
||||
detail::ibeta_inv_ab_imp(
|
||||
static_cast<value_type>(a),
|
||||
static_cast<value_type>(x),
|
||||
static_cast<value_type>(p),
|
||||
static_cast<value_type>(1 - static_cast<value_type>(p)),
|
||||
true, pol),
|
||||
function);
|
||||
}
|
||||
|
||||
template <class RT1, class RT2, class RT3, class Policy>
|
||||
typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibetac_invb(RT1 a, RT2 x, RT3 q, const Policy& pol)
|
||||
{
|
||||
static const char* function = "boost::math::ibeta_invb<%1%>(%1%, %1%, %1%)";
|
||||
typedef typename tools::promote_args<RT1, RT2, RT3>::type result_type;
|
||||
typedef typename policies::evaluation<result_type, Policy>::type value_type;
|
||||
typedef typename policies::normalise<
|
||||
Policy,
|
||||
policies::promote_float<false>,
|
||||
policies::promote_double<false>,
|
||||
policies::discrete_quantile<>,
|
||||
policies::assert_undefined<> >::type forwarding_policy;
|
||||
|
||||
if(q == 1)
|
||||
{
|
||||
return tools::min_value<result_type>();
|
||||
}
|
||||
if(q == 0)
|
||||
{
|
||||
return policies::raise_overflow_error<result_type>(function, 0, Policy());
|
||||
}
|
||||
|
||||
return policies::checked_narrowing_cast<result_type, forwarding_policy>(
|
||||
detail::ibeta_inv_ab_imp(
|
||||
static_cast<value_type>(a),
|
||||
static_cast<value_type>(x),
|
||||
static_cast<value_type>(1 - static_cast<value_type>(q)),
|
||||
static_cast<value_type>(q),
|
||||
true, pol),
|
||||
function);
|
||||
}
|
||||
|
||||
template <class RT1, class RT2, class RT3>
|
||||
inline typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibeta_inva(RT1 b, RT2 x, RT3 p)
|
||||
{
|
||||
return boost::math::ibeta_inva(b, x, p, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class RT1, class RT2, class RT3>
|
||||
inline typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibetac_inva(RT1 b, RT2 x, RT3 q)
|
||||
{
|
||||
return boost::math::ibetac_inva(b, x, q, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class RT1, class RT2, class RT3>
|
||||
inline typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibeta_invb(RT1 a, RT2 x, RT3 p)
|
||||
{
|
||||
return boost::math::ibeta_invb(a, x, p, policies::policy<>());
|
||||
}
|
||||
|
||||
template <class RT1, class RT2, class RT3>
|
||||
inline typename tools::promote_args<RT1, RT2, RT3>::type
|
||||
ibetac_invb(RT1 a, RT2 x, RT3 q)
|
||||
{
|
||||
return boost::math::ibetac_invb(a, x, q, policies::policy<>());
|
||||
}
|
||||
|
||||
} // namespace math
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_MATH_SP_DETAIL_BETA_INV_AB
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
// (C) Copyright John Maddock 2001 - 2003.
|
||||
// (C) Copyright Jens Maurer 2001 - 2003.
|
||||
// (C) Copyright David Abrahams 2002.
|
||||
// (C) Copyright Toon Knapen 2003.
|
||||
// (C) Copyright Boris Gubenko 2006 - 2007.
|
||||
// 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 for most recent version.
|
||||
|
||||
// hpux specific config options:
|
||||
|
||||
#define BOOST_PLATFORM "HP-UX"
|
||||
|
||||
// In principle, HP-UX has a nice <stdint.h> under the name <inttypes.h>
|
||||
// However, it has the following problem:
|
||||
// Use of UINT32_C(0) results in "0u l" for the preprocessed source
|
||||
// (verifyable with gcc 2.95.3)
|
||||
#if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__HP_aCC)
|
||||
# define BOOST_HAS_STDINT_H
|
||||
#endif
|
||||
|
||||
#if !(defined(__HP_aCC) || !defined(_INCLUDE__STDC_A1_SOURCE))
|
||||
# define BOOST_NO_SWPRINTF
|
||||
#endif
|
||||
#if defined(__HP_aCC) && !defined(_INCLUDE__STDC_A1_SOURCE)
|
||||
# define BOOST_NO_CWCTYPE
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__)
|
||||
# if (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))
|
||||
// GNU C on HP-UX does not support threads (checked up to gcc 3.3)
|
||||
# define BOOST_DISABLE_THREADS
|
||||
# elif !defined(BOOST_DISABLE_THREADS)
|
||||
// threads supported from gcc-3.3 onwards:
|
||||
# define BOOST_HAS_THREADS
|
||||
# define BOOST_HAS_PTHREADS
|
||||
# endif
|
||||
#elif defined(__HP_aCC) && !defined(BOOST_DISABLE_THREADS)
|
||||
# define BOOST_HAS_PTHREADS
|
||||
#endif
|
||||
|
||||
// boilerplate code:
|
||||
#define BOOST_HAS_UNISTD_H
|
||||
#include <boost/config/posix_features.hpp>
|
||||
|
||||
// the following are always available:
|
||||
#ifndef BOOST_HAS_GETTIMEOFDAY
|
||||
# define BOOST_HAS_GETTIMEOFDAY
|
||||
#endif
|
||||
#ifndef BOOST_HAS_SCHED_YIELD
|
||||
# define BOOST_HAS_SCHED_YIELD
|
||||
#endif
|
||||
#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
|
||||
# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
|
||||
#endif
|
||||
#ifndef BOOST_HAS_NL_TYPES_H
|
||||
# define BOOST_HAS_NL_TYPES_H
|
||||
#endif
|
||||
#ifndef BOOST_HAS_NANOSLEEP
|
||||
# define BOOST_HAS_NANOSLEEP
|
||||
#endif
|
||||
#ifndef BOOST_HAS_GETTIMEOFDAY
|
||||
# define BOOST_HAS_GETTIMEOFDAY
|
||||
#endif
|
||||
#ifndef BOOST_HAS_DIRENT_H
|
||||
# define BOOST_HAS_DIRENT_H
|
||||
#endif
|
||||
#ifndef BOOST_HAS_CLOCK_GETTIME
|
||||
# define BOOST_HAS_CLOCK_GETTIME
|
||||
#endif
|
||||
#ifndef BOOST_HAS_SIGACTION
|
||||
# define BOOST_HAS_SIGACTION
|
||||
#endif
|
||||
#ifndef BOOST_HAS_NRVO
|
||||
# ifndef __parisc
|
||||
# define BOOST_HAS_NRVO
|
||||
# endif
|
||||
#endif
|
||||
#ifndef BOOST_HAS_LOG1P
|
||||
# define BOOST_HAS_LOG1P
|
||||
#endif
|
||||
#ifndef BOOST_HAS_EXPM1
|
||||
# define BOOST_HAS_EXPM1
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,428 @@
|
||||
// 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) 2007-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_HETEROGENEOUS_SYSTEM_HPP
|
||||
#define BOOST_UNITS_HETEROGENEOUS_SYSTEM_HPP
|
||||
|
||||
/// \file
|
||||
/// \brief A heterogeneous system is a sorted list of base unit/exponent pairs.
|
||||
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/plus.hpp>
|
||||
#include <boost/mpl/times.hpp>
|
||||
#include <boost/mpl/divides.hpp>
|
||||
#include <boost/mpl/negate.hpp>
|
||||
#include <boost/mpl/less.hpp>
|
||||
#include <boost/mpl/size.hpp>
|
||||
#include <boost/mpl/begin.hpp>
|
||||
#include <boost/mpl/next.hpp>
|
||||
#include <boost/mpl/deref.hpp>
|
||||
#include <boost/mpl/front.hpp>
|
||||
#include <boost/mpl/push_front.hpp>
|
||||
#include <boost/mpl/pop_front.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
|
||||
#include <boost/units/config.hpp>
|
||||
#include <boost/units/static_rational.hpp>
|
||||
#include <boost/units/dimension.hpp>
|
||||
#include <boost/units/units_fwd.hpp>
|
||||
#include <boost/units/detail/push_front_if.hpp>
|
||||
#include <boost/units/detail/push_front_or_add.hpp>
|
||||
#include <boost/units/detail/linear_algebra.hpp>
|
||||
#include <boost/units/detail/unscale.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace detail {
|
||||
|
||||
// A normal system is a sorted list of base units.
|
||||
// A heterogeneous system is a sorted list of base unit/exponent pairs.
|
||||
// As long as we don't need to convert heterogeneous systems
|
||||
// directly everything is cool.
|
||||
|
||||
template<class T>
|
||||
struct is_zero : mpl::false_ {};
|
||||
|
||||
template<>
|
||||
struct is_zero<static_rational<0> > : mpl::true_ {};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class L, class Dimensions, class Scale>
|
||||
struct heterogeneous_system_impl
|
||||
{
|
||||
typedef L type;
|
||||
typedef Dimensions dimensions;
|
||||
typedef Scale scale;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
typedef dimensionless_type no_scale;
|
||||
|
||||
/// A system that can represent any possible combination
|
||||
/// of units at the expense of not preserving information
|
||||
/// about how it was created. Do not create specializations
|
||||
/// of this template directly. Instead use @c reduce_unit and
|
||||
/// @c base_unit<...>::unit_type.
|
||||
template<class T>
|
||||
struct heterogeneous_system : T {};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
struct heterogeneous_system_dim_tag {};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class Unit, class Exponent>
|
||||
struct heterogeneous_system_dim
|
||||
{
|
||||
typedef heterogeneous_system_dim_tag tag;
|
||||
typedef heterogeneous_system_dim type;
|
||||
typedef Unit tag_type;
|
||||
typedef Exponent value_type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
#define BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(BaseUnit, Dimensions) \
|
||||
boost::units::unit< \
|
||||
Dimensions, \
|
||||
boost::units::heterogeneous_system< \
|
||||
boost::units::heterogeneous_system_impl< \
|
||||
boost::units::list< \
|
||||
boost::units::heterogeneous_system_dim< \
|
||||
BaseUnit, \
|
||||
boost::units::static_rational<1> \
|
||||
>, \
|
||||
boost::units::dimensionless_type \
|
||||
>, \
|
||||
Dimensions, \
|
||||
boost::units::no_scale \
|
||||
> \
|
||||
> \
|
||||
>
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#if BOOST_UNITS_HAS_BOOST_TYPEOF
|
||||
|
||||
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_impl, (class)(class)(class))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system, (class))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::heterogeneous_system_dim, (class)(class))
|
||||
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace mpl {
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<>
|
||||
struct less_impl<boost::units::heterogeneous_system_dim_tag, boost::units::heterogeneous_system_dim_tag>
|
||||
{
|
||||
template<class T0, class T1>
|
||||
struct apply : mpl::less<typename T0::tag_type, typename T1::tag_type> {};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class Unit1, class Exponent1>
|
||||
struct is_empty_dim<heterogeneous_system_dim<Unit1,Exponent1> > : detail::is_zero<Exponent1> {};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace units
|
||||
|
||||
namespace mpl {
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<>
|
||||
struct plus_impl<boost::units::heterogeneous_system_dim_tag, boost::units::heterogeneous_system_dim_tag>
|
||||
{
|
||||
template<class T0, class T1>
|
||||
struct apply
|
||||
{
|
||||
typedef boost::units::heterogeneous_system_dim<
|
||||
typename T0::tag_type,
|
||||
typename mpl::plus<typename T0::value_type,typename T1::value_type>::type
|
||||
> type;
|
||||
};
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<>
|
||||
struct times_impl<boost::units::heterogeneous_system_dim_tag, boost::units::detail::static_rational_tag>
|
||||
{
|
||||
template<class T0, class T1>
|
||||
struct apply
|
||||
{
|
||||
typedef boost::units::heterogeneous_system_dim<
|
||||
typename T0::tag_type,
|
||||
typename mpl::times<typename T0::value_type,T1>::type
|
||||
> type;
|
||||
};
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<>
|
||||
struct divides_impl<boost::units::heterogeneous_system_dim_tag, boost::units::detail::static_rational_tag>
|
||||
{
|
||||
template<class T0, class T1>
|
||||
struct apply
|
||||
{
|
||||
typedef boost::units::heterogeneous_system_dim<
|
||||
typename T0::tag_type,
|
||||
typename mpl::divides<typename T0::value_type,T1>::type
|
||||
> type;
|
||||
};
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<>
|
||||
struct negate_impl<boost::units::heterogeneous_system_dim_tag>
|
||||
{
|
||||
template<class T>
|
||||
struct apply
|
||||
{
|
||||
typedef boost::units::heterogeneous_system_dim<typename T::tag_type, typename mpl::negate<typename T::value_type>::type> type;
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace mpl
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<int N>
|
||||
struct make_heterogeneous_system_impl
|
||||
{
|
||||
template<class UnitsBegin, class ExponentsBegin>
|
||||
struct apply
|
||||
{
|
||||
typedef typename push_front_if<!(is_zero<typename ExponentsBegin::item>::value)>::template apply<
|
||||
typename make_heterogeneous_system_impl<N-1>::template apply<
|
||||
typename UnitsBegin::next,
|
||||
typename ExponentsBegin::next
|
||||
>::type,
|
||||
heterogeneous_system_dim<typename UnitsBegin::item, typename ExponentsBegin::item>
|
||||
>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct make_heterogeneous_system_impl<0>
|
||||
{
|
||||
template<class UnitsBegin, class ExponentsBegin>
|
||||
struct apply
|
||||
{
|
||||
typedef dimensionless_type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<class Dimensions, class System>
|
||||
struct make_heterogeneous_system
|
||||
{
|
||||
typedef typename calculate_base_unit_exponents<typename System::type, Dimensions>::type exponents;
|
||||
BOOST_MPL_ASSERT_MSG((!boost::is_same<exponents, inconsistent>::value), the_specified_dimension_is_not_representible_in_the_given_system, (types<Dimensions, System>));
|
||||
typedef typename make_heterogeneous_system_impl<System::type::size::value>::template apply<
|
||||
typename System::type,
|
||||
exponents
|
||||
>::type unit_list;
|
||||
typedef heterogeneous_system<heterogeneous_system_impl<unit_list, Dimensions, no_scale> > type;
|
||||
};
|
||||
|
||||
template<class Dimensions, class T>
|
||||
struct make_heterogeneous_system<Dimensions, heterogeneous_system<T> >
|
||||
{
|
||||
typedef heterogeneous_system<T> type;
|
||||
};
|
||||
|
||||
template<class T0, class T1>
|
||||
struct multiply_systems
|
||||
{
|
||||
typedef heterogeneous_system<
|
||||
heterogeneous_system_impl<
|
||||
typename mpl::times<typename T0::type, typename T1::type>::type,
|
||||
typename mpl::times<typename T0::dimensions, typename T1::dimensions>::type,
|
||||
typename mpl::times<typename T0::scale, typename T1::scale>::type
|
||||
>
|
||||
> type;
|
||||
};
|
||||
|
||||
template<class T0, class T1>
|
||||
struct divide_systems
|
||||
{
|
||||
typedef heterogeneous_system<
|
||||
heterogeneous_system_impl<
|
||||
typename mpl::divides<typename T0::type, typename T1::type>::type,
|
||||
typename mpl::divides<typename T0::dimensions, typename T1::dimensions>::type,
|
||||
typename mpl::divides<typename T0::scale, typename T1::scale>::type
|
||||
>
|
||||
> type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class S, long N, long D>
|
||||
struct static_power<heterogeneous_system<S>, static_rational<N,D> >
|
||||
{
|
||||
typedef heterogeneous_system<
|
||||
heterogeneous_system_impl<
|
||||
typename static_power<typename S::type, static_rational<N,D> >::type,
|
||||
typename static_power<typename S::dimensions, static_rational<N,D> >::type,
|
||||
typename static_power<typename S::scale, static_rational<N,D> >::type
|
||||
>
|
||||
> type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class S, long N, long D>
|
||||
struct static_root<heterogeneous_system<S>, static_rational<N,D> >
|
||||
{
|
||||
typedef heterogeneous_system<
|
||||
heterogeneous_system_impl<
|
||||
typename static_root<typename S::type, static_rational<N,D> >::type,
|
||||
typename static_root<typename S::dimensions, static_rational<N,D> >::type,
|
||||
typename static_root<typename S::scale, static_rational<N,D> >::type
|
||||
>
|
||||
> type;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<int N>
|
||||
struct unscale_heterogeneous_system_impl
|
||||
{
|
||||
template<class Begin>
|
||||
struct apply
|
||||
{
|
||||
typedef typename push_front_or_add<
|
||||
typename unscale_heterogeneous_system_impl<N-1>::template apply<
|
||||
typename Begin::next
|
||||
>::type,
|
||||
typename unscale<typename Begin::item>::type
|
||||
>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct unscale_heterogeneous_system_impl<0>
|
||||
{
|
||||
template<class Begin>
|
||||
struct apply
|
||||
{
|
||||
typedef dimensionless_type type;
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/// Unscale all the base units. e.g
|
||||
/// km s -> m s
|
||||
/// cm km -> m^2
|
||||
/// INTERNAL ONLY
|
||||
template<class T>
|
||||
struct unscale<heterogeneous_system<T> >
|
||||
{
|
||||
typedef heterogeneous_system<
|
||||
heterogeneous_system_impl<
|
||||
typename detail::unscale_heterogeneous_system_impl<
|
||||
T::type::size::value
|
||||
>::template apply<
|
||||
typename T::type
|
||||
>::type,
|
||||
typename T::dimensions,
|
||||
no_scale
|
||||
>
|
||||
> type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class Unit, class Exponent>
|
||||
struct unscale<heterogeneous_system_dim<Unit, Exponent> >
|
||||
{
|
||||
typedef heterogeneous_system_dim<typename unscale<Unit>::type, Exponent> type;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<int N>
|
||||
struct get_scale_list_of_heterogeneous_system_impl
|
||||
{
|
||||
template<class Begin>
|
||||
struct apply
|
||||
{
|
||||
typedef typename mpl::times<
|
||||
typename get_scale_list_of_heterogeneous_system_impl<N-1>::template apply<
|
||||
typename Begin::next
|
||||
>::type,
|
||||
typename get_scale_list<typename Begin::item>::type
|
||||
>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct get_scale_list_of_heterogeneous_system_impl<0>
|
||||
{
|
||||
template<class Begin>
|
||||
struct apply
|
||||
{
|
||||
typedef dimensionless_type type;
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class T>
|
||||
struct get_scale_list<heterogeneous_system<T> >
|
||||
{
|
||||
typedef typename mpl::times<
|
||||
typename detail::get_scale_list_of_heterogeneous_system_impl<
|
||||
T::type::size::value
|
||||
>::template apply<typename T::type>::type,
|
||||
typename T::scale
|
||||
>::type type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class Unit, class Exponent>
|
||||
struct get_scale_list<heterogeneous_system_dim<Unit, Exponent> >
|
||||
{
|
||||
typedef typename static_power<typename get_scale_list<Unit>::type, Exponent>::type type;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class System, class Dimension>
|
||||
struct check_system : mpl::false_ {};
|
||||
|
||||
template<class System, class Dimension, class Scale>
|
||||
struct check_system<heterogeneous_system<heterogeneous_system_impl<System, Dimension, Scale> >, Dimension> : mpl::true_ {};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,367 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// funop.hpp
|
||||
// Contains definition of funop[n]\<\> class template.
|
||||
//
|
||||
// Copyright 2008 Eric Niebler. Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
template<typename Expr, typename Domain >
|
||||
struct funop0
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list1<
|
||||
Expr &
|
||||
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename This, typename Domain>
|
||||
struct funop<Expr(), This, Domain>
|
||||
: funop0<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0>
|
||||
struct funop1
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list2<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0, typename This, typename Domain>
|
||||
struct funop<Expr(A0), This, Domain>
|
||||
: funop1<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1>
|
||||
struct funop2
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list3<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1), This, Domain>
|
||||
: funop2<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2>
|
||||
struct funop3
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list4<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2), This, Domain>
|
||||
: funop3<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct funop4
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list5<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3), This, Domain>
|
||||
: funop4<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct funop5
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list6<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4), This, Domain>
|
||||
: funop5<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct funop6
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list7<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5), This, Domain>
|
||||
: funop6<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct funop7
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list8<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6), This, Domain>
|
||||
: funop7<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct funop8
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list9<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), This, Domain>
|
||||
: funop8<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct funop9
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list10<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type , typename proto::result_of::as_child<A8, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
BOOST_FORCEINLINE
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) , proto::as_child<Domain>(a8)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), This, Domain>
|
||||
: funop9<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type
|
||||
>
|
||||
{};
|
||||
@@ -0,0 +1,257 @@
|
||||
/* boost random/uniform_01.hpp header file
|
||||
*
|
||||
* Copyright Jens Maurer 2000-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 for most recent version including documentation.
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Revision history
|
||||
* 2001-02-18 moved to individual header files
|
||||
*/
|
||||
|
||||
#ifndef BOOST_RANDOM_UNIFORM_01_HPP
|
||||
#define BOOST_RANDOM_UNIFORM_01_HPP
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/random/detail/config.hpp>
|
||||
#include <boost/random/detail/ptr_helper.hpp>
|
||||
|
||||
#include <boost/random/detail/disable_warnings.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace random {
|
||||
|
||||
#ifdef BOOST_RANDOM_DOXYGEN
|
||||
|
||||
/**
|
||||
* The distribution function uniform_01 models a \random_distribution.
|
||||
* On each invocation, it returns a random floating-point value
|
||||
* uniformly distributed in the range [0..1).
|
||||
*
|
||||
* The template parameter RealType shall denote a float-like value type
|
||||
* with support for binary operators +, -, and /.
|
||||
*
|
||||
* Note: The current implementation is buggy, because it may not fill
|
||||
* all of the mantissa with random bits. I'm unsure how to fill a
|
||||
* (to-be-invented) @c boost::bigfloat class with random bits efficiently.
|
||||
* It's probably time for a traits class.
|
||||
*/
|
||||
template<class RealType = double>
|
||||
class uniform_01
|
||||
{
|
||||
public:
|
||||
typedef RealType input_type;
|
||||
typedef RealType result_type;
|
||||
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const;
|
||||
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const;
|
||||
void reset();
|
||||
|
||||
template<class Engine>
|
||||
result_type operator()(Engine& eng);
|
||||
|
||||
#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_ostream<CharT,Traits>&
|
||||
operator<<(std::basic_ostream<CharT,Traits>& os, const new_uniform_01&)
|
||||
{
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_istream<CharT,Traits>&
|
||||
operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&)
|
||||
{
|
||||
return is;
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class RealType>
|
||||
class new_uniform_01
|
||||
{
|
||||
public:
|
||||
typedef RealType input_type;
|
||||
typedef RealType result_type;
|
||||
// compiler-generated copy ctor and copy assignment are fine
|
||||
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); }
|
||||
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); }
|
||||
void reset() { }
|
||||
|
||||
template<class Engine>
|
||||
result_type operator()(Engine& eng) {
|
||||
for (;;) {
|
||||
typedef typename Engine::result_type base_result;
|
||||
result_type factor = result_type(1) /
|
||||
(result_type(base_result((eng.max)()-(eng.min)())) +
|
||||
result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0));
|
||||
result_type result = result_type(base_result(eng() - (eng.min)())) * factor;
|
||||
if (result < result_type(1))
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_ostream<CharT,Traits>&
|
||||
operator<<(std::basic_ostream<CharT,Traits>& os, const new_uniform_01&)
|
||||
{
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_istream<CharT,Traits>&
|
||||
operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&)
|
||||
{
|
||||
return is;
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
template<class UniformRandomNumberGenerator, class RealType>
|
||||
class backward_compatible_uniform_01
|
||||
{
|
||||
typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits;
|
||||
public:
|
||||
typedef UniformRandomNumberGenerator base_type;
|
||||
typedef RealType result_type;
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
|
||||
|
||||
#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
|
||||
BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
|
||||
#endif
|
||||
|
||||
explicit backward_compatible_uniform_01(typename traits::rvalue_type rng)
|
||||
: _rng(rng),
|
||||
_factor(result_type(1) /
|
||||
(result_type((base().max)()-(base().min)()) +
|
||||
result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0)))
|
||||
{
|
||||
}
|
||||
// compiler-generated copy ctor and copy assignment are fine
|
||||
|
||||
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); }
|
||||
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); }
|
||||
typename traits::value_type& base() { return traits::ref(_rng); }
|
||||
const typename traits::value_type& base() const { return traits::ref(_rng); }
|
||||
void reset() { }
|
||||
|
||||
result_type operator()() {
|
||||
for (;;) {
|
||||
result_type result = result_type(base()() - (base().min)()) * _factor;
|
||||
if (result < result_type(1))
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_ostream<CharT,Traits>&
|
||||
operator<<(std::basic_ostream<CharT,Traits>& os, const backward_compatible_uniform_01& u)
|
||||
{
|
||||
os << u._rng;
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_istream<CharT,Traits>&
|
||||
operator>>(std::basic_istream<CharT,Traits>& is, backward_compatible_uniform_01& u)
|
||||
{
|
||||
is >> u._rng;
|
||||
return is;
|
||||
}
|
||||
#endif
|
||||
|
||||
private:
|
||||
typedef typename traits::value_type::result_type base_result;
|
||||
UniformRandomNumberGenerator _rng;
|
||||
result_type _factor;
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
// A definition is required even for integral static constants
|
||||
template<class UniformRandomNumberGenerator, class RealType>
|
||||
const bool backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType>::has_fixed_range;
|
||||
#endif
|
||||
|
||||
template<class UniformRandomNumberGenerator, bool is_number = std::numeric_limits<UniformRandomNumberGenerator>::is_specialized>
|
||||
struct select_uniform_01
|
||||
{
|
||||
template<class RealType>
|
||||
struct apply
|
||||
{
|
||||
typedef backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType> type;
|
||||
};
|
||||
};
|
||||
|
||||
template<class Num>
|
||||
struct select_uniform_01<Num, true>
|
||||
{
|
||||
template<class RealType>
|
||||
struct apply
|
||||
{
|
||||
typedef new_uniform_01<Num> type;
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// Because it is so commonly used: uniform distribution on the real [0..1)
|
||||
// range. This allows for specializations to avoid a costly int -> float
|
||||
// conversion plus float multiplication
|
||||
template<class UniformRandomNumberGenerator = double, class RealType = double>
|
||||
class uniform_01
|
||||
: public detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type
|
||||
{
|
||||
typedef typename detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type impl_type;
|
||||
typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits;
|
||||
public:
|
||||
|
||||
uniform_01() {}
|
||||
|
||||
explicit uniform_01(typename traits::rvalue_type rng)
|
||||
: impl_type(rng)
|
||||
{
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_ostream<CharT,Traits>&
|
||||
operator<<(std::basic_ostream<CharT,Traits>& os, const uniform_01& u)
|
||||
{
|
||||
os << static_cast<const impl_type&>(u);
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_istream<CharT,Traits>&
|
||||
operator>>(std::basic_istream<CharT,Traits>& is, uniform_01& u)
|
||||
{
|
||||
is >> static_cast<impl_type&>(u);
|
||||
return is;
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace random
|
||||
|
||||
using random::uniform_01;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/random/detail/enable_warnings.hpp>
|
||||
|
||||
#endif // BOOST_RANDOM_UNIFORM_01_HPP
|
||||
@@ -0,0 +1,22 @@
|
||||
/*=============================================================================
|
||||
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 FUSION_MAX_DEQUE_SIZE <= 10
|
||||
#include <boost/fusion/container/generation/detail/preprocessed/make_deque10.hpp>
|
||||
#elif FUSION_MAX_DEQUE_SIZE <= 20
|
||||
#include <boost/fusion/container/generation/detail/preprocessed/make_deque20.hpp>
|
||||
#elif FUSION_MAX_DEQUE_SIZE <= 30
|
||||
#include <boost/fusion/container/generation/detail/preprocessed/make_deque30.hpp>
|
||||
#elif FUSION_MAX_DEQUE_SIZE <= 40
|
||||
#include <boost/fusion/container/generation/detail/preprocessed/make_deque40.hpp>
|
||||
#elif FUSION_MAX_DEQUE_SIZE <= 50
|
||||
#include <boost/fusion/container/generation/detail/preprocessed/make_deque50.hpp>
|
||||
#else
|
||||
#error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
|
||||
#endif
|
||||
@@ -0,0 +1,820 @@
|
||||
/*=============================================================================
|
||||
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
|
||||
{
|
||||
struct void_;
|
||||
namespace result_of
|
||||
{
|
||||
template <
|
||||
typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ , typename T20 = void_ , typename T21 = void_ , typename T22 = void_ , typename T23 = void_ , typename T24 = void_ , typename T25 = void_ , typename T26 = void_ , typename T27 = void_ , typename T28 = void_ , typename T29 = void_ , typename T30 = void_ , typename T31 = void_ , typename T32 = void_ , typename T33 = void_ , typename T34 = void_ , typename T35 = void_ , typename T36 = void_ , typename T37 = void_ , typename T38 = void_ , typename T39 = void_ , typename T40 = void_ , typename T41 = void_ , typename T42 = void_ , typename T43 = void_ , typename T44 = void_ , typename T45 = void_ , typename T46 = void_ , typename T47 = void_ , typename T48 = void_ , typename T49 = void_
|
||||
, typename Extra = void_
|
||||
>
|
||||
struct vector_tie;
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0>
|
||||
struct vector_tie< T0 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0&>
|
||||
vector_tie(T0 & arg0)
|
||||
{
|
||||
return vector<T0&>(
|
||||
arg0);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1>
|
||||
struct vector_tie< T0 , T1 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1)
|
||||
{
|
||||
return vector<T0& , T1&>(
|
||||
arg0 , arg1);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
struct vector_tie< T0 , T1 , T2 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2)
|
||||
{
|
||||
return vector<T0& , T1& , T2&>(
|
||||
arg0 , arg1 , arg2);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3&>(
|
||||
arg0 , arg1 , arg2 , arg3);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>
|
||||
vector_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 vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
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>
|
||||
struct vector_tie< 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 , void_ >
|
||||
{
|
||||
typedef vector<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&> type;
|
||||
};
|
||||
}
|
||||
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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<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&>
|
||||
vector_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 vector<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,40 @@
|
||||
subroutine slope(y,npts,xpk)
|
||||
|
||||
! Remove best-fit slope from data in y(i). When fitting the straight line,
|
||||
! ignore the peak around xpk +/- 2 bins
|
||||
|
||||
real y(npts)
|
||||
|
||||
sumw=0.
|
||||
sumx=0.
|
||||
sumy=0.
|
||||
sumx2=0.
|
||||
sumxy=0.
|
||||
sumy2=0.
|
||||
do i=1,npts
|
||||
if(abs(i-xpk).gt.2.0) then
|
||||
sumw=sumw + 1.0
|
||||
x=i
|
||||
sumx=sumx + x
|
||||
sumy=sumy + y(i)
|
||||
sumx2=sumx2 + x*x
|
||||
sumxy=sumxy + x*y(i)
|
||||
sumy2=sumy2 + y(i)**2
|
||||
endif
|
||||
enddo
|
||||
|
||||
delta=sumw*sumx2 - sumx**2
|
||||
a=(sumx2*sumy - sumx*sumxy) / delta
|
||||
b=(sumw*sumxy - sumx*sumy) / delta
|
||||
|
||||
sq=0.
|
||||
do i=1,npts
|
||||
y(i)=y(i)-(a + b*i)
|
||||
if(abs(i-xpk).gt.2.0) sq=sq + y(i)**2
|
||||
enddo
|
||||
rms=sqrt(sq/(sumw-2.0))
|
||||
y=y/rms
|
||||
|
||||
return
|
||||
end subroutine slope
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
#ifndef DATE_ITERATOR_HPP___
|
||||
#define DATE_ITERATOR_HPP___
|
||||
|
||||
/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
|
||||
* Use, modification and distribution is 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)
|
||||
* Author: Jeff Garland, Bart Garst
|
||||
* $Date$
|
||||
*/
|
||||
|
||||
#include <iterator>
|
||||
|
||||
namespace boost {
|
||||
namespace date_time {
|
||||
//! An iterator over dates with varying resolution (day, week, month, year, etc)
|
||||
enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
|
||||
|
||||
//! Base date iterator type
|
||||
/*! This class provides the skeleton for the creation of iterators.
|
||||
* New and interesting interators can be created by plugging in a new
|
||||
* function that derives the next value from the current state.
|
||||
* generation of various types of -based information.
|
||||
*
|
||||
* <b>Template Parameters</b>
|
||||
*
|
||||
* <b>date_type</b>
|
||||
*
|
||||
* The date_type is a concrete date_type. The date_type must
|
||||
* define a duration_type and a calendar_type.
|
||||
*/
|
||||
template<class date_type>
|
||||
class date_itr_base {
|
||||
// works, but benefit unclear at the moment
|
||||
// class date_itr_base : public std::iterator<std::input_iterator_tag,
|
||||
// date_type, void, void, void>{
|
||||
public:
|
||||
typedef typename date_type::duration_type duration_type;
|
||||
typedef date_type value_type;
|
||||
typedef std::input_iterator_tag iterator_category;
|
||||
|
||||
date_itr_base(date_type d) : current_(d) {}
|
||||
virtual ~date_itr_base() {}
|
||||
date_itr_base& operator++()
|
||||
{
|
||||
current_ = current_ + get_offset(current_);
|
||||
return *this;
|
||||
}
|
||||
date_itr_base& operator--()
|
||||
{
|
||||
current_ = current_ + get_neg_offset(current_);
|
||||
return *this;
|
||||
}
|
||||
virtual duration_type get_offset(const date_type& current) const=0;
|
||||
virtual duration_type get_neg_offset(const date_type& current) const=0;
|
||||
date_type operator*() {return current_;}
|
||||
date_type* operator->() {return ¤t_;}
|
||||
bool operator< (const date_type& d) {return current_ < d;}
|
||||
bool operator<= (const date_type& d) {return current_ <= d;}
|
||||
bool operator> (const date_type& d) {return current_ > d;}
|
||||
bool operator>= (const date_type& d) {return current_ >= d;}
|
||||
bool operator== (const date_type& d) {return current_ == d;}
|
||||
bool operator!= (const date_type& d) {return current_ != d;}
|
||||
private:
|
||||
date_type current_;
|
||||
};
|
||||
|
||||
//! Overrides the base date iterator providing hook for functors
|
||||
/*
|
||||
* <b>offset_functor</b>
|
||||
*
|
||||
* The offset functor must define a get_offset function that takes the
|
||||
* current point in time and calculates and offset.
|
||||
*
|
||||
*/
|
||||
template<class offset_functor, class date_type>
|
||||
class date_itr : public date_itr_base<date_type> {
|
||||
public:
|
||||
typedef typename date_type::duration_type duration_type;
|
||||
date_itr(date_type d, int factor=1) :
|
||||
date_itr_base<date_type>(d),
|
||||
of_(factor)
|
||||
{}
|
||||
private:
|
||||
virtual duration_type get_offset(const date_type& current) const
|
||||
{
|
||||
return of_.get_offset(current);
|
||||
}
|
||||
virtual duration_type get_neg_offset(const date_type& current) const
|
||||
{
|
||||
return of_.get_neg_offset(current);
|
||||
}
|
||||
offset_functor of_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
} } //namespace date_time
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,238 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2006-2014. 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/move for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_MOVE_MAKE_UNIQUE_HPP_INCLUDED
|
||||
#define BOOST_MOVE_MAKE_UNIQUE_HPP_INCLUDED
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
# include <boost/config.hpp>
|
||||
#endif
|
||||
#
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/move/detail/config_begin.hpp>
|
||||
#include <boost/move/detail/workaround.hpp>
|
||||
#include <boost/move/utility_core.hpp>
|
||||
#include <boost/move/unique_ptr.hpp>
|
||||
#include <cstddef> //for std::size_t
|
||||
#include <boost/move/detail/unique_ptr_meta_utils.hpp>
|
||||
#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
|
||||
# include <boost/move/detail/fwd_macros.hpp>
|
||||
#endif
|
||||
|
||||
//!\file
|
||||
//! Defines "make_unique" functions, which are factories to create instances
|
||||
//! of unique_ptr depending on the passed arguments.
|
||||
//!
|
||||
//! This header can be a bit heavyweight in C++03 compilers due to the use of the
|
||||
//! preprocessor library, that's why it's a a separate header from <tt>unique_ptr.hpp</tt>
|
||||
|
||||
#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
|
||||
|
||||
namespace std { //no namespace versioning in clang+libc++
|
||||
|
||||
struct nothrow_t;
|
||||
|
||||
} //namespace std {
|
||||
|
||||
namespace boost{
|
||||
namespace move_upmu {
|
||||
|
||||
//Compile time switch between
|
||||
//single element, unknown bound array
|
||||
//and known bound array
|
||||
template<class T>
|
||||
struct unique_ptr_if
|
||||
{
|
||||
typedef ::boost::movelib::unique_ptr<T> t_is_not_array;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct unique_ptr_if<T[]>
|
||||
{
|
||||
typedef ::boost::movelib::unique_ptr<T[]> t_is_array_of_unknown_bound;
|
||||
};
|
||||
|
||||
template<class T, std::size_t N>
|
||||
struct unique_ptr_if<T[N]>
|
||||
{
|
||||
typedef void t_is_array_of_known_bound;
|
||||
};
|
||||
|
||||
template <int Dummy = 0>
|
||||
struct nothrow_holder
|
||||
{
|
||||
static std::nothrow_t *pnothrow;
|
||||
};
|
||||
|
||||
template <int Dummy>
|
||||
std::nothrow_t *nothrow_holder<Dummy>::pnothrow =
|
||||
reinterpret_cast<std::nothrow_t *>(0x1234); //Avoid reference to null errors in sanitizers
|
||||
|
||||
} //namespace move_upmu {
|
||||
} //namespace boost{
|
||||
|
||||
#endif //!defined(BOOST_MOVE_DOXYGEN_INVOKED)
|
||||
|
||||
namespace boost{
|
||||
namespace movelib {
|
||||
|
||||
#if defined(BOOST_MOVE_DOXYGEN_INVOKED) || !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new T(std::forward<Args>(args)...))</tt>.
|
||||
template<class T, class... Args>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array)
|
||||
make_unique(BOOST_FWD_REF(Args)... args)
|
||||
{ return unique_ptr<T>(new T(::boost::forward<Args>(args)...)); }
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new T(std::nothrow)(std::forward<Args>(args)...))</tt>.
|
||||
template<class T, class... Args>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array)
|
||||
make_unique_nothrow(BOOST_FWD_REF(Args)... args)
|
||||
{ return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)T(::boost::forward<Args>(args)...)); }
|
||||
|
||||
#else
|
||||
#define BOOST_MOVE_MAKE_UNIQUE_CODE(N)\
|
||||
template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array\
|
||||
make_unique( BOOST_MOVE_UREF##N)\
|
||||
{ return unique_ptr<T>( new T( BOOST_MOVE_FWD##N ) ); }\
|
||||
\
|
||||
template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array\
|
||||
make_unique_nothrow( BOOST_MOVE_UREF##N)\
|
||||
{ return unique_ptr<T>( new (*boost::move_upmu::nothrow_holder<>::pnothrow)T ( BOOST_MOVE_FWD##N ) ); }\
|
||||
//
|
||||
BOOST_MOVE_ITERATE_0TO9(BOOST_MOVE_MAKE_UNIQUE_CODE)
|
||||
#undef BOOST_MOVE_MAKE_UNIQUE_CODE
|
||||
|
||||
#endif
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new T)</tt> (default initialization)
|
||||
template<class T>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array)
|
||||
make_unique_definit()
|
||||
{
|
||||
return unique_ptr<T>(new T);
|
||||
}
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is not an array.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new T(std::nothrow)</tt> (default initialization)
|
||||
template<class T>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array)
|
||||
make_unique_nothrow_definit()
|
||||
{
|
||||
return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)T);
|
||||
}
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of
|
||||
//! unknown bound.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new remove_extent_t<T>[n]())</tt> (value initialization)
|
||||
template<class T>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound)
|
||||
make_unique(std::size_t n)
|
||||
{
|
||||
typedef typename ::boost::move_upmu::remove_extent<T>::type U;
|
||||
return unique_ptr<T>(new U[n]());
|
||||
}
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of
|
||||
//! unknown bound.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new (std::nothrow)remove_extent_t<T>[n]())</tt> (value initialization)
|
||||
template<class T>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound)
|
||||
make_unique_nothrow(std::size_t n)
|
||||
{
|
||||
typedef typename ::boost::move_upmu::remove_extent<T>::type U;
|
||||
return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)U[n]());
|
||||
}
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of
|
||||
//! unknown bound.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new remove_extent_t<T>[n])</tt> (default initialization)
|
||||
template<class T>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound)
|
||||
make_unique_definit(std::size_t n)
|
||||
{
|
||||
typedef typename ::boost::move_upmu::remove_extent<T>::type U;
|
||||
return unique_ptr<T>(new U[n]);
|
||||
}
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is an array of
|
||||
//! unknown bound.
|
||||
//!
|
||||
//! <b>Returns</b>: <tt>unique_ptr<T>(new (std::nothrow)remove_extent_t<T>[n])</tt> (default initialization)
|
||||
template<class T>
|
||||
inline BOOST_MOVE_DOC1ST(unique_ptr<T>,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound)
|
||||
make_unique_nothrow_definit(std::size_t n)
|
||||
{
|
||||
typedef typename ::boost::move_upmu::remove_extent<T>::type U;
|
||||
return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow) U[n]);
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is
|
||||
//! an array of known bound.
|
||||
template<class T, class... Args>
|
||||
inline BOOST_MOVE_DOC1ST(unspecified,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound)
|
||||
make_unique(BOOST_FWD_REF(Args) ...) = delete;
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is
|
||||
//! an array of known bound.
|
||||
template<class T, class... Args>
|
||||
inline BOOST_MOVE_DOC1ST(unspecified,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound)
|
||||
make_unique_definit(BOOST_FWD_REF(Args) ...) = delete;
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is
|
||||
//! an array of known bound.
|
||||
template<class T, class... Args>
|
||||
inline BOOST_MOVE_DOC1ST(unspecified,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound)
|
||||
make_unique_nothrow(BOOST_FWD_REF(Args) ...) = delete;
|
||||
|
||||
//! <b>Remarks</b>: This function shall not participate in overload resolution unless T is
|
||||
//! an array of known bound.
|
||||
template<class T, class... Args>
|
||||
inline BOOST_MOVE_DOC1ST(unspecified,
|
||||
typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound)
|
||||
make_unique_nothrow_definit(BOOST_FWD_REF(Args) ...) = delete;
|
||||
|
||||
#endif
|
||||
|
||||
} //namespace movelib {
|
||||
|
||||
} //namespace boost{
|
||||
|
||||
#include <boost/move/detail/config_end.hpp>
|
||||
|
||||
#endif //#ifndef BOOST_MOVE_MAKE_UNIQUE_HPP_INCLUDED
|
||||
@@ -0,0 +1,31 @@
|
||||
// Boost.Range library
|
||||
//
|
||||
// Copyright Neil Groves 2014. Use, modification and
|
||||
// distribution is 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)
|
||||
//
|
||||
// For more information, see http://www.boost.org/libs/range/
|
||||
//
|
||||
|
||||
#ifndef BOOST_RANGE_TRAVERSAL_HPP
|
||||
#define BOOST_RANGE_TRAVERSAL_HPP
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/range/config.hpp>
|
||||
#include <boost/range/iterator.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template<typename SinglePassRange>
|
||||
struct range_traversal
|
||||
: iterator_traversal<typename range_iterator<SinglePassRange>::type>
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,217 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/external/thrust/thrust_algebra.hpp
|
||||
|
||||
[begin_description]
|
||||
An algebra for thrusts device_vectors.
|
||||
[end_description]
|
||||
|
||||
Copyright 2010-2013 Mario Mulansky
|
||||
Copyright 2010-2011 Karsten Ahnert
|
||||
Copyright 2013 Kyle Lutz
|
||||
|
||||
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_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED
|
||||
|
||||
|
||||
#include <thrust/device_vector.h>
|
||||
#include <thrust/for_each.h>
|
||||
#include <thrust/iterator/zip_iterator.h>
|
||||
|
||||
#include <boost/range.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
namespace detail {
|
||||
|
||||
// to use in thrust::reduce
|
||||
template< class Value >
|
||||
struct maximum
|
||||
{
|
||||
template< class Fac1 , class Fac2 >
|
||||
__host__ __device__
|
||||
Value operator()( const Fac1 t1 , const Fac2 t2 ) const
|
||||
{
|
||||
return ( abs( t1 ) < abs( t2 ) ) ? t2 : t1 ;
|
||||
}
|
||||
|
||||
typedef Value result_type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/** ToDO extend until for_each14 for rk78 */
|
||||
|
||||
/*
|
||||
* The const versions are needed for boost.range to work, i.e.
|
||||
* it allows you to do
|
||||
* for_each1( make_pair( vec1.begin() , vec1.begin() + 10 ) , op );
|
||||
*/
|
||||
|
||||
struct thrust_algebra
|
||||
{
|
||||
template< class StateType , class Operation >
|
||||
static void for_each1( StateType &s , Operation op )
|
||||
{
|
||||
thrust::for_each( boost::begin(s) , boost::end(s) , op );
|
||||
}
|
||||
|
||||
template< class StateType1 , class StateType2 , class Operation >
|
||||
static void for_each2( StateType1 &s1 , StateType2 &s2 , Operation op )
|
||||
{
|
||||
thrust::for_each(
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
|
||||
boost::begin(s2) ) ) ,
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
|
||||
boost::end(s2) ) ) ,
|
||||
op);
|
||||
}
|
||||
|
||||
template< class StateType1 , class StateType2 , class StateType3 , class Operation >
|
||||
static void for_each3( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , Operation op )
|
||||
{
|
||||
thrust::for_each(
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
|
||||
boost::begin(s2) ,
|
||||
boost::begin(s3) ) ) ,
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
|
||||
boost::end(s2) ,
|
||||
boost::end(s3) ) ) ,
|
||||
op);
|
||||
}
|
||||
|
||||
template< class StateType1 , class StateType2 , class StateType3 , class StateType4 ,
|
||||
class Operation >
|
||||
static void for_each4( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
|
||||
Operation op )
|
||||
{
|
||||
thrust::for_each(
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
|
||||
boost::begin(s2) ,
|
||||
boost::begin(s3) ,
|
||||
boost::begin(s4) ) ) ,
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
|
||||
boost::end(s2) ,
|
||||
boost::end(s3) ,
|
||||
boost::end(s4) ) ) ,
|
||||
op);
|
||||
}
|
||||
|
||||
template< class StateType1 , class StateType2 , class StateType3 ,
|
||||
class StateType4 , class StateType5 ,class Operation >
|
||||
static void for_each5( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
|
||||
StateType5 &s5 , Operation op )
|
||||
{
|
||||
thrust::for_each(
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
|
||||
boost::begin(s2) ,
|
||||
boost::begin(s3) ,
|
||||
boost::begin(s4) ,
|
||||
boost::begin(s5) ) ) ,
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
|
||||
boost::end(s2) ,
|
||||
boost::end(s3) ,
|
||||
boost::end(s4) ,
|
||||
boost::end(s5) ) ) ,
|
||||
op);
|
||||
}
|
||||
|
||||
template< class StateType1 , class StateType2 , class StateType3 ,
|
||||
class StateType4 , class StateType5 , class StateType6 , class Operation >
|
||||
static void for_each6( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
|
||||
StateType5 &s5 , StateType6 &s6 , Operation op )
|
||||
{
|
||||
thrust::for_each(
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
|
||||
boost::begin(s2) ,
|
||||
boost::begin(s3) ,
|
||||
boost::begin(s4) ,
|
||||
boost::begin(s5) ,
|
||||
boost::begin(s6) ) ) ,
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
|
||||
boost::end(s2) ,
|
||||
boost::end(s3) ,
|
||||
boost::end(s4) ,
|
||||
boost::end(s5) ,
|
||||
boost::end(s6) ) ) ,
|
||||
op);
|
||||
}
|
||||
|
||||
template< class StateType1 , class StateType2 , class StateType3 , class StateType4 ,
|
||||
class StateType5 , class StateType6 , class StateType7 , class Operation >
|
||||
static void for_each7( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
|
||||
StateType5 &s5 , StateType6 &s6 , StateType7 &s7 , Operation op )
|
||||
{
|
||||
thrust::for_each(
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
|
||||
boost::begin(s2) ,
|
||||
boost::begin(s3) ,
|
||||
boost::begin(s4) ,
|
||||
boost::begin(s5) ,
|
||||
boost::begin(s6) ,
|
||||
boost::begin(s7) ) ) ,
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
|
||||
boost::end(s2) ,
|
||||
boost::end(s3) ,
|
||||
boost::end(s4) ,
|
||||
boost::end(s5) ,
|
||||
boost::end(s6) ,
|
||||
boost::end(s7) ) ) ,
|
||||
op);
|
||||
}
|
||||
|
||||
template< class StateType1 , class StateType2 , class StateType3 , class StateType4 ,
|
||||
class StateType5 , class StateType6 , class StateType7 , class StateType8 , class Operation >
|
||||
static void for_each8( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 ,
|
||||
StateType5 &s5 , StateType6 &s6 , StateType7 &s7 , StateType8 &s8 , Operation op )
|
||||
{
|
||||
thrust::for_each(
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) ,
|
||||
boost::begin(s2) ,
|
||||
boost::begin(s3) ,
|
||||
boost::begin(s4) ,
|
||||
boost::begin(s5) ,
|
||||
boost::begin(s6) ,
|
||||
boost::begin(s7) ,
|
||||
boost::begin(s8) ) ) ,
|
||||
thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) ,
|
||||
boost::end(s2) ,
|
||||
boost::end(s3) ,
|
||||
boost::end(s4) ,
|
||||
boost::end(s5) ,
|
||||
boost::end(s6) ,
|
||||
boost::end(s7) ,
|
||||
boost::end(s8) ) ) ,
|
||||
op);
|
||||
}
|
||||
|
||||
template< class S >
|
||||
static typename S::value_type norm_inf( const S &s )
|
||||
{
|
||||
typedef typename S::value_type value_type;
|
||||
return thrust::reduce( boost::begin( s ) , boost::end( s ) ,
|
||||
static_cast<value_type>(0) ,
|
||||
detail::maximum<value_type>() );
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
} // odeint
|
||||
} // numeric
|
||||
} // boost
|
||||
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,167 @@
|
||||
#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// remove_whitespace.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is 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 for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/filter_iterator.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
|
||||
// here is the default standard implementation of the functor used
|
||||
// by the filter iterator to remove spaces. Unfortunately usage
|
||||
// of this implementation in combination with spirit trips a bug
|
||||
// VC 6.5. The only way I can find to work around it is to
|
||||
// implement a special non-standard version for this platform
|
||||
|
||||
#ifndef BOOST_NO_CWCTYPE
|
||||
#include <cwctype> // iswspace
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{ using ::iswspace; }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <cctype> // isspace
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
namespace std{ using ::isspace; }
|
||||
#endif
|
||||
|
||||
#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
|
||||
// this is required for the RW STL on Linux and Tru64.
|
||||
#undef isspace
|
||||
#undef iswspace
|
||||
#endif
|
||||
|
||||
namespace { // anonymous
|
||||
|
||||
template<class CharType>
|
||||
struct remove_whitespace_predicate;
|
||||
|
||||
template<>
|
||||
struct remove_whitespace_predicate<char>
|
||||
{
|
||||
bool operator()(unsigned char t){
|
||||
return ! std::isspace(t);
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
template<>
|
||||
struct remove_whitespace_predicate<wchar_t>
|
||||
{
|
||||
bool operator()(wchar_t t){
|
||||
return ! std::iswspace(t);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
} // namespace anonymous
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// convert base64 file data (including whitespace and padding) to binary
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
// custom version of filter iterator which doesn't look ahead further than
|
||||
// necessary
|
||||
|
||||
template<class Predicate, class Base>
|
||||
class filter_iterator
|
||||
: public boost::iterator_adaptor<
|
||||
filter_iterator<Predicate, Base>,
|
||||
Base,
|
||||
use_default,
|
||||
single_pass_traversal_tag
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef typename boost::iterator_adaptor<
|
||||
filter_iterator<Predicate, Base>,
|
||||
Base,
|
||||
use_default,
|
||||
single_pass_traversal_tag
|
||||
> super_t;
|
||||
typedef filter_iterator<Predicate, Base> this_t;
|
||||
typedef typename super_t::reference reference_type;
|
||||
|
||||
reference_type dereference_impl(){
|
||||
if(! m_full){
|
||||
while(! m_predicate(* this->base_reference()))
|
||||
++(this->base_reference());
|
||||
m_full = true;
|
||||
}
|
||||
return * this->base_reference();
|
||||
}
|
||||
|
||||
reference_type dereference() const {
|
||||
return const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
|
||||
Predicate m_predicate;
|
||||
bool m_full;
|
||||
public:
|
||||
// note: this function is public only because comeau compiler complained
|
||||
// I don't know if this is because the compiler is wrong or what
|
||||
void increment(){
|
||||
m_full = false;
|
||||
++(this->base_reference());
|
||||
}
|
||||
filter_iterator(Base start) :
|
||||
super_t(start),
|
||||
m_full(false)
|
||||
{}
|
||||
filter_iterator(){}
|
||||
};
|
||||
|
||||
template<class Base>
|
||||
class remove_whitespace :
|
||||
public filter_iterator<
|
||||
remove_whitespace_predicate<
|
||||
typename boost::iterator_value<Base>::type
|
||||
//typename Base::value_type
|
||||
>,
|
||||
Base
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef filter_iterator<
|
||||
remove_whitespace_predicate<
|
||||
typename boost::iterator_value<Base>::type
|
||||
//typename Base::value_type
|
||||
>,
|
||||
Base
|
||||
> super_t;
|
||||
public:
|
||||
// remove_whitespace(){} // why is this needed?
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
remove_whitespace(T start) :
|
||||
super_t(Base(static_cast< T >(start)))
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
remove_whitespace(const remove_whitespace & rhs) :
|
||||
super_t(rhs.base_reference())
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
|
||||
@@ -0,0 +1,132 @@
|
||||
|
||||
// (C) Copyright Tobias Schwinger
|
||||
//
|
||||
// Use modification and distribution are subject to the boost Software License,
|
||||
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_FT_DETAIL_CV_TRAITS_HPP_INCLUDED
|
||||
#define BOOST_FT_DETAIL_CV_TRAITS_HPP_INCLUDED
|
||||
|
||||
#include <cstddef>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, <= 0x582)
|
||||
# include <boost/type_traits/remove_cv.hpp>
|
||||
# include <boost/type_traits/remove_pointer.hpp>
|
||||
# include <boost/type_traits/remove_reference.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/function_types/property_tags.hpp>
|
||||
|
||||
namespace boost { namespace function_types { namespace detail {
|
||||
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x582)
|
||||
|
||||
template<typename T> struct cv_traits
|
||||
{ typedef non_cv tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T &>
|
||||
{ typedef non_cv tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T *>
|
||||
{ typedef non_cv tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T * const>
|
||||
{ typedef non_cv tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T * volatile>
|
||||
{ typedef non_cv tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T * const volatile>
|
||||
{ typedef non_cv tag; typedef T type; };
|
||||
|
||||
template<typename T> struct cv_traits<T const>
|
||||
{ typedef const_non_volatile tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const &>
|
||||
{ typedef const_non_volatile tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const *>
|
||||
{ typedef const_non_volatile tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const * const>
|
||||
{ typedef const_non_volatile tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const * volatile>
|
||||
{ typedef const_non_volatile tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const * const volatile>
|
||||
{ typedef const_non_volatile tag; typedef T type; };
|
||||
|
||||
template<typename T> struct cv_traits<T volatile>
|
||||
{ typedef volatile_non_const tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T volatile &>
|
||||
{ typedef volatile_non_const tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T volatile *>
|
||||
{ typedef volatile_non_const tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T volatile * const>
|
||||
{ typedef volatile_non_const tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T volatile * volatile>
|
||||
{ typedef volatile_non_const tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T volatile * const volatile>
|
||||
{ typedef volatile_non_const tag; typedef T type; };
|
||||
|
||||
template<typename T> struct cv_traits<T const volatile>
|
||||
{ typedef cv_qualified tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const volatile &>
|
||||
{ typedef cv_qualified tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const volatile *>
|
||||
{ typedef cv_qualified tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const volatile * const>
|
||||
{ typedef cv_qualified tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const volatile * volatile>
|
||||
{ typedef cv_qualified tag; typedef T type; };
|
||||
template<typename T> struct cv_traits<T const volatile * const volatile>
|
||||
{ typedef cv_qualified tag; typedef T type; };
|
||||
|
||||
#else
|
||||
template<std::size_t> struct cv_tag_impl;
|
||||
|
||||
template<> struct cv_tag_impl<1> { typedef non_cv type;};
|
||||
template<> struct cv_tag_impl<2> { typedef const_non_volatile type; };
|
||||
template<> struct cv_tag_impl<3> { typedef volatile_non_const type; };
|
||||
template<> struct cv_tag_impl<4> { typedef cv_qualified type; };
|
||||
|
||||
typedef char (& case_1)[1];
|
||||
typedef char (& case_2)[2];
|
||||
typedef char (& case_3)[3];
|
||||
typedef char (& case_4)[4];
|
||||
|
||||
template<typename T> case_1 switch_cv(T *);
|
||||
template<typename T> case_2 switch_cv(T const *);
|
||||
template<typename T> case_3 switch_cv(T volatile *);
|
||||
template<typename T> case_4 switch_cv(T const volatile *);
|
||||
|
||||
template<typename T> T * ref_to_ptr(T &);
|
||||
template<typename T> T const * ref_to_ptr(T const &);
|
||||
template<typename T> T volatile * ref_to_ptr(T volatile &);
|
||||
template<typename T> T const volatile * ref_to_ptr(T const volatile &);
|
||||
|
||||
template<typename T> T * ref_to_ptr(T * const volatile &);
|
||||
|
||||
template<typename T>
|
||||
struct cv_code
|
||||
{
|
||||
static T _t;
|
||||
BOOST_STATIC_CONSTANT(std::size_t, value =
|
||||
sizeof(::boost::function_types::detail::switch_cv(
|
||||
::boost::function_types::detail::ref_to_ptr(_t) ) ));
|
||||
};
|
||||
|
||||
template<typename T> struct cv_traits
|
||||
{
|
||||
typedef typename boost::function_types::detail::cv_tag_impl<
|
||||
::boost::function_types::detail::cv_code<T>::value >::type
|
||||
tag;
|
||||
|
||||
// may require Boost.TypeTraits broken compiler specializations
|
||||
// to work
|
||||
typedef typename boost::remove_cv<
|
||||
typename boost::remove_pointer<
|
||||
typename boost::remove_reference<T>::type
|
||||
>::type
|
||||
>::type type;
|
||||
};
|
||||
#endif
|
||||
|
||||
} } } // namespace boost::function_types::detail
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,261 @@
|
||||
// (C) Copyright John Maddock 2000.
|
||||
// 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_TYPE_WITH_ALIGNMENT_INCLUDED
|
||||
#define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED
|
||||
|
||||
#include <boost/type_traits/alignment_of.hpp>
|
||||
#include <boost/type_traits/is_pod.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <cstddef> // size_t
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4121) // alignment is sensitive to packing
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include <boost/type_traits/conditional.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace detail{
|
||||
|
||||
#ifndef __BORLANDC__
|
||||
|
||||
union max_align
|
||||
{
|
||||
char c;
|
||||
short s;
|
||||
int i;
|
||||
long l;
|
||||
#ifndef BOOST_NO_LONG_LONG
|
||||
boost::long_long_type ll;
|
||||
#endif
|
||||
#ifdef BOOST_HAS_INT128
|
||||
boost::int128_type i128;
|
||||
#endif
|
||||
float f;
|
||||
double d;
|
||||
long double ld;
|
||||
#ifdef BOOST_HAS_FLOAT128
|
||||
__float128 f128;
|
||||
#endif
|
||||
};
|
||||
|
||||
template <std::size_t Target, bool check> struct long_double_alignment{ typedef long double type; };
|
||||
template <std::size_t Target> struct long_double_alignment<Target, false>{ typedef boost::detail::max_align type; };
|
||||
|
||||
template <std::size_t Target, bool check> struct double_alignment{ typedef double type; };
|
||||
template <std::size_t Target> struct double_alignment<Target, false>{ typedef typename long_double_alignment<Target, boost::alignment_of<long double>::value >= Target>::type type; };
|
||||
|
||||
#ifndef BOOST_NO_LONG_LONG
|
||||
template <std::size_t Target, bool check> struct long_long_alignment{ typedef boost::long_long_type type; };
|
||||
template <std::size_t Target> struct long_long_alignment<Target, false>{ typedef typename double_alignment<Target, boost::alignment_of<double>::value >= Target>::type type; };
|
||||
#endif
|
||||
|
||||
template <std::size_t Target, bool check> struct long_alignment{ typedef long type; };
|
||||
#ifndef BOOST_NO_LONG_LONG
|
||||
template <std::size_t Target> struct long_alignment<Target, false>{ typedef typename long_long_alignment<Target, boost::alignment_of<boost::long_long_type>::value >= Target>::type type; };
|
||||
#else
|
||||
template <std::size_t Target> struct long_alignment<Target, false>{ typedef typename double_alignment<Target, boost::alignment_of<double>::value >= Target>::type type; };
|
||||
#endif
|
||||
|
||||
template <std::size_t Target, bool check> struct int_alignment{ typedef int type; };
|
||||
template <std::size_t Target> struct int_alignment<Target, false>{ typedef typename long_alignment<Target, boost::alignment_of<long>::value >= Target>::type type; };
|
||||
|
||||
template <std::size_t Target, bool check> struct short_alignment{ typedef short type; };
|
||||
template <std::size_t Target> struct short_alignment<Target, false>{ typedef typename int_alignment<Target, boost::alignment_of<int>::value >= Target>::type type; };
|
||||
|
||||
template <std::size_t Target, bool check> struct char_alignment{ typedef char type; };
|
||||
template <std::size_t Target> struct char_alignment<Target, false>{ typedef typename short_alignment<Target, boost::alignment_of<short>::value >= Target>::type type; };
|
||||
|
||||
}
|
||||
|
||||
template <std::size_t Align>
|
||||
struct type_with_alignment
|
||||
{
|
||||
typedef typename boost::detail::char_alignment<Align, boost::alignment_of<char>::value >= Align>::type type;
|
||||
};
|
||||
|
||||
#if (defined(__GNUC__) || (defined (__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)) || defined(__clang__)) && !defined(BOOST_TT_DISABLE_INTRINSICS)
|
||||
namespace tt_align_ns {
|
||||
struct __attribute__((__aligned__(2))) a2 {};
|
||||
struct __attribute__((__aligned__(4))) a4 {};
|
||||
struct __attribute__((__aligned__(8))) a8 {};
|
||||
struct __attribute__((__aligned__(16))) a16 {};
|
||||
struct __attribute__((__aligned__(32))) a32 {};
|
||||
struct __attribute__((__aligned__(64))) a64 {};
|
||||
struct __attribute__((__aligned__(128))) a128 {};
|
||||
}
|
||||
|
||||
template<> struct type_with_alignment<1> { public: typedef char type; };
|
||||
template<> struct type_with_alignment<2> { public: typedef tt_align_ns::a2 type; };
|
||||
template<> struct type_with_alignment<4> { public: typedef tt_align_ns::a4 type; };
|
||||
template<> struct type_with_alignment<8> { public: typedef tt_align_ns::a8 type; };
|
||||
template<> struct type_with_alignment<16> { public: typedef tt_align_ns::a16 type; };
|
||||
template<> struct type_with_alignment<32> { public: typedef tt_align_ns::a32 type; };
|
||||
template<> struct type_with_alignment<64> { public: typedef tt_align_ns::a64 type; };
|
||||
template<> struct type_with_alignment<128> { public: typedef tt_align_ns::a128 type; };
|
||||
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
|
||||
|
||||
#endif
|
||||
#if (defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && !defined(BOOST_TT_DISABLE_INTRINSICS)
|
||||
//
|
||||
// MSVC supports types which have alignments greater than the normal
|
||||
// maximum: these are used for example in the types __m64 and __m128
|
||||
// to provide types with alignment requirements which match the SSE
|
||||
// registers. Therefore we extend type_with_alignment<> to support
|
||||
// such types, however, we have to be careful to use a builtin type
|
||||
// whenever possible otherwise we break previously working code:
|
||||
// see http://article.gmane.org/gmane.comp.lib.boost.devel/173011
|
||||
// for an example and test case. Thus types like a8 below will
|
||||
// be used *only* if the existing implementation can't provide a type
|
||||
// with suitable alignment. This does mean however, that type_with_alignment<>
|
||||
// may return a type which cannot be passed through a function call
|
||||
// by value (and neither can any type containing such a type like
|
||||
// Boost.Optional). However, this only happens when we have no choice
|
||||
// in the matter because no other "ordinary" type is available.
|
||||
//
|
||||
namespace tt_align_ns {
|
||||
struct __declspec(align(8)) a8 {
|
||||
char m[8];
|
||||
typedef a8 type;
|
||||
};
|
||||
struct __declspec(align(16)) a16 {
|
||||
char m[16];
|
||||
typedef a16 type;
|
||||
};
|
||||
struct __declspec(align(32)) a32 {
|
||||
char m[32];
|
||||
typedef a32 type;
|
||||
};
|
||||
struct __declspec(align(64)) a64
|
||||
{
|
||||
char m[64];
|
||||
typedef a64 type;
|
||||
};
|
||||
struct __declspec(align(128)) a128 {
|
||||
char m[128];
|
||||
typedef a128 type;
|
||||
};
|
||||
}
|
||||
|
||||
template<> struct type_with_alignment<8>
|
||||
{
|
||||
typedef boost::conditional<
|
||||
::boost::alignment_of<boost::detail::max_align>::value < 8,
|
||||
tt_align_ns::a8,
|
||||
boost::detail::char_alignment<8, false> >::type t1;
|
||||
public:
|
||||
typedef t1::type type;
|
||||
};
|
||||
template<> struct type_with_alignment<16>
|
||||
{
|
||||
typedef boost::conditional<
|
||||
::boost::alignment_of<boost::detail::max_align>::value < 16,
|
||||
tt_align_ns::a16,
|
||||
boost::detail::char_alignment<16, false> >::type t1;
|
||||
public:
|
||||
typedef t1::type type;
|
||||
};
|
||||
template<> struct type_with_alignment<32>
|
||||
{
|
||||
typedef boost::conditional<
|
||||
::boost::alignment_of<boost::detail::max_align>::value < 32,
|
||||
tt_align_ns::a32,
|
||||
boost::detail::char_alignment<32, false> >::type t1;
|
||||
public:
|
||||
typedef t1::type type;
|
||||
};
|
||||
template<> struct type_with_alignment<64> {
|
||||
typedef boost::conditional<
|
||||
::boost::alignment_of<boost::detail::max_align>::value < 64,
|
||||
tt_align_ns::a64,
|
||||
boost::detail::char_alignment<64, false> >::type t1;
|
||||
public:
|
||||
typedef t1::type type;
|
||||
};
|
||||
template<> struct type_with_alignment<128> {
|
||||
typedef boost::conditional<
|
||||
::boost::alignment_of<boost::detail::max_align>::value < 128,
|
||||
tt_align_ns::a128,
|
||||
boost::detail::char_alignment<128, false> >::type t1;
|
||||
public:
|
||||
typedef t1::type type;
|
||||
};
|
||||
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
|
||||
template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
|
||||
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
//
|
||||
// Borland specific version, we have this for two reasons:
|
||||
// 1) The version above doesn't always compile (with the new test cases for example)
|
||||
// 2) Because of Borlands #pragma option we can create types with alignments that are
|
||||
// greater that the largest aligned builtin type.
|
||||
|
||||
namespace tt_align_ns{
|
||||
#pragma option push -a16
|
||||
struct a2{ short s; };
|
||||
struct a4{ int s; };
|
||||
struct a8{ double s; };
|
||||
struct a16{ long double s; };
|
||||
#pragma option pop
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
typedef ::boost::tt_align_ns::a16 max_align;
|
||||
|
||||
}
|
||||
//#if ! BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
|
||||
template <> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{};
|
||||
template <> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{};
|
||||
template <> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
|
||||
template <> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
|
||||
//#endif
|
||||
|
||||
template <std::size_t N> struct type_with_alignment
|
||||
{
|
||||
// We should never get to here, but if we do use the maximally
|
||||
// aligned type:
|
||||
// BOOST_STATIC_ASSERT(0);
|
||||
typedef tt_align_ns::a16 type;
|
||||
};
|
||||
template <> struct type_with_alignment<1>{ typedef char type; };
|
||||
template <> struct type_with_alignment<2>{ typedef tt_align_ns::a2 type; };
|
||||
template <> struct type_with_alignment<4>{ typedef tt_align_ns::a4 type; };
|
||||
template <> struct type_with_alignment<8>{ typedef tt_align_ns::a8 type; };
|
||||
template <> struct type_with_alignment<16>{ typedef tt_align_ns::a16 type; };
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED
|
||||
|
||||
|
||||
@@ -0,0 +1,181 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/external/mkl/mkl_operations.hpp
|
||||
|
||||
[begin_description]
|
||||
Wrapper classes for intel math kernel library types.
|
||||
Get a free, non-commercial download of MKL at
|
||||
http://software.intel.com/en-us/articles/non-commercial-software-download/
|
||||
[end_description]
|
||||
|
||||
Copyright 2010-2011 Mario Mulansky
|
||||
Copyright 2011-2013 Karsten Ahnert
|
||||
|
||||
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_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include <mkl_cblas.h>
|
||||
#include <boost/numeric/odeint/algebra/default_operations.hpp>
|
||||
|
||||
/* exemplary example for writing bindings to the Intel MKL library
|
||||
* see test/mkl for how to use mkl with odeint
|
||||
* this is a quick and dirty implementation showing the general possibility.
|
||||
* It works only with containers based on double and sequential memory allocation.
|
||||
*/
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
/* only defined for doubles */
|
||||
struct mkl_operations
|
||||
{
|
||||
//template< class Fac1 , class Fac2 > struct scale_sum2;
|
||||
|
||||
template< class F1 = double , class F2 = F1 >
|
||||
struct scale_sum2
|
||||
{
|
||||
typedef double Fac1;
|
||||
typedef double Fac2;
|
||||
const Fac1 m_alpha1;
|
||||
const Fac2 m_alpha2;
|
||||
|
||||
scale_sum2( const Fac1 alpha1 , const Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }
|
||||
|
||||
template< class T1 , class T2 , class T3 >
|
||||
void operator()( T1 &t1 , const T2 &t2 , const T3 &t3) const
|
||||
{ // t1 = m_alpha1 * t2 + m_alpha2 * t3;
|
||||
// we get Containers that have size() and [i]-access
|
||||
|
||||
const int n = t1.size();
|
||||
//boost::numeric::odeint::copy( t1 , t3 );
|
||||
if( &(t2[0]) != &(t1[0]) )
|
||||
{
|
||||
cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
|
||||
}
|
||||
cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
|
||||
cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
|
||||
//daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
|
||||
}
|
||||
};
|
||||
|
||||
template< class F1 = double , class F2 = F1 , class F3 = F2 >
|
||||
struct scale_sum3
|
||||
{
|
||||
typedef double Fac1;
|
||||
typedef double Fac2;
|
||||
typedef double Fac3;
|
||||
const Fac1 m_alpha1;
|
||||
const Fac2 m_alpha2;
|
||||
const Fac3 m_alpha3;
|
||||
|
||||
scale_sum3( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 )
|
||||
: m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { }
|
||||
|
||||
template< class T1 , class T2 , class T3 , class T4 >
|
||||
void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 ) const
|
||||
{ // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4;
|
||||
// we get Containers that have size() and [i]-access
|
||||
|
||||
const int n = t1.size();
|
||||
//boost::numeric::odeint::copy( t1 , t3 );
|
||||
if( &(t2[0]) != &(t1[0]) )
|
||||
{
|
||||
cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
|
||||
}
|
||||
cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
|
||||
cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
|
||||
//daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
|
||||
cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
|
||||
}
|
||||
};
|
||||
|
||||
template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 >
|
||||
struct scale_sum4
|
||||
{
|
||||
typedef double Fac1;
|
||||
typedef double Fac2;
|
||||
typedef double Fac3;
|
||||
typedef double Fac4;
|
||||
const Fac1 m_alpha1;
|
||||
const Fac2 m_alpha2;
|
||||
const Fac3 m_alpha3;
|
||||
const Fac4 m_alpha4;
|
||||
|
||||
scale_sum4( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 )
|
||||
: m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { }
|
||||
|
||||
template< class T1 , class T2 , class T3 , class T4 , class T5 >
|
||||
void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 ) const
|
||||
{ // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5;
|
||||
// we get Containers that have size() and [i]-access
|
||||
|
||||
const int n = t1.size();
|
||||
//boost::numeric::odeint::copy( t1 , t3 );
|
||||
if( &(t2[0]) != &(t1[0]) )
|
||||
{
|
||||
cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
|
||||
}
|
||||
|
||||
cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
|
||||
cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
|
||||
//daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
|
||||
cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
|
||||
cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 );
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 , class F5 = F4 >
|
||||
struct scale_sum5
|
||||
{
|
||||
typedef double Fac1;
|
||||
typedef double Fac2;
|
||||
typedef double Fac3;
|
||||
typedef double Fac4;
|
||||
typedef double Fac5;
|
||||
const Fac1 m_alpha1;
|
||||
const Fac2 m_alpha2;
|
||||
const Fac3 m_alpha3;
|
||||
const Fac4 m_alpha4;
|
||||
const Fac5 m_alpha5;
|
||||
|
||||
scale_sum5( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 , const Fac5 alpha5 )
|
||||
: m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { }
|
||||
|
||||
template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
|
||||
void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 ) const
|
||||
{ // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6;
|
||||
// we get Containers that have size() and [i]-access
|
||||
|
||||
const int n = t1.size();
|
||||
//boost::numeric::odeint::copy( t1 , t3 );
|
||||
if( &(t2[0]) != &(t1[0]) )
|
||||
{
|
||||
cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 );
|
||||
}
|
||||
|
||||
cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 );
|
||||
cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 );
|
||||
//daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one );
|
||||
cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 );
|
||||
cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 );
|
||||
cblas_daxpy( n , m_alpha5 , &(t6[0]) , 1 , &(t1[0]) , 1 );
|
||||
}
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
} // odeint
|
||||
} // numeric
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED
|
||||
@@ -0,0 +1,118 @@
|
||||
#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// binary_from_base64.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is 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 for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/serialization/throw_exception.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
#include <boost/iterator/transform_iterator.hpp>
|
||||
#include <boost/archive/iterators/dataflow_exception.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// convert base64 characters to binary data
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class CharType>
|
||||
struct to_6_bit {
|
||||
typedef CharType result_type;
|
||||
CharType operator()(CharType t) const{
|
||||
const signed char lookup_table[] = {
|
||||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
|
||||
52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0
|
||||
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
|
||||
15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
|
||||
-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
|
||||
41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
|
||||
};
|
||||
// metrowerks trips this assertion - how come?
|
||||
#if ! defined(__MWERKS__)
|
||||
BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
|
||||
#endif
|
||||
signed char value = -1;
|
||||
if((unsigned)t <= 127)
|
||||
value = lookup_table[(unsigned)t];
|
||||
if(-1 == value)
|
||||
boost::serialization::throw_exception(
|
||||
dataflow_exception(dataflow_exception::invalid_base64_character)
|
||||
);
|
||||
return value;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// note: what we would like to do is
|
||||
// template<class Base, class CharType = typename Base::value_type>
|
||||
// typedef transform_iterator<
|
||||
// from_6_bit<CharType>,
|
||||
// transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
|
||||
// > base64_from_binary;
|
||||
// but C++ won't accept this. Rather than using a "type generator" and
|
||||
// using a different syntax, make a derivation which should be equivalent.
|
||||
//
|
||||
// Another issue addressed here is that the transform_iterator doesn't have
|
||||
// a templated constructor. This makes it incompatible with the dataflow
|
||||
// ideal. This is also addressed here.
|
||||
|
||||
template<
|
||||
class Base,
|
||||
class CharType = typename boost::iterator_value<Base>::type
|
||||
>
|
||||
class binary_from_base64 : public
|
||||
transform_iterator<
|
||||
detail::to_6_bit<CharType>,
|
||||
Base
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef transform_iterator<
|
||||
detail::to_6_bit<CharType>,
|
||||
Base
|
||||
> super_t;
|
||||
public:
|
||||
// make composible buy using templated constructor
|
||||
template<class T>
|
||||
binary_from_base64(T start) :
|
||||
super_t(
|
||||
Base(static_cast< T >(start)),
|
||||
detail::to_6_bit<CharType>()
|
||||
)
|
||||
{}
|
||||
// intel 7.1 doesn't like default copy constructor
|
||||
binary_from_base64(const binary_from_base64 & rhs) :
|
||||
super_t(
|
||||
Base(rhs.base_reference()),
|
||||
detail::to_6_bit<CharType>()
|
||||
)
|
||||
{}
|
||||
// binary_from_base64(){};
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
|
||||
@@ -0,0 +1,244 @@
|
||||
|
||||
// (C) Copyright Rani Sharoni 2003.
|
||||
// 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_IS_BASE_AND_DERIVED_HPP_INCLUDED
|
||||
#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
|
||||
|
||||
#include <boost/type_traits/intrinsics.hpp>
|
||||
#include <boost/type_traits/integral_constant.hpp>
|
||||
#ifndef BOOST_IS_BASE_OF
|
||||
#include <boost/type_traits/is_class.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/is_convertible.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#endif
|
||||
#include <boost/type_traits/remove_cv.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail {
|
||||
|
||||
#ifndef BOOST_IS_BASE_OF
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) \
|
||||
&& !BOOST_WORKAROUND(__SUNPRO_CC , <= 0x540) \
|
||||
&& !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \
|
||||
&& !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
|
||||
|
||||
// The EDG version number is a lower estimate.
|
||||
// It is not currently known which EDG version
|
||||
// exactly fixes the problem.
|
||||
|
||||
/*************************************************************************
|
||||
|
||||
This version detects ambiguous base classes and private base classes
|
||||
correctly, and was devised by Rani Sharoni.
|
||||
|
||||
Explanation by Terje Slettebo and Rani Sharoni.
|
||||
|
||||
Let's take the multiple base class below as an example, and the following
|
||||
will also show why there's not a problem with private or ambiguous base
|
||||
class:
|
||||
|
||||
struct B {};
|
||||
struct B1 : B {};
|
||||
struct B2 : B {};
|
||||
struct D : private B1, private B2 {};
|
||||
|
||||
is_base_and_derived<B, D>::value;
|
||||
|
||||
First, some terminology:
|
||||
|
||||
SC - Standard conversion
|
||||
UDC - User-defined conversion
|
||||
|
||||
A user-defined conversion sequence consists of an SC, followed by an UDC,
|
||||
followed by another SC. Either SC may be the identity conversion.
|
||||
|
||||
When passing the default-constructed Host object to the overloaded check_sig()
|
||||
functions (initialization 8.5/14/4/3), we have several viable implicit
|
||||
conversion sequences:
|
||||
|
||||
For "static no_type check_sig(B const volatile *, int)" we have the conversion
|
||||
sequences:
|
||||
|
||||
C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC)
|
||||
C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
|
||||
B const volatile* (SC - Conversion)
|
||||
|
||||
For "static yes_type check_sig(D const volatile *, T)" we have the conversion
|
||||
sequence:
|
||||
|
||||
C -> D const volatile* (UDC)
|
||||
|
||||
According to 13.3.3.1/4, in context of user-defined conversion only the
|
||||
standard conversion sequence is considered when selecting the best viable
|
||||
function, so it only considers up to the user-defined conversion. For the
|
||||
first function this means choosing between C -> C const and C -> C, and it
|
||||
chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the
|
||||
former. Therefore, we have:
|
||||
|
||||
C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
|
||||
B const volatile* (SC - Conversion)
|
||||
C -> D const volatile* (UDC)
|
||||
|
||||
Here, the principle of the "shortest subsequence" applies again, and it
|
||||
chooses C -> D const volatile*. This shows that it doesn't even need to
|
||||
consider the multiple paths to B, or accessibility, as that possibility is
|
||||
eliminated before it could possibly cause ambiguity or access violation.
|
||||
|
||||
If D is not derived from B, it has to choose between C -> C const -> B const
|
||||
volatile* for the first function, and C -> D const volatile* for the second
|
||||
function, which are just as good (both requires a UDC, 13.3.3.2), had it not
|
||||
been for the fact that "static no_type check_sig(B const volatile *, int)" is
|
||||
not templated, which makes C -> C const -> B const volatile* the best choice
|
||||
(13.3.3/1/4), resulting in "no".
|
||||
|
||||
Also, if Host::operator B const volatile* hadn't been const, the two
|
||||
conversion sequences for "static no_type check_sig(B const volatile *, int)", in
|
||||
the case where D is derived from B, would have been ambiguous.
|
||||
|
||||
See also
|
||||
http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting.
|
||||
google.com and links therein.
|
||||
|
||||
*************************************************************************/
|
||||
|
||||
template <typename B, typename D>
|
||||
struct bd_helper
|
||||
{
|
||||
//
|
||||
// This VC7.1 specific workaround stops the compiler from generating
|
||||
// an internal compiler error when compiling with /vmg (thanks to
|
||||
// Aleksey Gurtovoy for figuring out the workaround).
|
||||
//
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
template <typename T>
|
||||
static type_traits::yes_type check_sig(D const volatile *, T);
|
||||
static type_traits::no_type check_sig(B const volatile *, int);
|
||||
#else
|
||||
static type_traits::yes_type check_sig(D const volatile *, long);
|
||||
static type_traits::no_type check_sig(B const volatile * const&, int);
|
||||
#endif
|
||||
};
|
||||
|
||||
template<typename B, typename D>
|
||||
struct is_base_and_derived_impl2
|
||||
{
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:6334)
|
||||
#endif
|
||||
//
|
||||
// May silently do the wrong thing with incomplete types
|
||||
// unless we trap them here:
|
||||
//
|
||||
BOOST_STATIC_ASSERT(sizeof(B) != 0);
|
||||
BOOST_STATIC_ASSERT(sizeof(D) != 0);
|
||||
|
||||
struct Host
|
||||
{
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
operator B const volatile *() const;
|
||||
#else
|
||||
operator B const volatile * const&() const;
|
||||
#endif
|
||||
operator D const volatile *();
|
||||
};
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
sizeof(bd_helper<B,D>::check_sig(Host(), 0)) == sizeof(type_traits::yes_type));
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
//
|
||||
// broken version:
|
||||
//
|
||||
template<typename B, typename D>
|
||||
struct is_base_and_derived_impl2
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::is_convertible<D*,B*>::value));
|
||||
};
|
||||
|
||||
#define BOOST_BROKEN_IS_BASE_AND_DERIVED
|
||||
|
||||
#endif
|
||||
|
||||
template <typename B, typename D>
|
||||
struct is_base_and_derived_impl3
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
template <bool ic1, bool ic2, bool iss>
|
||||
struct is_base_and_derived_select
|
||||
{
|
||||
template <class T, class U>
|
||||
struct rebind
|
||||
{
|
||||
typedef is_base_and_derived_impl3<T,U> type;
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_base_and_derived_select<true,true,false>
|
||||
{
|
||||
template <class T, class U>
|
||||
struct rebind
|
||||
{
|
||||
typedef is_base_and_derived_impl2<T,U> type;
|
||||
};
|
||||
};
|
||||
|
||||
template <typename B, typename D>
|
||||
struct is_base_and_derived_impl
|
||||
{
|
||||
typedef typename remove_cv<B>::type ncvB;
|
||||
typedef typename remove_cv<D>::type ncvD;
|
||||
|
||||
typedef is_base_and_derived_select<
|
||||
::boost::is_class<B>::value,
|
||||
::boost::is_class<D>::value,
|
||||
::boost::is_same<ncvB,ncvD>::value> selector;
|
||||
typedef typename selector::template rebind<ncvB,ncvD> binder;
|
||||
typedef typename binder::type bound_type;
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, value = bound_type::value);
|
||||
};
|
||||
#else
|
||||
template <typename B, typename D>
|
||||
struct is_base_and_derived_impl
|
||||
{
|
||||
typedef typename remove_cv<B>::type ncvB;
|
||||
typedef typename remove_cv<D>::type ncvD;
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, value = (BOOST_IS_BASE_OF(B,D) && ! ::boost::is_same<ncvB,ncvD>::value));
|
||||
};
|
||||
#endif
|
||||
} // namespace detail
|
||||
|
||||
template <class Base, class Derived> struct is_base_and_derived
|
||||
: public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};
|
||||
|
||||
template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
|
||||
template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
|
||||
template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
|
||||
|
||||
#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
|
||||
template <class Base> struct is_base_and_derived<Base, Base> : public true_type{};
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
|
||||
@@ -0,0 +1,91 @@
|
||||
/* Copyright 2003-2013 Joaquin M Lopez Munoz.
|
||||
* 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/multi_index for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
|
||||
#define BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
|
||||
#include <algorithm>
|
||||
#include <boost/detail/allocator_utilities.hpp>
|
||||
#include <boost/multi_index/detail/adl_swap.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <memory>
|
||||
|
||||
namespace boost{
|
||||
|
||||
namespace multi_index{
|
||||
|
||||
namespace detail{
|
||||
|
||||
/* auto_space provides uninitialized space suitably to store
|
||||
* a given number of elements of a given type.
|
||||
*/
|
||||
|
||||
/* NB: it is not clear whether using an allocator to handle
|
||||
* zero-sized arrays of elements is conformant or not. GCC 3.3.1
|
||||
* and prior fail here, other stdlibs handle the issue gracefully.
|
||||
* To be on the safe side, the case n==0 is given special treatment.
|
||||
* References:
|
||||
* GCC Bugzilla, "standard allocator crashes when deallocating segment
|
||||
* "of zero length", http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14176
|
||||
* C++ Standard Library Defect Report List (Revision 28), issue 199
|
||||
* "What does allocate(0) return?",
|
||||
* http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199
|
||||
*/
|
||||
|
||||
template<typename T,typename Allocator=std::allocator<T> >
|
||||
struct auto_space:private noncopyable
|
||||
{
|
||||
typedef typename boost::detail::allocator::rebind_to<
|
||||
Allocator,T
|
||||
>::type::pointer pointer;
|
||||
|
||||
explicit auto_space(const Allocator& al=Allocator(),std::size_t n=1):
|
||||
al_(al),n_(n),data_(n_?al_.allocate(n_):pointer(0))
|
||||
{}
|
||||
|
||||
~auto_space()
|
||||
{
|
||||
if(n_)al_.deallocate(data_,n_);
|
||||
}
|
||||
|
||||
Allocator get_allocator()const{return al_;}
|
||||
|
||||
pointer data()const{return data_;}
|
||||
|
||||
void swap(auto_space& x)
|
||||
{
|
||||
if(al_!=x.al_)adl_swap(al_,x.al_);
|
||||
std::swap(n_,x.n_);
|
||||
std::swap(data_,x.data_);
|
||||
}
|
||||
|
||||
private:
|
||||
typename boost::detail::allocator::rebind_to<
|
||||
Allocator,T>::type al_;
|
||||
std::size_t n_;
|
||||
pointer data_;
|
||||
};
|
||||
|
||||
template<typename T,typename Allocator>
|
||||
void swap(auto_space<T,Allocator>& x,auto_space<T,Allocator>& y)
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
} /* namespace multi_index::detail */
|
||||
|
||||
} /* namespace multi_index */
|
||||
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,886 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file proto_fwd.hpp
|
||||
/// Forward declarations of all of proto's public types and functions.
|
||||
//
|
||||
// Copyright 2008 Eric Niebler. Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROTO_FWD_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005
|
||||
|
||||
#include <cstddef>
|
||||
#include <climits>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/long.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/mpl/aux_/config/ttp.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
#ifndef BOOST_PROTO_MAX_ARITY
|
||||
# define BOOST_PROTO_MAX_ARITY 10
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_MAX_LOGICAL_ARITY
|
||||
# define BOOST_PROTO_MAX_LOGICAL_ARITY 10
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
|
||||
# define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY BOOST_PROTO_MAX_ARITY
|
||||
#endif
|
||||
|
||||
#if BOOST_PROTO_MAX_ARITY < 3
|
||||
# error BOOST_PROTO_MAX_ARITY must be at least 3
|
||||
#endif
|
||||
|
||||
#if BOOST_PROTO_MAX_FUNCTION_CALL_ARITY > BOOST_PROTO_MAX_ARITY
|
||||
# error BOOST_PROTO_MAX_FUNCTION_CALL_ARITY cannot be larger than BOOST_PROTO_MAX_ARITY
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
#if 10 < BOOST_PROTO_MAX_ARITY || \
|
||||
10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \
|
||||
10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
|
||||
#define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_BROKEN_CONST_OVERLOADS
|
||||
# if BOOST_WORKAROUND(__GNUC__, == 3) \
|
||||
|| BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310))
|
||||
# define BOOST_PROTO_BROKEN_CONST_OVERLOADS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
|
||||
# if BOOST_WORKAROUND(__GNUC__, == 3) \
|
||||
|| BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310))
|
||||
# define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS
|
||||
# include <boost/utility/enable_if.hpp>
|
||||
# include <boost/type_traits/is_const.hpp>
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\
|
||||
, typename boost::disable_if_c<boost::is_const<T>::value, boost::proto::detail::undefined>::type * = 0
|
||||
#else
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
|
||||
# include <boost/utility/enable_if.hpp>
|
||||
# include <boost/type_traits/is_function.hpp>
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\
|
||||
, typename boost::disable_if_c<boost::is_function<T>::value, boost::proto::detail::undefined>::type * = 0
|
||||
#else
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_BROKEN_PTS
|
||||
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
|
||||
# define BOOST_PROTO_BROKEN_PTS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_CXX11_DECLTYPE_N3276
|
||||
# // Proto can only use the decltype-based result_of if N3276 has been
|
||||
# // implemented by the compiler.
|
||||
# // See http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf
|
||||
# ifndef BOOST_PROTO_USE_NORMAL_RESULT_OF
|
||||
# define BOOST_PROTO_USE_NORMAL_RESULT_OF
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// Unless compiler support is there, use tr1_result_of instead of
|
||||
// result_of to avoid the problems addressed by N3276.
|
||||
#ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF
|
||||
# define BOOST_PROTO_RESULT_OF boost::result_of
|
||||
#else
|
||||
# define BOOST_PROTO_RESULT_OF boost::tr1_result_of
|
||||
#endif
|
||||
|
||||
// If we're using the decltype-based result_of, we need to be a bit
|
||||
// stricter about the return types of some functions.
|
||||
#if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_PROTO_USE_NORMAL_RESULT_OF)
|
||||
# define BOOST_PROTO_STRICT_RESULT_OF
|
||||
# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) X
|
||||
#else
|
||||
# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) Y
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
|
||||
# define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable : 4522)) // 'class' : multiple assignment operators specified
|
||||
# define BOOST_PROTO_DISABLE_MSVC_C4714 __pragma(warning(disable : 4714)) // function 'xxx' marked as __forceinline not inlined
|
||||
#else
|
||||
# define BOOST_PROTO_DISABLE_MSVC_C4522
|
||||
# define BOOST_PROTO_DISABLE_MSVC_C4714
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
typedef char yes_type;
|
||||
typedef char (&no_type)[2];
|
||||
|
||||
template<int N>
|
||||
struct sized_type
|
||||
{
|
||||
typedef char (&type)[N];
|
||||
};
|
||||
|
||||
struct dont_care;
|
||||
struct undefined; // leave this undefined
|
||||
struct not_a_valid_type;
|
||||
|
||||
struct private_type_
|
||||
{
|
||||
private_type_ operator ,(int) const;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref<T const>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref<T &>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref<T const &>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct uncvref<T const[N]>
|
||||
{
|
||||
typedef T type[N];
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct uncvref<T (&)[N]>
|
||||
{
|
||||
typedef T type[N];
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct uncvref<T const (&)[N]>
|
||||
{
|
||||
typedef T type[N];
|
||||
};
|
||||
|
||||
struct ignore
|
||||
{
|
||||
ignore()
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
ignore(T const &)
|
||||
{}
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_UNCVREF(X) \
|
||||
typename boost::proto::detail::uncvref<X>::type \
|
||||
/**/
|
||||
|
||||
struct _default;
|
||||
|
||||
struct not_a_domain;
|
||||
struct not_a_grammar;
|
||||
struct not_a_generator;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_transform_;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_aggregate_;
|
||||
|
||||
template<typename Expr>
|
||||
struct flat_view;
|
||||
}
|
||||
|
||||
typedef detail::ignore const ignore;
|
||||
|
||||
namespace argsns_
|
||||
{
|
||||
template<typename Arg0>
|
||||
struct term;
|
||||
|
||||
#define M0(Z, N, DATA) \
|
||||
template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename Arg)> struct BOOST_PP_CAT(list, N); \
|
||||
/**/
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~)
|
||||
#undef M0
|
||||
}
|
||||
|
||||
using namespace argsns_;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Operator tags
|
||||
namespace tagns_
|
||||
{
|
||||
namespace tag
|
||||
{
|
||||
struct terminal;
|
||||
struct unary_plus;
|
||||
struct negate;
|
||||
struct dereference;
|
||||
struct complement;
|
||||
struct address_of;
|
||||
struct logical_not;
|
||||
struct pre_inc;
|
||||
struct pre_dec;
|
||||
struct post_inc;
|
||||
struct post_dec;
|
||||
|
||||
struct shift_left;
|
||||
struct shift_right;
|
||||
struct multiplies;
|
||||
struct divides;
|
||||
struct modulus;
|
||||
struct plus;
|
||||
struct minus;
|
||||
struct less;
|
||||
struct greater;
|
||||
struct less_equal;
|
||||
struct greater_equal;
|
||||
struct equal_to;
|
||||
struct not_equal_to;
|
||||
struct logical_or;
|
||||
struct logical_and;
|
||||
struct bitwise_and;
|
||||
struct bitwise_or;
|
||||
struct bitwise_xor;
|
||||
struct comma;
|
||||
struct mem_ptr;
|
||||
|
||||
struct assign;
|
||||
struct shift_left_assign;
|
||||
struct shift_right_assign;
|
||||
struct multiplies_assign;
|
||||
struct divides_assign;
|
||||
struct modulus_assign;
|
||||
struct plus_assign;
|
||||
struct minus_assign;
|
||||
struct bitwise_and_assign;
|
||||
struct bitwise_or_assign;
|
||||
struct bitwise_xor_assign;
|
||||
struct subscript;
|
||||
struct member;
|
||||
struct if_else_;
|
||||
struct function;
|
||||
|
||||
// Fusion tags
|
||||
template<typename Tag, typename Domain> struct proto_expr;
|
||||
template<typename Tag, typename Domain> struct proto_expr_iterator;
|
||||
template<typename Tag, typename Domain> struct proto_flat_view;
|
||||
}
|
||||
}
|
||||
|
||||
using namespace tagns_;
|
||||
|
||||
template<typename Expr>
|
||||
struct tag_of;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct _;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct default_generator;
|
||||
|
||||
struct basic_default_generator;
|
||||
|
||||
template<template<typename> class Extends>
|
||||
struct generator;
|
||||
|
||||
template<template<typename> class Extends>
|
||||
struct pod_generator;
|
||||
|
||||
struct by_value_generator;
|
||||
|
||||
template<typename First, typename Second>
|
||||
struct compose_generators;
|
||||
|
||||
template<typename Generator, typename Void = void>
|
||||
struct wants_basic_expr;
|
||||
|
||||
template<typename Generator>
|
||||
struct use_basic_expr;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
namespace domainns_
|
||||
{
|
||||
typedef detail::not_a_domain no_super_domain;
|
||||
|
||||
template<
|
||||
typename Generator = default_generator
|
||||
, typename Grammar = proto::_
|
||||
, typename Super = no_super_domain
|
||||
>
|
||||
struct domain;
|
||||
|
||||
struct default_domain;
|
||||
|
||||
struct basic_default_domain;
|
||||
|
||||
struct deduce_domain;
|
||||
|
||||
template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr = wants_basic_expr<typename Domain::proto_generator>::value>
|
||||
struct base_expr;
|
||||
}
|
||||
|
||||
using namespace domainns_;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
namespace exprns_
|
||||
{
|
||||
template<typename Tag, typename Args, long Arity = Args::arity>
|
||||
struct basic_expr;
|
||||
|
||||
template<typename Tag, typename Args, long Arity = Args::arity>
|
||||
struct expr;
|
||||
|
||||
template<
|
||||
typename Expr
|
||||
, typename Derived
|
||||
, typename Domain = default_domain
|
||||
, long Arity = Expr::proto_arity_c
|
||||
>
|
||||
struct extends;
|
||||
|
||||
template<typename This, typename Fun, typename Domain>
|
||||
struct virtual_member;
|
||||
|
||||
struct is_proto_expr;
|
||||
}
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
using exprns_::expr;
|
||||
using exprns_::basic_expr;
|
||||
using exprns_::extends;
|
||||
using exprns_::is_proto_expr;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)>
|
||||
struct or_;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)>
|
||||
struct and_;
|
||||
|
||||
template<typename Grammar>
|
||||
struct not_;
|
||||
|
||||
template<typename Condition, typename Then = _, typename Else = not_<_> >
|
||||
struct if_;
|
||||
|
||||
template<typename Cases, typename Transform = tag_of<_>()>
|
||||
struct switch_;
|
||||
|
||||
template<typename T>
|
||||
struct exact;
|
||||
|
||||
template<typename T>
|
||||
struct convertible_to;
|
||||
|
||||
template<typename Grammar>
|
||||
struct vararg;
|
||||
|
||||
struct pack;
|
||||
|
||||
// Boost bug https://svn.boost.org/trac/boost/ticket/4602
|
||||
//int const N = INT_MAX;
|
||||
int const N = (INT_MAX >> 10);
|
||||
|
||||
namespace context
|
||||
{
|
||||
struct null_context;
|
||||
|
||||
template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
|
||||
struct null_eval;
|
||||
|
||||
struct default_context;
|
||||
|
||||
template<typename Expr, typename Context, typename Tag = typename Expr::proto_tag, long Arity = Expr::proto_arity_c>
|
||||
struct default_eval;
|
||||
|
||||
template<typename Derived, typename DefaultCtx = default_context>
|
||||
struct callable_context;
|
||||
|
||||
template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
|
||||
struct callable_eval;
|
||||
}
|
||||
|
||||
using context::null_context;
|
||||
using context::null_eval;
|
||||
using context::default_context;
|
||||
using context::default_eval;
|
||||
using context::callable_context;
|
||||
using context::callable_eval;
|
||||
|
||||
namespace utility
|
||||
{
|
||||
template<typename T, typename Domain = default_domain>
|
||||
struct literal;
|
||||
}
|
||||
|
||||
using utility::literal;
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template<typename T, typename Domain = default_domain>
|
||||
struct as_expr;
|
||||
|
||||
template<typename T, typename Domain = default_domain>
|
||||
struct as_child;
|
||||
|
||||
template<typename Expr, typename N = mpl::long_<0> >
|
||||
struct child;
|
||||
|
||||
template<typename Expr, long N>
|
||||
struct child_c;
|
||||
|
||||
template<typename Expr>
|
||||
struct left;
|
||||
|
||||
template<typename Expr>
|
||||
struct right;
|
||||
|
||||
template<typename Expr>
|
||||
struct deep_copy;
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct eval;
|
||||
|
||||
template<
|
||||
typename Tag
|
||||
, typename DomainOrA0
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
|
||||
BOOST_PROTO_MAX_ARITY
|
||||
, typename A
|
||||
, = void BOOST_PP_INTERCEPT
|
||||
)
|
||||
, typename Void = void
|
||||
>
|
||||
struct make_expr;
|
||||
|
||||
template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void>
|
||||
struct unpack_expr;
|
||||
|
||||
template<typename T>
|
||||
struct as_env;
|
||||
|
||||
template<typename Env, typename Tag>
|
||||
struct has_env_var;
|
||||
|
||||
template<typename Env, typename Tag>
|
||||
struct env_var;
|
||||
}
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_expr;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_domain;
|
||||
|
||||
template<typename SubDomain, typename SuperDomain>
|
||||
struct is_sub_domain_of;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_env;
|
||||
|
||||
template<typename Expr>
|
||||
struct arity_of;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct domain_of;
|
||||
|
||||
template<typename Expr, typename Grammar>
|
||||
struct matches;
|
||||
|
||||
// Generic expression metafunctions and
|
||||
// grammar elements
|
||||
template<typename Tag, typename Arg>
|
||||
struct unary_expr;
|
||||
|
||||
template<typename Tag, typename Left, typename Right>
|
||||
struct binary_expr;
|
||||
|
||||
template<typename Tag, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)>
|
||||
struct nary_expr;
|
||||
|
||||
// Specific expression metafunctions and
|
||||
// grammar elements, for convenience
|
||||
template<typename T> struct terminal;
|
||||
template<typename T> struct unary_plus;
|
||||
template<typename T> struct negate;
|
||||
template<typename T> struct dereference;
|
||||
template<typename T> struct complement;
|
||||
template<typename T> struct address_of;
|
||||
template<typename T> struct logical_not;
|
||||
template<typename T> struct pre_inc;
|
||||
template<typename T> struct pre_dec;
|
||||
template<typename T> struct post_inc;
|
||||
template<typename T> struct post_dec;
|
||||
|
||||
template<typename T, typename U> struct shift_left;
|
||||
template<typename T, typename U> struct shift_right;
|
||||
template<typename T, typename U> struct multiplies;
|
||||
template<typename T, typename U> struct divides;
|
||||
template<typename T, typename U> struct modulus;
|
||||
template<typename T, typename U> struct plus;
|
||||
template<typename T, typename U> struct minus;
|
||||
template<typename T, typename U> struct less;
|
||||
template<typename T, typename U> struct greater;
|
||||
template<typename T, typename U> struct less_equal;
|
||||
template<typename T, typename U> struct greater_equal;
|
||||
template<typename T, typename U> struct equal_to;
|
||||
template<typename T, typename U> struct not_equal_to;
|
||||
template<typename T, typename U> struct logical_or;
|
||||
template<typename T, typename U> struct logical_and;
|
||||
template<typename T, typename U> struct bitwise_and;
|
||||
template<typename T, typename U> struct bitwise_or;
|
||||
template<typename T, typename U> struct bitwise_xor;
|
||||
template<typename T, typename U> struct comma;
|
||||
template<typename T, typename U> struct mem_ptr;
|
||||
|
||||
template<typename T, typename U> struct assign;
|
||||
template<typename T, typename U> struct shift_left_assign;
|
||||
template<typename T, typename U> struct shift_right_assign;
|
||||
template<typename T, typename U> struct multiplies_assign;
|
||||
template<typename T, typename U> struct divides_assign;
|
||||
template<typename T, typename U> struct modulus_assign;
|
||||
template<typename T, typename U> struct plus_assign;
|
||||
template<typename T, typename U> struct minus_assign;
|
||||
template<typename T, typename U> struct bitwise_and_assign;
|
||||
template<typename T, typename U> struct bitwise_or_assign;
|
||||
template<typename T, typename U> struct bitwise_xor_assign;
|
||||
template<typename T, typename U> struct subscript;
|
||||
template<typename T, typename U> struct member;
|
||||
template<typename T, typename U, typename V> struct if_else_;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)>
|
||||
struct function;
|
||||
|
||||
namespace functional
|
||||
{
|
||||
struct left;
|
||||
struct right;
|
||||
struct eval;
|
||||
struct deep_copy;
|
||||
|
||||
template<typename Domain = default_domain>
|
||||
struct as_expr;
|
||||
|
||||
template<typename Domain = default_domain>
|
||||
struct as_child;
|
||||
|
||||
template<typename N = mpl::long_<0> >
|
||||
struct child;
|
||||
|
||||
template<long N>
|
||||
struct child_c;
|
||||
|
||||
struct as_env;
|
||||
|
||||
template<typename Tag>
|
||||
struct has_env_var;
|
||||
|
||||
template<typename Tag>
|
||||
struct env_var;
|
||||
|
||||
template<typename Tag, typename Domain = deduce_domain>
|
||||
struct make_expr;
|
||||
|
||||
template<typename Tag, typename Domain = deduce_domain>
|
||||
struct unpack_expr;
|
||||
|
||||
typedef make_expr<tag::terminal> make_terminal;
|
||||
typedef make_expr<tag::unary_plus> make_unary_plus;
|
||||
typedef make_expr<tag::negate> make_negate;
|
||||
typedef make_expr<tag::dereference> make_dereference;
|
||||
typedef make_expr<tag::complement> make_complement;
|
||||
typedef make_expr<tag::address_of> make_address_of;
|
||||
typedef make_expr<tag::logical_not> make_logical_not;
|
||||
typedef make_expr<tag::pre_inc> make_pre_inc;
|
||||
typedef make_expr<tag::pre_dec> make_pre_dec;
|
||||
typedef make_expr<tag::post_inc> make_post_inc;
|
||||
typedef make_expr<tag::post_dec> make_post_dec;
|
||||
typedef make_expr<tag::shift_left> make_shift_left;
|
||||
typedef make_expr<tag::shift_right> make_shift_right;
|
||||
typedef make_expr<tag::multiplies> make_multiplies;
|
||||
typedef make_expr<tag::divides> make_divides;
|
||||
typedef make_expr<tag::modulus> make_modulus;
|
||||
typedef make_expr<tag::plus> make_plus;
|
||||
typedef make_expr<tag::minus> make_minus;
|
||||
typedef make_expr<tag::less> make_less;
|
||||
typedef make_expr<tag::greater> make_greater;
|
||||
typedef make_expr<tag::less_equal> make_less_equal;
|
||||
typedef make_expr<tag::greater_equal> make_greater_equal;
|
||||
typedef make_expr<tag::equal_to> make_equal_to;
|
||||
typedef make_expr<tag::not_equal_to> make_not_equal_to;
|
||||
typedef make_expr<tag::logical_or> make_logical_or;
|
||||
typedef make_expr<tag::logical_and> make_logical_and;
|
||||
typedef make_expr<tag::bitwise_and> make_bitwise_and;
|
||||
typedef make_expr<tag::bitwise_or> make_bitwise_or;
|
||||
typedef make_expr<tag::bitwise_xor> make_bitwise_xor;
|
||||
typedef make_expr<tag::comma> make_comma;
|
||||
typedef make_expr<tag::mem_ptr> make_mem_ptr;
|
||||
typedef make_expr<tag::assign> make_assign;
|
||||
typedef make_expr<tag::shift_left_assign> make_shift_left_assign;
|
||||
typedef make_expr<tag::shift_right_assign> make_shift_right_assign;
|
||||
typedef make_expr<tag::multiplies_assign> make_multiplies_assign;
|
||||
typedef make_expr<tag::divides_assign> make_divides_assign;
|
||||
typedef make_expr<tag::modulus_assign> make_modulus_assign;
|
||||
typedef make_expr<tag::plus_assign> make_plus_assign;
|
||||
typedef make_expr<tag::minus_assign> make_minus_assign;
|
||||
typedef make_expr<tag::bitwise_and_assign> make_bitwise_and_assign;
|
||||
typedef make_expr<tag::bitwise_or_assign> make_bitwise_or_assign;
|
||||
typedef make_expr<tag::bitwise_xor_assign> make_bitwise_xor_assign;
|
||||
typedef make_expr<tag::subscript> make_subscript;
|
||||
typedef make_expr<tag::if_else_> make_if_else;
|
||||
typedef make_expr<tag::function> make_function;
|
||||
|
||||
struct flatten;
|
||||
struct make_pair;
|
||||
struct first;
|
||||
struct second;
|
||||
struct at;
|
||||
struct pop_front;
|
||||
struct push_front;
|
||||
struct pop_back;
|
||||
struct push_back;
|
||||
struct reverse;
|
||||
}
|
||||
|
||||
typedef functional::flatten _flatten;
|
||||
typedef functional::make_pair _make_pair;
|
||||
typedef functional::first _first;
|
||||
typedef functional::second _second;
|
||||
typedef functional::pop_front _at;
|
||||
typedef functional::pop_front _pop_front;
|
||||
typedef functional::push_front _push_front;
|
||||
typedef functional::pop_back _pop_back;
|
||||
typedef functional::push_back _push_back;
|
||||
typedef functional::reverse _reverse;
|
||||
typedef functional::eval _eval;
|
||||
struct _deep_copy;
|
||||
|
||||
typedef functional::make_expr<tag::terminal> _make_terminal;
|
||||
typedef functional::make_expr<tag::unary_plus> _make_unary_plus;
|
||||
typedef functional::make_expr<tag::negate> _make_negate;
|
||||
typedef functional::make_expr<tag::dereference> _make_dereference;
|
||||
typedef functional::make_expr<tag::complement> _make_complement;
|
||||
typedef functional::make_expr<tag::address_of> _make_address_of;
|
||||
typedef functional::make_expr<tag::logical_not> _make_logical_not;
|
||||
typedef functional::make_expr<tag::pre_inc> _make_pre_inc;
|
||||
typedef functional::make_expr<tag::pre_dec> _make_pre_dec;
|
||||
typedef functional::make_expr<tag::post_inc> _make_post_inc;
|
||||
typedef functional::make_expr<tag::post_dec> _make_post_dec;
|
||||
typedef functional::make_expr<tag::shift_left> _make_shift_left;
|
||||
typedef functional::make_expr<tag::shift_right> _make_shift_right;
|
||||
typedef functional::make_expr<tag::multiplies> _make_multiplies;
|
||||
typedef functional::make_expr<tag::divides> _make_divides;
|
||||
typedef functional::make_expr<tag::modulus> _make_modulus;
|
||||
typedef functional::make_expr<tag::plus> _make_plus;
|
||||
typedef functional::make_expr<tag::minus> _make_minus;
|
||||
typedef functional::make_expr<tag::less> _make_less;
|
||||
typedef functional::make_expr<tag::greater> _make_greater;
|
||||
typedef functional::make_expr<tag::less_equal> _make_less_equal;
|
||||
typedef functional::make_expr<tag::greater_equal> _make_greater_equal;
|
||||
typedef functional::make_expr<tag::equal_to> _make_equal_to;
|
||||
typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to;
|
||||
typedef functional::make_expr<tag::logical_or> _make_logical_or;
|
||||
typedef functional::make_expr<tag::logical_and> _make_logical_and;
|
||||
typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and;
|
||||
typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or;
|
||||
typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor;
|
||||
typedef functional::make_expr<tag::comma> _make_comma;
|
||||
typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr;
|
||||
typedef functional::make_expr<tag::assign> _make_assign;
|
||||
typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign;
|
||||
typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign;
|
||||
typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign;
|
||||
typedef functional::make_expr<tag::divides_assign> _make_divides_assign;
|
||||
typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign;
|
||||
typedef functional::make_expr<tag::plus_assign> _make_plus_assign;
|
||||
typedef functional::make_expr<tag::minus_assign> _make_minus_assign;
|
||||
typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign;
|
||||
typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign;
|
||||
typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign;
|
||||
typedef functional::make_expr<tag::subscript> _make_subscript;
|
||||
typedef functional::make_expr<tag::if_else_> _make_if_else;
|
||||
typedef functional::make_expr<tag::function> _make_function;
|
||||
|
||||
template<typename T>
|
||||
struct is_callable;
|
||||
|
||||
template<typename T>
|
||||
struct is_transform;
|
||||
|
||||
template<typename T>
|
||||
struct is_aggregate;
|
||||
|
||||
#define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_;
|
||||
#define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_;
|
||||
#define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_;
|
||||
#define BOOST_PROTO_USE_BASIC_EXPR() typedef void proto_use_basic_expr_;
|
||||
|
||||
struct callable
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
};
|
||||
|
||||
namespace envns_
|
||||
{
|
||||
struct key_not_found;
|
||||
|
||||
struct empty_env;
|
||||
|
||||
typedef int empty_state;
|
||||
|
||||
template<typename Tag, typename Value, typename Base = empty_env>
|
||||
struct env;
|
||||
|
||||
struct data_type;
|
||||
|
||||
struct transforms_type;
|
||||
}
|
||||
|
||||
using envns_::key_not_found;
|
||||
using envns_::empty_env;
|
||||
using envns_::empty_state;
|
||||
using envns_::env;
|
||||
using envns_::data_type;
|
||||
using envns_::transforms_type;
|
||||
|
||||
struct external_transform;
|
||||
|
||||
template<typename PrimitiveTransform = void, typename X = void>
|
||||
struct transform;
|
||||
|
||||
template<typename Grammar, typename Fun = Grammar>
|
||||
struct when;
|
||||
|
||||
template<typename Fun>
|
||||
struct otherwise;
|
||||
|
||||
template<typename Fun>
|
||||
struct call;
|
||||
|
||||
template<typename Fun>
|
||||
struct make;
|
||||
|
||||
template<typename PrimitiveTransform>
|
||||
struct protect;
|
||||
|
||||
template<typename T>
|
||||
struct noinvoke;
|
||||
|
||||
template<typename Fun>
|
||||
struct lazy;
|
||||
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct fold;
|
||||
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct reverse_fold;
|
||||
|
||||
// Q: can we replace fold_tree with fold<flatten(_), state, fun> ?
|
||||
// A: once segmented Fusion works well.
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct fold_tree;
|
||||
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct reverse_fold_tree;
|
||||
|
||||
template<typename Grammar, typename Domain = deduce_domain>
|
||||
struct pass_through;
|
||||
|
||||
template<typename Grammar = detail::_default>
|
||||
struct _default;
|
||||
|
||||
struct _expr;
|
||||
struct _state;
|
||||
struct _data;
|
||||
|
||||
struct _value;
|
||||
|
||||
struct _void;
|
||||
|
||||
template<typename T, T I>
|
||||
struct integral_c;
|
||||
|
||||
template<char I>
|
||||
struct char_;
|
||||
|
||||
template<int I>
|
||||
struct int_;
|
||||
|
||||
template<long I>
|
||||
struct long_;
|
||||
|
||||
template<std::size_t I>
|
||||
struct size_t;
|
||||
|
||||
template<int I>
|
||||
struct _child_c;
|
||||
|
||||
typedef _child_c<0> _child0;
|
||||
typedef _child_c<1> _child1;
|
||||
typedef _child0 _child;
|
||||
typedef _child0 _left;
|
||||
typedef _child1 _right;
|
||||
|
||||
// _child2, _child3, _child4, ...
|
||||
#define M0(Z, N, DATA) typedef _child_c<N> BOOST_PP_CAT(_child, N);
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
2
|
||||
, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY)
|
||||
, M0
|
||||
, ~
|
||||
)
|
||||
#undef M0
|
||||
|
||||
struct _byref;
|
||||
struct _byval;
|
||||
|
||||
template<typename Tag>
|
||||
struct _env_var;
|
||||
|
||||
struct _env;
|
||||
|
||||
template<typename T>
|
||||
struct is_extension;
|
||||
|
||||
namespace exops = exprns_;
|
||||
|
||||
}} // namespace boost::proto
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,22 @@
|
||||
/* boost random/detail/enable_warnings.hpp header file
|
||||
*
|
||||
* Copyright Steven Watanabe 2009
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See http://www.boost.org for most recent version including documentation.
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
*/
|
||||
|
||||
// No #include guard. This header is intended to be included multiple times.
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_GCC) && BOOST_GCC >= 40600
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
@@ -0,0 +1,54 @@
|
||||
// (C) Copyright John Maddock 2007.
|
||||
// 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)
|
||||
//
|
||||
// This file is machine generated, do not edit by hand
|
||||
|
||||
// Polynomial evaluation using Horners rule
|
||||
#ifndef BOOST_MATH_TOOLS_POLY_RAT_3_HPP
|
||||
#define BOOST_MATH_TOOLS_POLY_RAT_3_HPP
|
||||
|
||||
namespace boost{ namespace math{ namespace tools{ namespace detail{
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(0);
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(a[0]) / static_cast<V>(b[0]);
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>((a[0] * z + a[1]) / (b[0] * z + b[1]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0]));
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
return static_cast<V>(((a[0] * z + a[1]) * z + a[2]) / ((b[0] * z + b[1]) * z + b[2]));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}}}} // namespaces
|
||||
|
||||
#endif // include guard
|
||||
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,96 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/util/n_ary_helper.hpp
|
||||
|
||||
Macros to generate scale_sumN and for_eachN functors.
|
||||
|
||||
Copyright 2013 Karsten Ahnert
|
||||
Copyright 2013 Mario Mulansky
|
||||
Copyright 2013 Pascal Germroth
|
||||
|
||||
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_ODEINT_UTIL_N_ARY_HELPER_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_UTIL_N_ARY_HELPER_HPP_INCLUDED
|
||||
|
||||
#include <boost/preprocessor/repetition.hpp>
|
||||
|
||||
// like BOOST_PP_ENUM_SHIFTED but with a comma in front like _TRAILING
|
||||
#define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_PARAMS(count, param) \
|
||||
BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \
|
||||
BOOST_PP_ENUM_SHIFTED_PARAMS(count, param)
|
||||
|
||||
#define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_BINARY_PARAMS(count, p1, p2) \
|
||||
BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \
|
||||
BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(count, p1, p2)
|
||||
|
||||
// like BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(n, p1, p2) but p2 is shifted left.
|
||||
// generate "p1 ## 0 = p2, p1 ## 1 = p3 ## 0, p1 ## 2 = p3 ## 1"
|
||||
#define BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS(count, p1, p2, p3) \
|
||||
BOOST_PP_ENUM(count, BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS_, (p1, p2, p3))
|
||||
#define BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS_(z, n, data) \
|
||||
BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, data), n) \
|
||||
BOOST_PP_IF(n, \
|
||||
BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 2, data), BOOST_PP_DEC(n)), \
|
||||
BOOST_PP_TUPLE_ELEM(3, 1, data))
|
||||
|
||||
// like BOOST_PP_ENUM_BINARY_PARAMS(n, p1, p2) but with statements.
|
||||
// "p1 ## 0 p2 ## 0 ; p1 ## 1 p2 ## 1 ; ..."
|
||||
#define BOOST_ODEINT_ENUM_BINARY_STATEMENTS(count, p1, p2) \
|
||||
BOOST_PP_REPEAT(count, BOOST_ODEINT_ENUM_BINARY_STATEMENTS_, (p1, p2))
|
||||
#define BOOST_ODEINT_ENUM_BINARY_STATEMENTS_(z, n, data) \
|
||||
BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n) \
|
||||
BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n) ;
|
||||
|
||||
// like BOOST_PP_ENUM_BINARY_PARAMS(n, p1, p2) but p2 is in parens.
|
||||
// "p1 ## 0 (p2 ## 0) , p1 ## 1 (p2 ## 1) , ..."
|
||||
#define BOOST_ODEINT_ENUM_UNARY_CALLS(count, p1, p2) \
|
||||
BOOST_PP_ENUM(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2))
|
||||
#define BOOST_ODEINT_ENUM_SHIFTED_UNARY_CALLS(count, p1, p2) \
|
||||
BOOST_PP_ENUM_SHIFTED(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2))
|
||||
#define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_UNARY_CALLS(count, p1, p2) \
|
||||
BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \
|
||||
BOOST_PP_ENUM_SHIFTED(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2))
|
||||
#define BOOST_ODEINT_ENUM_UNARY_CALLS_(z, n, data) \
|
||||
BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n) \
|
||||
( BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n) )
|
||||
|
||||
|
||||
// maximum arity + 1 for scale_sum and for_each
|
||||
#define BOOST_ODEINT_N_ARY_MAX 16
|
||||
|
||||
|
||||
// generate scale_sum1 to scale_sumN, operator body generated by macro(N)
|
||||
#define BOOST_ODEINT_GEN_SCALE_SUM(macro) \
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_ODEINT_N_ARY_MAX, BOOST_ODEINT_GEN_SCALE_SUM_, macro)
|
||||
#define BOOST_ODEINT_GEN_SCALE_SUM_(z, n, macro) \
|
||||
template< BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS(n, class Fac, = double, = Fac) > \
|
||||
struct BOOST_PP_CAT(scale_sum, n) \
|
||||
{ \
|
||||
BOOST_ODEINT_ENUM_BINARY_STATEMENTS(n, const Fac, m_alpha) \
|
||||
\
|
||||
BOOST_PP_CAT(scale_sum, n) \
|
||||
( BOOST_PP_ENUM_BINARY_PARAMS(n, Fac, alpha) ) \
|
||||
: BOOST_ODEINT_ENUM_UNARY_CALLS(n, m_alpha, alpha) {} \
|
||||
\
|
||||
template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), class T) > \
|
||||
void operator()( T0 &t0 \
|
||||
BOOST_ODEINT_ENUM_TRAILING_SHIFTED_BINARY_PARAMS(BOOST_PP_INC(n), const T, &t) \
|
||||
) const \
|
||||
{ macro(n) } \
|
||||
typedef void result_type; \
|
||||
};
|
||||
|
||||
// generate for_each1 to for_eachN, body generated by macro(N)
|
||||
#define BOOST_ODEINT_GEN_FOR_EACH(macro) \
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_ODEINT_N_ARY_MAX, BOOST_ODEINT_GEN_FOR_EACH_, macro)
|
||||
#define BOOST_ODEINT_GEN_FOR_EACH_(z, n, macro) \
|
||||
template< BOOST_PP_ENUM_PARAMS(n, class S) , class Op > \
|
||||
static void for_each##n ( BOOST_PP_ENUM_BINARY_PARAMS(n, S, &s) , Op op ) \
|
||||
{ macro(n) }
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,23 @@
|
||||
#ifndef TRACE_FILE_HPP_
|
||||
#define TRACE_FILE_HPP_
|
||||
|
||||
#include "pimpl_h.hpp"
|
||||
|
||||
class QString;
|
||||
|
||||
class TraceFile final
|
||||
{
|
||||
public:
|
||||
explicit TraceFile (QString const& TraceFile_file_path);
|
||||
~TraceFile ();
|
||||
|
||||
// copying not allowed
|
||||
TraceFile (TraceFile const&) = delete;
|
||||
TraceFile& operator = (TraceFile const&) = delete;
|
||||
|
||||
private:
|
||||
class impl;
|
||||
pimpl<impl> m_;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,253 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/iterator/detail/adaptive_iterator_impl.hpp
|
||||
|
||||
[begin_description]
|
||||
tba.
|
||||
[end_description]
|
||||
|
||||
Copyright 2009-2012 Karsten Ahnert
|
||||
Copyright 2009-2012 Mario Mulansky
|
||||
|
||||
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_ODEINT_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED
|
||||
#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED
|
||||
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <boost/numeric/odeint/util/unit_helper.hpp>
|
||||
#include <boost/numeric/odeint/util/copy.hpp>
|
||||
#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
|
||||
#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
|
||||
template< class Iterator , class Stepper , class System , class State , typename Tag , typename StepperTag >
|
||||
class adaptive_iterator_impl;
|
||||
|
||||
/*
|
||||
* Specilization for controlled steppers
|
||||
*/
|
||||
/**
|
||||
* \brief ODE Iterator with adaptive step size control. The value type of this iterator is the state type of the stepper.
|
||||
*
|
||||
* Implements an ODE iterator with adaptive step size control. Uses controlled steppers. adaptive_iterator is a model
|
||||
* of single-pass iterator.
|
||||
*
|
||||
* The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
|
||||
*
|
||||
* \tparam Stepper The stepper type which should be used during the iteration.
|
||||
* \tparam System The type of the system function (ODE) which should be solved.
|
||||
*/
|
||||
template< class Iterator , class Stepper , class System , class State , typename Tag >
|
||||
class adaptive_iterator_impl< Iterator , Stepper , System , State , Tag , controlled_stepper_tag >
|
||||
: public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
|
||||
{
|
||||
private:
|
||||
|
||||
|
||||
typedef Stepper stepper_type;
|
||||
typedef System system_type;
|
||||
typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
|
||||
typedef State state_type;
|
||||
typedef typename traits::time_type< stepper_type >::type time_type;
|
||||
typedef typename traits::value_type< stepper_type >::type ode_value_type;
|
||||
#ifndef DOXYGEN_SKIP
|
||||
typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
|
||||
#endif
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
* \brief Constructs an adaptive_iterator. This constructor should be used to construct the begin iterator.
|
||||
*
|
||||
* \param stepper The stepper to use during the iteration.
|
||||
* \param sys The system function (ODE) to solve.
|
||||
* \param s The initial state. adaptive_iterator stores a reference of s and changes its value during the iteration.
|
||||
* \param t The initial time.
|
||||
* \param t_end The end time, at which the iteration should stop.
|
||||
* \param dt The initial time step.
|
||||
*/
|
||||
adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt )
|
||||
: base_type( stepper , sys , t , dt ) , m_t_end( t_end ) , m_state( &s )
|
||||
{
|
||||
if( detail::less_with_sign( this->m_t_end , this->m_t , this->m_dt ) )
|
||||
this->m_at_end = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator.
|
||||
*
|
||||
* \param stepper The stepper to use during the iteration.
|
||||
* \param sys The system function (ODE) to solve.
|
||||
* \param s The initial state. adaptive_iterator store a reference of s and changes its value during the iteration.
|
||||
*/
|
||||
adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
|
||||
: base_type( stepper , sys ) , m_state( &s ) { }
|
||||
|
||||
protected:
|
||||
|
||||
friend class boost::iterator_core_access;
|
||||
|
||||
void increment()
|
||||
{
|
||||
if( detail::less_with_sign( this->m_t , this->m_t_end , this->m_dt) )
|
||||
{
|
||||
if( detail::less_with_sign( this->m_t_end ,
|
||||
static_cast<time_type>(this->m_t + this->m_dt) ,
|
||||
this->m_dt ) )
|
||||
{
|
||||
this->m_dt = this->m_t_end - this->m_t;
|
||||
}
|
||||
unwrapped_stepper_type &stepper = this->m_stepper;
|
||||
const size_t max_attempts = 1000;
|
||||
size_t trials = 0;
|
||||
controlled_step_result res = success;
|
||||
do
|
||||
{
|
||||
res = stepper.try_step( this->m_system , *( this->m_state ) , this->m_t , this->m_dt );
|
||||
++trials;
|
||||
}
|
||||
while( ( res == fail ) && ( trials < max_attempts ) );
|
||||
if( trials == max_attempts )
|
||||
{
|
||||
BOOST_THROW_EXCEPTION( std::overflow_error( "Adaptive iterator : Maximal number of iterations reached. A step size could not be found." ));
|
||||
}
|
||||
} else {
|
||||
this->m_at_end = true;
|
||||
}
|
||||
}
|
||||
public:
|
||||
const state_type& get_state() const
|
||||
{
|
||||
return *this->m_state;
|
||||
}
|
||||
|
||||
private:
|
||||
time_type m_t_end;
|
||||
state_type* m_state;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Specilization for dense outputer steppers
|
||||
*/
|
||||
/**
|
||||
* \brief ODE Iterator with adaptive step size control. The value type of this iterator is the state type of the stepper.
|
||||
*
|
||||
* Implements an ODE iterator with adaptive step size control. Uses dense-output steppers. adaptive_iterator is a model
|
||||
* of single-pass iterator.
|
||||
*
|
||||
* The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
|
||||
*
|
||||
* \tparam Stepper The stepper type which should be used during the iteration.
|
||||
* \tparam System The type of the system function (ODE) which should be solved.
|
||||
*/
|
||||
template< class Iterator , class Stepper , class System , class State , typename Tag >
|
||||
class adaptive_iterator_impl< Iterator , Stepper , System , State , Tag , dense_output_stepper_tag >
|
||||
: public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
|
||||
{
|
||||
private:
|
||||
|
||||
|
||||
typedef Stepper stepper_type;
|
||||
typedef System system_type;
|
||||
typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
|
||||
typedef State state_type;
|
||||
typedef typename traits::time_type< stepper_type >::type time_type;
|
||||
typedef typename traits::value_type< stepper_type >::type ode_value_type;
|
||||
#ifndef DOXYGEN_SKIP
|
||||
typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
|
||||
#endif
|
||||
|
||||
|
||||
public:
|
||||
|
||||
|
||||
/**
|
||||
* \brief Constructs an adaptive_iterator. This constructor should be used to construct the begin iterator.
|
||||
*
|
||||
* \param stepper The stepper to use during the iteration.
|
||||
* \param sys The system function (ODE) to solve.
|
||||
* \param s The initial state.
|
||||
* \param t The initial time.
|
||||
* \param t_end The end time, at which the iteration should stop.
|
||||
* \param dt The initial time step.
|
||||
*/
|
||||
adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt )
|
||||
: base_type( stepper , sys , t , dt ) , m_t_end( t_end )
|
||||
{
|
||||
if( detail::less_eq_with_sign( this->m_t , this->m_t_end , this->m_dt ) )
|
||||
{
|
||||
unwrapped_stepper_type &st = this->m_stepper;
|
||||
st.initialize( s , this->m_t , this->m_dt );
|
||||
} else {
|
||||
this->m_at_end = true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator.
|
||||
*
|
||||
* \param stepper The stepper to use during the iteration.
|
||||
* \param sys The system function (ODE) to solve.
|
||||
* \param s The initial state.
|
||||
*/
|
||||
adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type& /* s */ )
|
||||
: base_type( stepper , sys ) { }
|
||||
|
||||
protected:
|
||||
|
||||
friend class boost::iterator_core_access;
|
||||
|
||||
void increment()
|
||||
{
|
||||
unwrapped_stepper_type &stepper = this->m_stepper;
|
||||
if( detail::less_with_sign( this->m_t ,
|
||||
this->m_t_end ,
|
||||
stepper.current_time_step() ) )
|
||||
{
|
||||
if( detail::less_with_sign( this->m_t_end ,
|
||||
static_cast<time_type>(this->m_t + stepper.current_time_step()) ,
|
||||
stepper.current_time_step() ) )
|
||||
{
|
||||
// make stpper to end exactly at t_end
|
||||
stepper.initialize( stepper.current_state() , stepper.current_time() ,
|
||||
static_cast<time_type>(this->m_t_end-this->m_t) );
|
||||
}
|
||||
stepper.do_step( this->m_system );
|
||||
this->m_t = stepper.current_time();
|
||||
} else { // we have reached t_end
|
||||
this->m_at_end = true;
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
const state_type& get_state() const
|
||||
{
|
||||
const unwrapped_stepper_type &stepper = this->m_stepper;
|
||||
return stepper.current_state();
|
||||
}
|
||||
|
||||
private:
|
||||
time_type m_t_end;
|
||||
};
|
||||
|
||||
} // namespace odeint
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED
|
||||
Reference in New Issue
Block a user