Utility_Tuple.h File Reference

#include <hydra/detail/Config.h>
#include <hydra/Types.h>
#include <hydra/detail/utility/Generic.h>
#include <hydra/detail/TagTraits.h>
#include <hydra/detail/FunctorTraits.h>
#include <hydra/Parameter.h>
#include <hydra/detail/external/hydra_thrust/tuple.h>
#include <hydra/detail/external/hydra_thrust/detail/type_traits.h>
#include <hydra/detail/external/hydra_thrust/iterator/detail/tuple_of_iterator_references.h>
#include <type_traits>
#include <array>

Include dependency graph for Utility_Tuple.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	hydra::detail::CompareTuples< N, COM >
struct	hydra::detail::is_homogeneous< A, Tuple >
struct	hydra::detail::is_homogeneous_base< A, Tp, I >
struct	hydra::detail::is_homogeneous_base< A, Tp, 0 >
struct	hydra::detail::references_tuple_type< N, T >
struct	hydra::detail::tuple_cat_type< Tuple1, Tuple2 >
struct	hydra::detail::tuple_cat_type< hydra::thrust::detail::tuple_of_iterator_references< T1... >, hydra::thrust::detail::tuple_of_iterator_references< T2... > >
struct	hydra::detail::tuple_cat_type< hydra::thrust::tuple< T1... >, hydra::thrust::tuple< T2... > >
struct	hydra::detail::tuple_type< N, T >

Namespaces
	hydra
	Generic policies definition.
	hydra::detail
	hydra::detail::utils

Functions
template<typename R , typename T , size_t I>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I==hydra::thrust::tuple_size< T >::value), void >::type	hydra::detail::_get_element (const size_t, T &, R *&)
template<typename R , typename T , size_t I = 0>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< hydra::thrust::tuple_size< T >::value), void >::type	hydra::detail::_get_element (const size_t index, T &t, R *&ptr)
template<typename TupleType , typename ArrayType , size_t I>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==hydra::thrust::tuple_size< TupleType >::value, void >::type	hydra::detail::utils::_tuple_to_array (TupleType const &, ArrayType *)
template<typename Return_Type , typename ArgType , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value >::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::accumulate (ArgType &x, hydra::thrust::tuple< Tp... > &t)
template<typename Return_Type , typename ArgType , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value >::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::accumulate (ArgType const &x, hydra::thrust::tuple< Tp... > const &t)
template<typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value>::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::accumulate2 (ArgType1 &x, ArgType2 &y, hydra::thrust::tuple< Tp... > &t)
template<typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value>::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::accumulate2 (ArgType1 const &x, ArgType2 const &y, hydra::thrust::tuple< Tp... > const &t)
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::add_parameters_in_tuple (std::vector< hydra::Parameter *> &, hydra::thrust::tuple< Tp... > &)
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::add_parameters_in_tuple (std::vector< hydra::Parameter *> &user_parameters, hydra::thrust::tuple< Tp... > &t)
template<size_t I, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I==sizeof...(T)), void >::type	hydra::detail::add_tuple_values (GReal_t &, hydra::thrust::tuple< T... > const &)
template<size_t I = 0, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(T)), void >::type	hydra::detail::add_tuple_values (GReal_t &result, hydra::thrust::tuple< T... > const &tpl)
template<typename T , size_t N>
auto	hydra::detail::arrayToTuple (std::array< T, N >const &Array) -> decltype(arrayToTupleHelper(Array, make_index_sequence< N >
template<typename T , size_t N>
__hydra_host__ __hydra_device__ auto	hydra::detail::arrayToTuple (T *Array) -> decltype(arrayToTupleHelper(Array, make_index_sequence< N >
template<typename T , size_t... Is>
auto	hydra::detail::arrayToTupleHelper (std::array< T, sizeof...(Is)>const &Array, index_sequence< Is... >) -> decltype(hydra::thrust::make_tuple(Array[Is]...))
template<typename T , size_t... Indices>
__hydra_host__ __hydra_device__ auto	hydra::detail::arrayToTupleHelper (T *Array, index_sequence< Indices... >) -> decltype(hydra::thrust::make_tuple(Array[Indices]...))
template<size_t I, typename ArrayType , typename FistType , typename ... OtherTypes>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==(sizeof...(OtherTypes)+1) &&std::is_convertible< FistType, ArrayType >::value &&all_true< std::is_convertible< OtherTypes, ArrayType >::value... >::value, void >::type	hydra::detail::assignArrayToTuple (hydra::thrust::tuple< FistType, OtherTypes... > &, ArrayType const *)
template<size_t I = 0, typename ArrayType , typename FistType , typename ... OtherTypes>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(OtherTypes)+1) &&std::is_convertible< FistType, ArrayType >::value &&all_true< std::is_convertible< OtherTypes, ArrayType >::value... >::value, void >::type	hydra::detail::assignArrayToTuple (hydra::thrust::tuple< FistType, OtherTypes... > &t, ArrayType const *Array)
template<size_t I, typename ArrayType , typename FistType , typename ... OtherTypes>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==(sizeof...(OtherTypes)+1) &&std::is_convertible< FistType, ArrayType >::value &&all_true< std::is_convertible< OtherTypes, ArrayType >::value... >::value, void >::type	hydra::detail::assignArrayToTuple (hydra::thrust::detail::tuple_of_iterator_references< FistType, OtherTypes... > &, ArrayType const *)
template<size_t I = 0, typename ArrayType , typename FistType , typename ... OtherTypes>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(OtherTypes)+1) &&std::is_convertible< FistType, ArrayType >::value &&all_true< std::is_convertible< OtherTypes, ArrayType >::value... >::value, void >::type	hydra::detail::assignArrayToTuple (hydra::thrust::detail::tuple_of_iterator_references< FistType, OtherTypes... > &t, ArrayType const *Array)
template<size_t I, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I==sizeof...(Tail)+1) &&std::is_convertible< Head, Type >::value &&all_true< std::is_convertible< Tail, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::tuple< Head, Tail... > const &, Type(&)[sizeof...(Tail)+1])
template<size_t I = 0, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I< sizeof...(Tail)+1) &&std::is_convertible< Head, Type >::value &&all_true< std::is_convertible< Tail, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::tuple< Head, Tail... > const &Tuple, Type(&Array)[sizeof...(Tail)+1])
template<size_t I, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I==sizeof...(Tail)+1) &&std::is_convertible< Head, Type >::value &&all_true< std::is_convertible< Tail, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::tuple< Head, Tail... > const &, std::array< Type, sizeof...(Tail)+1 > &)
template<size_t I = 0, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I< sizeof...(Tail)+1) &&std::is_convertible< Head, Type >::value &&all_true< std::is_convertible< Tail, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::tuple< Head, Tail... > const &Tuple, std::array< Type, sizeof...(Tail)+1 > &Array)
template<size_t I, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I==sizeof...(Tail)+1) &&std::is_convertible< typename remove_device_reference< Head >::type, Type >::value &&all_true< std::is_convertible< typename remove_device_reference< Tail >::type, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::detail::tuple_of_iterator_references< Head, Tail... > const &, Type(&)[sizeof...(Tail)+1])
template<size_t I = 0, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I< sizeof...(Tail)+1) &&std::is_convertible< typename remove_device_reference< Head >::type, Type >::value &&all_true< std::is_convertible< typename remove_device_reference< Tail >::type, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::detail::tuple_of_iterator_references< Head, Tail... > const &Tuple, Type(&Array)[sizeof...(Tail)+1])
template<size_t I, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I==sizeof...(Tail)+1) &&std::is_convertible< typename remove_device_reference< Head >::type, Type >::value &&all_true< std::is_convertible< typename remove_device_reference< Tail >::type, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::detail::tuple_of_iterator_references< Head, Tail... > const &, std::array< Type, sizeof...(Tail)+1 > &)
template<size_t I = 0, typename Type , typename Head , typename ... Tail>
__hydra_host__ __hydra_device__ std::enable_if<(I< sizeof...(Tail)+1) &&std::is_convertible< typename remove_device_reference< Head >::type, Type >::value &&all_true< std::is_convertible< typename remove_device_reference< Tail >::type, Type >::value ... >::value, void >::type	hydra::detail::assignTupleToArray (hydra::thrust::detail::tuple_of_iterator_references< Head, Tail... > const &Tuple, std::array< Type, sizeof...(Tail)+1 > &Array)
template<unsigned int I = 0, typename FuncT , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::eval_on_tuple_element (int, hydra::thrust::tuple< Tp... > const &, FuncT const &)
template<unsigned int I = 0, typename FuncT , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::eval_on_tuple_element (int index, hydra::thrust::tuple< Tp... > const &t, FuncT const &f)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::eval_tuple_element (Return_Type &, int, hydra::thrust::tuple< Tp... > const &, ArgType const &)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::eval_tuple_element (Return_Type &r, int index, hydra::thrust::tuple< Tp... > const &t, ArgType const &arg)
template<typename Type , typename Tuple >
__hydra_host__ __hydra_device__ Type	hydra::detail::extract (const int idx, const Tuple &t)
template<typename R , typename ... T>
__hydra_host__ __hydra_device__ R &	hydra::detail::get_element (const size_t index, hydra::thrust::tuple< T... > &t)
template<unsigned int I = 0, typename T , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::get_tuple_element (const int, hydra::thrust::tuple< Tp... > const &, T &)
template<unsigned int I = 0, typename T , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::get_tuple_element (const int index, hydra::thrust::tuple< Tp... > const &t, T &x)
template<typename Iterator , size_t N>
__hydra_host__ auto	hydra::detail::get_zip_iterator (std::array< Iterator, N >const &array_of_iterators) -> decltype(get_zip_iterator_helper(array_of_iterators, make_index_sequence< N >
template<typename IteratorHead , typename IteratorTail , size_t N>
__hydra_host__ auto	hydra::detail::get_zip_iterator (IteratorHead head, std::array< IteratorTail, N >const &array_of_iterators) -> decltype(get_zip_iterator_helper(head, array_of_iterators, make_index_sequence< N >
template<typename Iterator , size_t ... Index>
__hydra_host__ auto	hydra::detail::get_zip_iterator_helper (std::array< Iterator, sizeof ...(Index)>const &array_of_iterators, index_sequence< Index... >) -> decltype(hydra::thrust::make_zip_iterator(hydra::thrust::make_tuple(array_of_iterators[Index]...)))
template<typename IteratorHead , typename IteratorTail , size_t ... Index>
__hydra_host__ auto	hydra::detail::get_zip_iterator_helper (IteratorHead head, std::array< IteratorTail, sizeof ...(Index)>const &array_of_iterators, index_sequence< Index... >) -> decltype(hydra::thrust::make_zip_iterator(hydra::thrust::make_tuple(head, array_of_iterators[Index]...)))
template<typename Tup , typename ArgType , size_t N = hydra::thrust::tuple_size<typename hydra::thrust::detail::remove_reference<Tup>::type>::value>
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke (ArgType &&x, Tup &&tup) -> decltype(invoke_helper(std::forward< ArgType >(x), std::forward< Tup >(tup), make_index_sequence< N >
template<typename Tup , typename ArgType , size_t N = hydra::thrust::tuple_size<typename hydra::thrust::detail::remove_reference<Tup>::type>::value>
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke (ArgType const &x, Tup const &tup) -> decltype(invoke_helper(x, tup, make_index_sequence< N >
template<typename Tup , typename ArgType1 , typename ArgType2 , size_t N = hydra::thrust::tuple_size<typename hydra::thrust::detail::remove_reference<Tup>::type>::value>
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke (ArgType1 &&x, ArgType2 &&y, Tup &&tup) -> decltype(invoke_helper(std::forward< ArgType1 >(x), std::forward< ArgType2 >(y), std::forward< Tup >(tup), make_index_sequence< hydra::thrust::tuple_size< Tup >::value >
template<typename Tup , typename ArgType1 , typename ArgType2 >
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke (ArgType1 const &x, ArgType2 const &y, Tup const &tup) -> decltype(invoke_helper(x, y, tup, make_index_sequence< hydra::thrust::tuple_size< Tup >::value >
template<typename Tup , typename ArgType , size_t ... index>
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke_helper (ArgType &&x, Tup &&tup, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(std::forward< Tup >(tup))(std::forward< ArgType >(x))...))
template<typename Tup , typename ArgType , size_t ... index>
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke_helper (ArgType const &x, Tup const &tup, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(tup)(x)...))
template<typename Tup , typename ArgType1 , typename ArgType2 , size_t ... index>
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke_helper (ArgType1 &&x, ArgType2 &&y, Tup &&tup, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(std::forward< Tup >(tup))(std::forward< ArgType1 >(x), std::forward< ArgType2 >(y))...))
template<typename Tup , typename ArgType1 , typename ArgType2 , size_t ... index>
__hydra_thrust_exec_check_disable__ __hydra_host__ __hydra_device__ auto	hydra::detail::invoke_helper (ArgType1 const &x, ArgType2 const &y, Tup const &tup, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(tup)(x, y)...))
return	hydra::detail::invoke_helper (x, y, tup, make_index_sequence< Size > { })
template<typename Tup , typename ArgType >
__hydra_host__ __hydra_device__ auto	hydra::detail::invoke_normalized (ArgType const &x, Tup const &tup) -> decltype(invoke_helper(x, tup, make_index_sequence< hydra::thrust::tuple_size< Tup >::value >
template<typename Tup , typename ArgType , size_t N = hydra::thrust::tuple_size<typename hydra::thrust::detail::remove_reference<Tup>::type>::value>
__hydra_host__ __hydra_device__ auto	hydra::detail::invoke_normalized (ArgType &&x, Tup &&tup) -> decltype(invoke_helper(std::forward< ArgType >(x), std::forward< Tup >(tup), make_index_sequence< N >
template<typename Tup , typename ArgType , size_t ... index>
__hydra_host__ __hydra_device__ auto	hydra::detail::invoke_normalized_helper (ArgType const &x, Tup const &tup, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(tup)(x)...))
return	hydra::detail::invoke_normalized_helper (x, tup, make_index_sequence< Size > { })
template<typename Tup , typename ArgType , size_t ... index>
__hydra_host__ __hydra_device__ auto	hydra::detail::invoke_normalized_helper (ArgType &&x, Tup &&tup, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(std::forward< Tup >(tup))(std::forward< ArgType >(x))...))
template<typename ... T>
auto	hydra::detail::make_rtuple (hydra::thrust::tuple< T... > &t) -> hydra::thrust::tuple< T &... >
template<typename ... T, size_t... I>
auto	hydra::detail::make_rtuple_helper (hydra::thrust::tuple< T... > &t, index_sequence< I... >) -> hydra::thrust::tuple< T &... >
T ::type TupleType	hydra::detail::make_tuple (T &&value)
template<typename ... T>
__hydra_host__ __hydra_device__ size_t	hydra::detail::max (hydra::thrust::tuple< T... > const &tuple)
template<typename T , typename C , size_t N, size_t I>
__hydra_host__ __hydra_device__ std::enable_if< I==N, void >::type	hydra::detail::max_helper (T const &, C &, size_t &)
	hydra::detail::max_helper< T, C, N, I+1 > (tuple, max_value, max_index)
template<typename ... T>
__hydra_host__ __hydra_device__ auto	hydra::detail::multiply_array_tuple (GReal_t(&fCoefficients)[sizeof...(T)], hydra::thrust::tuple< T... > const &tpl) -> decltype(multiply_array_tuple_helper(fCoefficients, tpl, make_index_sequence< sizeof...(T)>
template<typename Tuple , size_t ... I>
__hydra_host__ __hydra_device__ tuple_type< sizeof...(I), GReal_t >::type	hydra::detail::multiply_array_tuple_helper (GReal_t(&fCoefficients)[sizeof...(I)], Tuple const &tpl, index_sequence< I... >)
template<size_t I = 0, typename Return_Type , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::multiply_tuple (Return_Type &, hydra::thrust::tuple< Tp... > const &)
template<size_t I = 0, typename Return_Type , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::multiply_tuple (Return_Type &r, hydra::thrust::tuple< Tp... >const &t)
template<size_t I = 0, typename Return_Type , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::multiply_tuple (Return_Type &, hydra::thrust::tuple< Tp... > &&)
template<size_t I = 0, typename Return_Type , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::multiply_tuple (Return_Type &r, hydra::thrust::tuple< Tp... > &&t)
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::print_parameters_in_tuple (hydra::thrust::tuple< Tp... > &)
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::print_parameters_in_tuple (hydra::thrust::tuple< Tp... > &t)
template<typename Return_Type , typename ArgType , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value >::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::product (ArgType const &x, hydra::thrust::tuple< Tp... > const &t)
template<typename Return_Type , typename ArgType , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value >::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::product (ArgType &x, hydra::thrust::tuple< Tp... > &t)
template<typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value >::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::product2 (ArgType1 const &x, ArgType2 const &y, hydra::thrust::tuple< Tp... > const &t)
template<typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp, typename = typename hydra::thrust::detail::enable_if<std::is_convertible<Return_Type, double>::value || std::is_constructible<hydra::thrust::complex<double>,Return_Type>::value >::type>
__hydra_host__ __hydra_device__ Return_Type	hydra::detail::product2 (ArgType1 &x, ArgType2 &y, hydra::thrust::tuple< Tp... > &t)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::product_tuple (Return_Type &, hydra::thrust::tuple< Tp... > const &, ArgType const &)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::product_tuple (Return_Type &r, hydra::thrust::tuple< Tp... > const &t, ArgType const &arg)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::product_tuple (Return_Type &, hydra::thrust::tuple< Tp... > &&, ArgType &&)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::product_tuple (Return_Type &r, hydra::thrust::tuple< Tp... > &&t, ArgType &&arg)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::product_tuple2 (Return_Type &, hydra::thrust::tuple< Tp... > const &, ArgType1 const &, ArgType2 const &)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I<(sizeof...(Tp))), void >::type	hydra::detail::product_tuple2 (Return_Type &r, hydra::thrust::tuple< Tp... > const &t, ArgType1 const &arg1, ArgType2 const &arg2)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::product_tuple2 (Return_Type &, hydra::thrust::tuple< Tp... > &&, ArgType1 &&, ArgType2 &&)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I<(sizeof...(Tp))), void >::type	hydra::detail::product_tuple2 (Return_Type &r, hydra::thrust::tuple< Tp... > &&t, ArgType1 &&arg1, ArgType2 &&arg2)
template<size_t I = 0, size_t N, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==N, void >::type	hydra::detail::product_tuple3 (Return_Type &, hydra::thrust::tuple< Tp... > const &, ArgType1 const &, ArgType2 const &)
template<size_t I = 0, size_t N, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< N), void >::type	hydra::detail::product_tuple3 (Return_Type &r, hydra::thrust::tuple< Tp... > const &t, ArgType1 const &arg1, ArgType2 const &arg2)
template<size_t I = 0, size_t N, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==N, void >::type	hydra::detail::product_tuple3 (Return_Type &, hydra::thrust::tuple< Tp... > &&, ArgType1 &&, ArgType2 &&)
template<size_t I = 0, size_t N, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< N), void >::type	hydra::detail::product_tuple3 (Return_Type &r, hydra::thrust::tuple< Tp... > &&t, ArgType1 &&arg1, ArgType2 &&arg2)
template<typename T1 , typename T2 >
void	hydra::detail::ptr_setter (T1 *&ptr, typename hydra::thrust::detail::enable_if< hydra::thrust::detail::is_same< T1, T2 >::value, T2 >::type *el)
template<typename T1 , typename T2 >
void	hydra::detail::ptr_setter (T1 *&, typename hydra::thrust::detail::enable_if<!hydra::thrust::detail::is_same< T1, T2 >::value, T2 >::type *)
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::set_functors_in_tuple (hydra::thrust::tuple< Tp... > &, const std::vector< double > &)
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::set_functors_in_tuple (hydra::thrust::tuple< Tp... > &t, const std::vector< double > &parameters)
template<unsigned int I, typename Ptr , typename ... Tp>
hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::set_ptr_to_tuple_element (const int, std::tuple< Tp... > &, Ptr *&)
template<unsigned int I = 0, typename Ptr , typename ... Tp>
hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::set_ptr_to_tuple_element (const int index, std::tuple< Tp... > &t, Ptr *&ptr)
template<size_t I = 0, typename Array_Type , typename T >
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I==hydra::thrust::tuple_size< T >::value) &&is_homogeneous< Array_Type, T >::value, void >::type	hydra::detail::set_ptrs_to_tuple (T &, Array_Type **)
template<size_t I = 0, typename Array_Type , typename T >
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< hydra::thrust::tuple_size< T >::value) &&is_homogeneous< Array_Type, T >::value, void >::type	hydra::detail::set_ptrs_to_tuple (T &t, Array_Type **Array)
template<unsigned int I = 0, typename T , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::set_tuple_element (const int, hydra::thrust::tuple< Tp... > const &, T &)
template<unsigned int I = 0, typename T , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::set_tuple_element (const int index, hydra::thrust::tuple< Tp... > &t, const T &x)
template<typename ... T1, typename ... T2>
__hydra_host__ __hydra_device__ void	hydra::detail::split_tuple (hydra::thrust::tuple< T1... > &t1, hydra::thrust::tuple< T2... > &t2, hydra::thrust::tuple< T1..., T2... > const &t)
template<size_t N, typename ... T>
__hydra_host__ __hydra_device__ auto	hydra::detail::split_tuple (hydra::thrust::tuple< T... > &t) -> decltype(split_tuple_helper(t, make_index_sequence< N >
template<typename ... T1, typename ... T2, size_t... I1, size_t... I2>
__hydra_host__ __hydra_device__ void	hydra::detail::split_tuple_helper (hydra::thrust::tuple< T1... > &t1, hydra::thrust::tuple< T2... > &t2, hydra::thrust::tuple< T1..., T2... > const &t, index_sequence< I1... >, index_sequence< I2... >)
template<typename ... T, size_t... I1, size_t... I2>
__hydra_host__ __hydra_device__ auto	hydra::detail::split_tuple_helper (hydra::thrust::tuple< T... > &t, index_sequence< I1... >, index_sequence< I2... >) -> decltype(hydra::thrust::make_pair(hydra::thrust::tie(hydra::thrust::get< I1 >(t)...), hydra::thrust::tie(hydra::thrust::get< I2++sizeof...(I1)>(t)...)))
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::sum_tuple (Return_Type &, hydra::thrust::tuple< Tp... > &&, ArgType &&)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::sum_tuple (Return_Type &r, hydra::thrust::tuple< Tp... > &&t, ArgType &&arg)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::sum_tuple (Return_Type &, hydra::thrust::tuple< Tp... > const &, ArgType const &)
template<size_t I = 0, typename Return_Type , typename ArgType , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::sum_tuple (Return_Type &r, hydra::thrust::tuple< Tp... >const &t, ArgType const &arg)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::sum_tuple2 (Return_Type &, hydra::thrust::tuple< Tp... > &&, ArgType1 &&, ArgType2 &&)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::sum_tuple2 (Return_Type &r, hydra::thrust::tuple< Tp... > &&t, ArgType1 &&arg1, ArgType2 &&arg2)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	hydra::detail::sum_tuple2 (Return_Type &, hydra::thrust::tuple< Tp... >const &, ArgType1 const &, ArgType2 const &)
template<size_t I = 0, typename Return_Type , typename ArgType1 , typename ArgType2 , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(Tp)), void >::type	hydra::detail::sum_tuple2 (Return_Type &r, hydra::thrust::tuple< Tp... > const &t, ArgType1 const &arg1, ArgType2 const &arg2)
template<size_t I = 0, typename FistType , typename ... OtherTypes>
hydra::thrust::detail::enable_if< I==(sizeof...(OtherTypes)+1) &&are_all_same< FistType, OtherTypes... >::value, void >::type	hydra::detail::tupleToArray (hydra::thrust::tuple< FistType, OtherTypes... > const &, std::array< FistType, sizeof...(OtherTypes)+1 > &)
template<size_t I = 0, typename FistType , typename ... OtherTypes>
hydra::thrust::detail::enable_if<(I< sizeof...(OtherTypes)+1) &&are_all_same< FistType, OtherTypes... >::value, void >::type	hydra::detail::tupleToArray (hydra::thrust::tuple< FistType, OtherTypes... > const &t, std::array< FistType, sizeof...(OtherTypes)+1 > &Array)
template<size_t I = 0, typename FistType , typename ... OtherTypes>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==(sizeof...(OtherTypes)+1) &&are_all_same< FistType, OtherTypes... >::value, void >::type	hydra::detail::tupleToArray (hydra::thrust::tuple< FistType, OtherTypes... > const &, typename std::remove_reference< FistType >::type *)
template<size_t I = 0, typename FistType , typename ... OtherTypes>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(I< sizeof...(OtherTypes)+1) &&are_all_same< FistType, OtherTypes... >::value, void >::type	hydra::detail::tupleToArray (hydra::thrust::tuple< FistType, OtherTypes... > const &t, typename std::remove_reference< FistType >::type *Array)
template<typename TupleType , typename ArrayType >
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if<(detail::is_instantiation_of< hydra::thrust::tuple, TupleType >::value||detail::is_instantiation_of< hydra::thrust::detail::tuple_of_iterator_references, TupleType >::value), void >::type	hydra::detail::tupleToArray (TupleType const &_tuple, ArrayType *_array)

Variables
	hydra::detail::make_index_sequence< sizeof...(T) -N >
template<typename T , typename C , size_t N, size_t I = 1>
__hydra_host__ __hydra_device__ std::enable_if< I< N, void >::type max_helper(T const &tuple, C &max_value, size_t &max_index){ max_index=max_value > hydra::thrust::get< I >(tuple) ? max_index	hydra::detail::max_value = max_value > hydra::thrust::get<I>(tuple) ? max_value : hydra::thrust::get<I>(tuple)

---

Data Structure Documentation

hydra::detail::references_tuple_type

struct hydra::detail::references_tuple_type

template<size_t N, typename T>
struct hydra::detail::references_tuple_type< N, T >

Collaboration diagram for hydra::detail::references_tuple_type< N, T >:

Data Fields
typedef repeat< T, N, tuple_of_iterator_references >::type	type

hydra::detail::tuple_cat_type

struct hydra::detail::tuple_cat_type

template<typename Tuple1, typename Tuple2>
struct hydra::detail::tuple_cat_type< Tuple1, Tuple2 >

Collaboration diagram for hydra::detail::tuple_cat_type< Tuple1, Tuple2 >:

hydra::detail::tuple_cat_type< hydra::thrust::detail::tuple_of_iterator_references< T1... >, hydra::thrust::detail::tuple_of_iterator_references< T2... > >

struct hydra::detail::tuple_cat_type< hydra::thrust::detail::tuple_of_iterator_references< T1... >, hydra::thrust::detail::tuple_of_iterator_references< T2... > >

template<typename ... T1, typename ... T2>
struct hydra::detail::tuple_cat_type< hydra::thrust::detail::tuple_of_iterator_references< T1... >, hydra::thrust::detail::tuple_of_iterator_references< T2... > >

Collaboration diagram for hydra::detail::tuple_cat_type< hydra::thrust::detail::tuple_of_iterator_references< T1... >, hydra::thrust::detail::tuple_of_iterator_references< T2... > >:

Data Fields
	type

hydra::detail::tuple_cat_type< hydra::thrust::tuple< T1... >, hydra::thrust::tuple< T2... > >

struct hydra::detail::tuple_cat_type< hydra::thrust::tuple< T1... >, hydra::thrust::tuple< T2... > >

template<typename ... T1, typename ... T2>
struct hydra::detail::tuple_cat_type< hydra::thrust::tuple< T1... >, hydra::thrust::tuple< T2... > >

Collaboration diagram for hydra::detail::tuple_cat_type< hydra::thrust::tuple< T1... >, hydra::thrust::tuple< T2... > >:

Data Fields
	type

hydra::detail::tuple_type

struct hydra::detail::tuple_type

template<size_t N, typename T>
struct hydra::detail::tuple_type< N, T >

Collaboration diagram for hydra::detail::tuple_type< N, T >:

Data Fields
typedef repeat< T, N, tuple >::type	type