hydra::detail Namespace Reference

Namespaces
	convolution
	cpp
	cuda
	cufft
	device
	fa_impl
	fftw
	host
	impl
	jacobi
	meld_iterators_ns
	omp
	random
	range
	spline
	stuple_impl
	tbb
	tuple
	tuple_utility
	utils

Data Structures
struct	_merge_and_renumber
struct	_merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > >
class	AddPdfBase
class	AddPdfChecker
struct	AddPdfFunctor
struct	AddResultGenzMalikBoxes
struct	AddStatsPHSP
struct	all_true
struct	all_true<>
struct	append_to_type_seq
struct	append_to_type_seq< T, TT< Ts... > >
struct	are_base_of
struct	are_base_of< Base, T >
struct	are_iterables
struct	are_iterators
struct	AverageMother
struct	AverageMothers
struct	BackendPolicy
struct	BackendPolicy< Backend::Cpp >
struct	BackendPolicy< Backend::Cuda >
struct	BackendPolicy< Backend::Device >
struct	BackendPolicy< Backend::Host >
struct	BackendPolicy< Backend::Omp >
struct	BackendPolicy< Backend::Tbb >
struct	bool_pack
struct	CanConvert
struct	Caster
struct	CheckEnergy
struct	CompareGenzMalikBoxes
struct	CompareTuples
class	CompositeBase
struct	conditions_and
struct	conditions_and< Cond, Conds... >
struct	CovMatrixBinary
struct	CovMatrixUnary
struct	DecayMother
struct	DecayMothers
struct	dimensionality
struct	divide_result
struct	EvalMother
struct	EvalMothers
struct	EvalOnDaughters
struct	EvalOnDaughtersBinary
struct	FCNWeightsReducerUnary
struct	FFTPolicy
struct	FFTPolicy< T, detail::CuFFT >
struct	FFTPolicy< T, detail::FFTW >
struct	find_unique_type
struct	find_unique_type_impl
struct	find_unique_type_impl< I, T >
struct	find_unique_type_impl< I, T, T, Types... >
struct	find_unique_type_impl< I, T, U, Types... >
struct	FlagAcceptReject
	Flags generated events as accepted (1) or rejected (0). More...
class	FlagDaugthers
struct	function_traits
struct	function_traits< ReturnType(ClassType::*)(Args &...)>
struct	function_traits< ReturnType(ClassType::*)(Args...) const >
struct	FunctionArgument
struct	functor_traits
struct	functor_traits< ReturnType(ClassType::*)(Args...) >
struct	functor_traits< ReturnType(ClassType::*)(Args...) const >
struct	GenerateDecay
class	GenzMalikBox
class	GenzMalikBoxResult
struct	GetAxisBinCenter
struct	GetBinCenter
struct	GetBinCenter< T, 1 >
struct	GetGlobalBin
struct	GetGlobalBin< 1, T >
struct	GetSWeight
class	gray_code
struct	has_rng_formula
struct	has_rng_formula< Functor, hydra::thrust::void_t< typename hydra::RngFormula< Functor >::value_type > >
struct	high_bit_mask_t
class	if_then_else
class	if_then_else< false, T1, T2 >
class	if_then_else< true, T1, T2 >
struct	if_then_else_tt
struct	if_then_else_tt< false, T1, T2 >
struct	if_then_else_tt< true, T1, T2 >
struct	index_in_tuple
struct	index_in_tuple< Type, hydra::thrust::tuple< Head, Tail... > >
struct	index_sequence
struct	int_fast_t
struct	int_t
struct	is_device_reference
struct	is_device_reference< hydra::thrust::device_reference< T > >
struct	is_function_argument
struct	is_function_argument< Arg, false >
struct	is_function_argument< Arg, true >
struct	is_function_argument< hydra::thrust::device_reference< Arg >, true >
struct	is_function_argument_pack
struct	is_homogeneous
struct	is_homogeneous_base
struct	is_homogeneous_base< A, Tp, 0 >
struct	is_hydra_composite_functor
struct	is_hydra_composite_functor< T, hydra::thrust::void_t< typename T::hydra_composed_functor_type > >
struct	is_hydra_convertible_to_tuple
struct	is_hydra_convertible_to_tuple< T, typename tag_type< typename T::hydra_convertible_to_tuple_tag >::type >
struct	is_hydra_dense_histogram
struct	is_hydra_dense_histogram< hydra::DenseHistogram< T, N, detail::BackendPolicy< BACKEND >, D > >
struct	is_hydra_estimator
struct	is_hydra_estimator< T, hydra::thrust::void_t< typename T::likelihood_estimator_type > >
struct	is_hydra_functor
struct	is_hydra_functor< Functor, hydra::thrust::void_t< typename Functor::hydra_functor_type, typename Functor::argument_type, typename Functor::return_type > >
struct	is_hydra_integrator
struct	is_hydra_integrator< T, hydra::thrust::void_t< typename T::hydra_integrator_type > >
struct	is_hydra_lambda
struct	is_hydra_lambda< Functor, hydra::thrust::void_t< typename Functor::hydra_lambda_type, typename Functor::argument_type, typename Functor::return_type > >
struct	is_hydra_pdf
struct	is_hydra_pdf< T, hydra::thrust::void_t< typename T::hydra_pdf_type > >
struct	is_hydra_sparse_histogram
struct	is_hydra_sparse_histogram< hydra::SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, D > >
struct	is_hydra_sum_pdf
struct	is_hydra_sum_pdf< T, typename tag_type< typename T::hydra_sum_pdf_tag >::type >
struct	is_instantiation_of
struct	is_instantiation_of< Template, Template< Args... > >
struct	is_intuple
struct	is_intuple< T, hydra::tuple< Head, Tail... > >
struct	is_intuple< T, hydra::tuple<> >
struct	is_iterable
struct	is_iterable< T, hydra::thrust::void_t< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end()), decltype(++std::declval< decltype(hydra::begin(std::declval< T >()))& >()), decltype(*hydra::begin(std::declval< T >())) > >
struct	is_iterator
struct	is_iterator< T, hydra::thrust::void_t< typename std::enable_if< std::is_default_constructible< T >::value, void >::type, typename std::enable_if< std::is_copy_constructible< T >::value, void >::type, typename std::enable_if< std::is_destructible< T >::value, void >::type, decltype(std::declval< T & >()[0]), decltype(std::declval< T & >() -std::declval< T & >()), decltype(++std::declval< T & >()), decltype(*std::declval< T & >()), decltype(std::declval< T & >()==std::declval< T & >()), decltype(std::declval< T & >() !=std::declval< T & >())> >
struct	is_reverse_iterable
struct	is_reverse_iterable< T, hydra::thrust::void_t< decltype(std::declval< T >().rbegin()), decltype(std::declval< T >().rend()), decltype(++std::declval< decltype(hydra::rbegin(std::declval< T >()))& >()), decltype(*hydra::rbegin(std::declval< T >())) > >
struct	is_rng_formula
struct	is_rng_formula< hydra::RngFormula< Formula > >
struct	is_specialization
struct	is_specialization< REF< Args... >, REF >
struct	is_tuple
struct	is_tuple< hydra::tuple< T... > >
struct	is_tuple_of_function_arguments
struct	is_tuple_of_function_arguments< hydra::thrust::detail::tuple_of_iterator_references< ArgTypes &... > >
struct	is_tuple_of_function_arguments< hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< ArgTypes >... > >
struct	is_tuple_of_function_arguments< hydra::thrust::tuple< ArgTypes... > >
struct	is_tuple_type
struct	is_tuple_type< hydra::thrust::detail::tuple_of_iterator_references< ArgTypes... > >
struct	is_tuple_type< hydra::thrust::tuple< ArgTypes... > >
struct	is_valid_type_pack
struct	is_valid_type_pack< hydra::thrust::tuple< RefT... >, T... >
struct	is_zip_iterator
struct	is_zip_iterator< hydra::thrust::zip_iterator< T... > >
struct	isAccepted
struct	IteratorTraits
struct	lambda_traits
struct	LogLikelihood1
struct	LogLikelihood2
struct	low_bits_mask_t
struct	low_bits_mask_t< std::numeric_limits< unsigned char >::digits >
struct	make_index_sequence
struct	make_index_sequence< 0 >
struct	make_index_sequence< 1 >
struct	merged_tuple
struct	merged_tuple< hydra::tuple< T... > >
struct	merged_tuple< hydra::tuple< T... >, hydra::tuple< U... > >
struct	merged_tuple< hydra::tuple< T... >, hydra::tuple< U... >, Z... >
struct	merged_zip_iterator
struct	merged_zip_iterator< hydra::thrust::zip_iterator< T... > >
struct	merged_zip_iterator< hydra::thrust::zip_iterator< T... >, hydra::thrust::zip_iterator< U... > >
struct	merged_zip_iterator< hydra::thrust::zip_iterator< T... >, hydra::thrust::zip_iterator< U... >, Z... >
struct	minus_result
struct	multidimensional
struct	multiply_result
struct	nearest_int
	Round to nearest integer at compile time. More...
struct	ObjSelector
struct	ObjSelector< false >
struct	ObjSelector< true >
class	Parameters
class	Parameters< 0 >
	specialization for no-parametrized functor More...
class	ParametersCompositeFunctor
struct	power
struct	power< B, 0 >
struct	ProcessBoxesVegas
struct	ProcessCallsPlainBinary
struct	ProcessCallsPlainUnary
struct	ProcessCallsVegas
struct	ProcessCallsVegas< FUNCTOR, NDimensions, hydra::detail::BackendPolicy< BACKEND >, IteratorBackendReal, IteratorBackendUInt, GRND >
struct	ProcessGenzMalikBinaryCall
struct	ProcessGenzMalikBox
struct	ProcessGenzMalikUnaryCall
class	quasi_random_base
struct	random_traits
struct	random_traits< hydra_r123::Philox2x64 >
struct	random_traits< hydra_r123::Philox4x64 >
struct	random_traits< hydra_r123::Threefry2x64 >
struct	random_traits< hydra_r123::Threefry4x64 >
struct	references_tuple_type
struct	remove_device_reference
struct	remove_device_reference< hydra::thrust::device_reference< T > >
struct	remove_device_reference< T & >
struct	repeat
struct	repeat< T, 0, TT >
struct	ResultPHSP
struct	ResultVegas
struct	RndBreitWigner
struct	RndCDF
struct	RndExp
struct	RndFlag
struct	RndGauss
struct	RndTrial
struct	RndTrial< T, GRND, FUNCTOR, 1 >
struct	RndUniform
struct	Sampler
struct	selected_tuple
struct	selected_tuple< Selector, hydra::tuple< Head, Tail... > >
struct	selected_tuple< Selector, hydra::tuple< Type > >
struct	signature_traits
struct	signature_traits< hydra::thrust::tuple< R, Args... > >
struct	signature_traits< R(Args...)>
struct	signature_type
struct	signature_type_impl
struct	sobol_lattice
struct	SobolTable
struct	StatsPHSP
struct	stripped_tuple
struct	stripped_tuple< hydra::tuple< T... > >
struct	stripped_type
struct	stripped_type< Arg, false >
struct	stripped_type< Arg, true >
struct	sum_result
struct	SWeights
struct	tag_type
struct	trimmed_lambda_signature
struct	trimmed_lambda_signature< hydra::thrust::tuple< Head, Neck, Tail... > >
struct	tuple_cat_type
struct	tuple_cat_type< hydra::thrust::detail::tuple_of_iterator_references< T1... >, hydra::thrust::detail::tuple_of_iterator_references< T2... > >
struct	tuple_cat_type< hydra::thrust::tuple< T1... >, hydra::thrust::tuple< T2... > >
struct	tuple_type
struct	TypeTraits
struct	TypeTraits< hydra::thrust::complex< T > >
struct	uint_t
struct	unidimensional

Typedefs
template<class R , class... Ts>
using	are_all_same = all_true< std::is_same< Ts, R >::value... >
template<class... T>
using	common_type_t = typename std::common_type< T... >::type

Enumerations
enum	{ kInvalidNumber = -111 }
enum	Backend {   Host, Device, Cpp, Omp,   Tbb, Cuda }
enum	FFTCalculator { CuFFT, FFTW }

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	_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	_get_element (const size_t index, T &t, R *&ptr)
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	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	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	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	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	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	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	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	add_tuple_values (GReal_t &result, hydra::thrust::tuple< T... > const &tpl)
template<typename ... T, size_t ... I>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	addTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b, index_sequence< I... >)
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	addTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<size_t I, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< I, hydra::thrust::tuple< T... > >::type	addTuplesHelper (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<typename T >
__hydra_host__ __hydra_device__ bool	ApproximatelyEqual (T a, T b, T tolerance=machine_eps_f64())
template<typename T >
__hydra_host__ __hydra_device__ bool	ApproximatelyZero (T a, T tolerance=machine_eps_f64())
template<typename T , size_t N>
auto	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	arrayToTuple (T *Array) -> decltype(arrayToTupleHelper(Array, make_index_sequence< N >
template<typename T , size_t... Is>
auto	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	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	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	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	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	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	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	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	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	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	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	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	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	assignTupleToArray (hydra::thrust::detail::tuple_of_iterator_references< Head, Tail... > const &Tuple, std::array< Type, sizeof...(Tail)+1 > &Array)
template<typename F , typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	callOnTuple (F const &f, const hydra::thrust::tuple< T... > &tuple)
template<typename F , typename ... T, size_t ... I>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	callOnTupleHelper (F const &f, const hydra::thrust::tuple< T... > &tuple, index_sequence< I... >)
template<typename T , typename ... Ts>
__hydra_host__ __hydra_device__ T	CheckValue (T &&x, char const *fmt, char const *file, char const *function, unsigned int line, Ts &&...par)
template<typename ... T, size_t ... I>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	divideTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b, index_sequence< I... >)
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	divideTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<size_t I, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< I, hydra::thrust::tuple< T... > >::type	divideTuplesHelper (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<unsigned int I = 0, typename FuncT , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	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	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	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	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	extract (const int idx, const Tuple &t)
template<typename R , typename ... T>
__hydra_host__ __hydra_device__ R &	get_element (const size_t index, hydra::thrust::tuple< T... > &t)
template<typename Tup >
auto	get_functor_tuple (Tup &pdfs) -> decltype(get_functor_tuple_helper(pdfs, make_index_sequence< hydra::thrust::tuple_size< Tup >::value >
template<typename Tup , size_t ... index>
auto	get_functor_tuple_helper (Tup &pdfs, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(pdfs).GetFunctor()...))
return	get_functor_tuple_helper (pdfs, make_index_sequence< Size > { })
template<typename T , size_t DIM, size_t I>
std::enable_if<(I==DIM) &&(std::is_integral< T >::value), void >::type	get_indexes (size_t, std::array< T, DIM > const &, std::array< T, DIM > &)
template<typename T , size_t DIM, size_t I = 0>
std::enable_if<(I< DIM) &&(std::is_integral< T >::value), void >::type	get_indexes (size_t index, std::array< T, DIM > const &depths, std::array< T, DIM > &indexes)
template<typename T , size_t DIM, size_t I>
std::enable_if<(I==DIM) &&(std::is_integral< T >::value), void >::type	get_indexes (size_t, const T(&)[DIM], T(&)[DIM])
template<typename T , size_t DIM, size_t I = 0>
std::enable_if<(I< DIM) &&(std::is_integral< T >::value), void >::type	get_indexes (size_t index, const T(&depths)[DIM], T(&indexes)[DIM])
template<typename T , typename... Types>
__hydra_host__ __hydra_device__ T &	get_tuple_element (hydra::thrust::tuple< Types... > &t)
template<class T , class... Types>
__hydra_host__ __hydra_device__ const T &	get_tuple_element (const hydra::thrust::tuple< Types... > &t)
template<class T , class... Types>
__hydra_host__ __hydra_device__ T &&	get_tuple_element (hydra::thrust::tuple< Types... > &&t)
template<typename T , typename... Types>
__hydra_host__ __hydra_device__ hydra::thrust::device_reference< T >	get_tuple_element (hydra::thrust::tuple< hydra::thrust::device_reference< Types >... > &t)
template<class T , class... Types>
__hydra_host__ __hydra_device__ const hydra::thrust::device_reference< T >	get_tuple_element (const hydra::thrust::tuple< hydra::thrust::device_reference< Types >... > &t)
template<class T , class... Types>
__hydra_host__ __hydra_device__ hydra::thrust::device_reference< T > &&	get_tuple_element (hydra::thrust::tuple< hydra::thrust::device_reference< Types >... > &&t)
template<typename T , typename... Types>
__hydra_host__ __hydra_device__ hydra::thrust::device_reference< T >	get_tuple_element (hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< Types >... > &t)
template<class T , class... Types>
__hydra_host__ __hydra_device__ const hydra::thrust::device_reference< T >	get_tuple_element (const hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< Types >... > &t)
template<class T , class... Types>
__hydra_host__ __hydra_device__ hydra::thrust::device_reference< T >	get_tuple_element (hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< Types >... > &&t)
template<unsigned int I = 0, typename T , typename ... Tp>
__hydra_host__ __hydra_device__ hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	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	get_tuple_element (const int index, hydra::thrust::tuple< Tp... > const &t, T &x)
template<typename Iterator , size_t N>
__hydra_host__ auto	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	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	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	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<class T >
void	hash_combine (std::size_t &seed, T const &v)
template<class It >
std::size_t	hash_range (It first, It last)
template<class It >
void	hash_range (std::size_t &seed, It first, It last)
template<typename ... T>
void	hash_tuple (std::size_t &seed, hydra::tuple< T... > const &_tuple)
template<typename ... T>
std::size_t	hash_tuple (hydra::tuple< T... > const &_tuple)
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	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	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	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	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	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	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	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	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	invoke_helper (x, y, tup, make_index_sequence< Size > { })
template<typename Tup , typename ArgType >
__hydra_host__ __hydra_device__ auto	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	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	invoke_normalized_helper (ArgType const &x, Tup const &tup, index_sequence< index... >) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get< index >(tup)(x)...))
return	invoke_normalized_helper (x, tup, make_index_sequence< Size > { })
template<typename Tup , typename ArgType , size_t ... index>
__hydra_host__ __hydra_device__ auto	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<class Iterator >
__hydra_host__ __hydra_device__ void	iter_swap (Iterator first, Iterator second)
template<typename T , typename ... Ts>
__hydra_host__ __hydra_device__ T	kill (T &&x)
template<size_t N, typename GRND , typename Iterator >
void	launch_decayer (Iterator begin, Iterator end, DecayMother< N, GRND > const &decayer)
template<size_t N, typename GRND , typename Iterator , hydra::detail::Backend BACKEND>
void	launch_decayer (hydra::detail::BackendPolicy< BACKEND > const &exec_policy, Iterator begin, Iterator end, DecayMother< N, GRND > const &decayer)
template<size_t N, typename GRND , typename IteratorMother , typename IteratorDaughter >
void	launch_decayer (IteratorMother begin_mothers, IteratorMother end_mothers, IteratorDaughter begin_daugters, DecayMothers< N, GRND > const &decayer)
template<size_t N, typename GRND , typename IteratorMother , typename IteratorDaughter , hydra::detail::Backend BACKEND>
void	launch_decayer (hydra::detail::BackendPolicy< BACKEND > const &exec_policy, IteratorMother begin_mothers, IteratorMother end_mothers, IteratorDaughter begin_daugters, DecayMothers< N, GRND > const &decayer)
template<size_t N, typename FUNCTOR , typename ... FUNCTORS, typename GRND , typename Iterator >
void	launch_evaluator (Iterator begin, Iterator end, detail::EvalMother< N, GRND, FUNCTOR, FUNCTORS... > const &evaluator)
template<size_t N, typename FUNCTOR , typename ... FUNCTORS, typename GRND , typename IteratorMother , typename Iterator >
void	launch_evaluator (IteratorMother mbegin, IteratorMother mend, Iterator begin, detail::EvalMothers< N, GRND, FUNCTOR, FUNCTORS... > const &evaluator)
template<size_t N, hydra::detail::Backend BACKEND, typename FUNCTOR , typename GRND , typename Iterator >
StatsPHSP	launch_reducer (hydra::detail::BackendPolicy< BACKEND >const &policy, Iterator begin, Iterator end, detail::AverageMother< N, GRND, FUNCTOR > const &evaluator)
template<size_t N, typename FUNCTOR , typename GRND , typename Iterator >
StatsPHSP	launch_reducer (Iterator begin, Iterator end, detail::AverageMothers< N, GRND, FUNCTOR > const &evaluator)
template<typename Integer >
__hydra_host__ __hydra_device__ std::enable_if< std::is_integral< Integer >::value &&!(std::is_signed< Integer >::value) &&(sizeof(Integer)==8), unsigned >::type	lsb (Integer x)
template<typename Integer >
__hydra_host__ __hydra_device__ std::enable_if< std::is_integral< Integer >::value &&!(std::is_signed< Integer >::value) &&(sizeof(Integer)==4), unsigned >::type	lsb (Integer x)
__hydra_host__ __hydra_device__ float	machine_eps_f32 (float value=1.0)
__hydra_host__ __hydra_device__ double	machine_eps_f64 (double value=1.0)
template<typename ... T>
auto	make_rtuple (hydra::thrust::tuple< T... > &t) -> hydra::thrust::tuple< T &... >
template<typename ... T, size_t... I>
auto	make_rtuple_helper (hydra::thrust::tuple< T... > &t, index_sequence< I... >) -> hydra::thrust::tuple< T &... >
T ::type TupleType	make_tuple (T &&value)
template<typename ... T>
__hydra_host__ __hydra_device__ size_t	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	max_helper (T const &, C &, size_t &)
	max_helper< T, C, N, I+1 > (tuple, max_value, max_index)
template<typename ... Iterators>
auto	meld_iterators (Iterators &&... iterators) -> decltype(hydra::thrust::make_zip_iterator(hydra::thrust::tuple_cat(meld_iterators_ns::convert_to_tuple(std::forward< Iterators >(iterators))...)))
template<typename Integer >
__hydra_host__ __hydra_device__ std::enable_if< std::is_integral< Integer >::value &&!(std::is_signed< Integer >::value) &&(std::numeric_limits< Integer >::digits==64), unsigned >::type	msb (Integer x)
template<typename Integer >
__hydra_host__ __hydra_device__ std::enable_if< std::is_integral< Integer >::value &&!(std::is_signed< Integer >::value) &&(std::numeric_limits< Integer >::digits<=32), unsigned >::type	msb (Integer x)
template<typename T , size_t N, size_t I>
std::enable_if<(I==N), void >::type	multiply (std::array< T, N > const &, T &)
template<typename T , size_t N, size_t I = 0>
std::enable_if<(I< N), void >::type	multiply (std::array< T, N > const &obj, T &result)
template<typename T , size_t N, size_t I>
std::enable_if<(I==N), void >::type	multiply (const T(&)[N], T &)
template<typename T , size_t N, size_t I = 0>
std::enable_if<(I< N), void >::type	multiply (const T(&obj)[N], T &result)
template<typename ... T>
__hydra_host__ __hydra_device__ auto	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	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	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	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	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	multiply_tuple (Return_Type &r, hydra::thrust::tuple< Tp... > &&t)
template<typename ... T, size_t ... I>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	multiplyTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b, index_sequence< I... >)
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	multiplyTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<size_t I, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< I, hydra::thrust::tuple< T... > >::type	multiplyTuplesHelper (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<class BidirIt >
__hydra_host__ __hydra_device__ bool	next_permutation (BidirIt first, BidirIt last)
template<typename Iterator , typename Integer , typename Comparator >
std::enable_if< std::is_integral< Integer >::value, void >::type __hydra_host__ __hydra_device__	nth_permutation (Iterator begin, Iterator end, Integer n, Comparator comp)
template<typename Type >
__hydra_host__ __hydra_device__ GenzMalikBoxResult< Type >	operator+ (GenzMalikBoxResult< Type > left, GenzMalikBoxResult< Type > const &right)
template<typename Type , size_t N>
__hydra_host__ __hydra_device__ GenzMalikBoxResult< Type >	operator+ (GenzMalikBoxResult< Type > left, GenzMalikBox< N > const &right)
template<typename T , unsigned int N, unsigned int I>
__hydra_host__ __hydra_device__ std::enable_if< I==N, void >::type	pow_helper (T const, T &)
template<typename T , unsigned int N, unsigned int I>
__hydra_host__ __hydra_device__ std::enable_if<(I< N), void >::type	pow_helper (T const x, T &r)
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	product_tuple3 (Return_Type &r, hydra::thrust::tuple< Tp... > &&t, ArgType1 &&arg1, ArgType2 &&arg2)
template<typename T1 , typename T2 >
void	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	ptr_setter (T1 *&, typename hydra::thrust::detail::enable_if<!hydra::thrust::detail::is_same< T1, T2 >::value, T2 >::type *)
template<class Iterator >
__hydra_host__ __hydra_device__ Iterator	rotate (Iterator first, Iterator n_first, Iterator last)
template<typename T >
__hydra_host__ __hydra_device__ bool	SafeGreaterThan (T a, T b, T tolerance=machine_eps_f64())
template<typename T >
__hydra_host__ __hydra_device__ bool	SafeLessThan (T a, T b, T tolerance=machine_eps_f64())
template<size_t I = 0, typename ... Tp>
hydra::thrust::detail::enable_if< I==sizeof...(Tp), void >::type	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	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	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	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	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	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	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	set_tuple_element (const int index, hydra::thrust::tuple< Tp... > &t, const T &x)
template<typename ... T1, typename ... T2>
__hydra_host__ __hydra_device__ void	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	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	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	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<typename ... T, size_t ... I>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	subtractTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b, index_sequence< I... >)
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	subtractTuples (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<size_t I, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< I, hydra::thrust::tuple< T... > >::type	subtractTuplesHelper (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
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	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	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	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	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	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	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	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	sum_tuple2 (Return_Type &r, hydra::thrust::tuple< Tp... > const &t, ArgType1 const &arg1, ArgType2 const &arg2)
template<typename T >
__hydra_host__ __hydra_device__ std::enable_if< detail::is_tuple< T >::value, T >::type	tupler (T const &data)
template<typename T >
__hydra_host__ __hydra_device__ std::enable_if<!detail::is_tuple< T >::value, hydra::tuple< T > >::type	tupler (T const &data)
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	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	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	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	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	tupleToArray (TupleType const &_tuple, ArrayType *_array)
template<typename T >
__hydra_host__ __hydra_device__ bool	WithinPrecisionInterval (T b, T a, unsigned int interval_size=1)
template<typename ... T>
std::enable_if< all_true< is_zip_iterator< T >::value... >::value, typename detail::merged_zip_iterator< T... >::type >::type	zip_iterator_cat (T const &... zip_iterators)

Variables
	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	max_value = max_value > hydra::thrust::get<I>(tuple) ? max_value : hydra::thrust::get<I>(tuple)

---

Data Structure Documentation

hydra::detail::_merge_and_renumber

struct hydra::detail::_merge_and_renumber

template<class Sequence1, class Sequence2>
struct hydra::detail::_merge_and_renumber< Sequence1, Sequence2 >

Inheritance diagram for hydra::detail::_merge_and_renumber< Sequence1, Sequence2 >:

Collaboration diagram for hydra::detail::_merge_and_renumber< Sequence1, Sequence2 >:

hydra::detail::append_to_type_seq

struct hydra::detail::append_to_type_seq

template<typename, typename>
struct hydra::detail::append_to_type_seq< typename, typename >

Collaboration diagram for hydra::detail::append_to_type_seq< typename, typename >:

hydra::detail::append_to_type_seq< T, TT< Ts... > >

struct hydra::detail::append_to_type_seq< T, TT< Ts... > >

template<typename T, typename... Ts, template< typename... > class TT>
struct hydra::detail::append_to_type_seq< T, TT< Ts... > >

Collaboration diagram for hydra::detail::append_to_type_seq< T, TT< Ts... > >:

Data Fields
	type

hydra::detail::BackendPolicy

struct hydra::detail::BackendPolicy

template<Backend BACKEND>
struct hydra::detail::BackendPolicy< BACKEND >

Examples:

dalitz_plot.C, dalitz_plot.inl, dense_histogram.inl, multidimensional_fit.inl, multivector_container.inl, phsp_basic.inl, phsp_chain.inl, phsp_reweighting.inl, phsp_unweighting.inl, phsp_unweighting_functor.inl, pseudo_experiment.inl, range_semantics.inl, and splot.inl.

Collaboration diagram for hydra::detail::BackendPolicy< BACKEND >:

hydra::detail::bool_pack

struct hydra::detail::bool_pack

template<bool...>
struct hydra::detail::bool_pack<... >

Collaboration diagram for hydra::detail::bool_pack<... >:

hydra::detail::CanConvert

struct hydra::detail::CanConvert

template<class ... A>
struct hydra::detail::CanConvert< A >

Collaboration diagram for hydra::detail::CanConvert< A >:

hydra::detail::divide_result

struct hydra::detail::divide_result

template<typename F1, typename F2, typename ... Fs>
struct hydra::detail::divide_result< F1, F2, Fs >

Collaboration diagram for hydra::detail::divide_result< F1, F2, Fs >:

Data Fields
	type

hydra::detail::FFTPolicy

struct hydra::detail::FFTPolicy

template<typename Precision, FFTCalculator FFTBackend>
struct hydra::detail::FFTPolicy< Precision, FFTBackend >

Collaboration diagram for hydra::detail::FFTPolicy< Precision, FFTBackend >:

hydra::detail::FFTPolicy< T, detail::CuFFT >

struct hydra::detail::FFTPolicy< T, detail::CuFFT >

template<typename T>
struct hydra::detail::FFTPolicy< T, detail::CuFFT >

Collaboration diagram for hydra::detail::FFTPolicy< T, detail::CuFFT >:

Data Fields
typedef ComplexToComplexCuFFT< T >	C2C
typedef ComplexToRealCuFFT< T >	C2R
typedef sys_t	device_backend_type
typedef sys_t	host_backend_type
typedef RealToComplexCuFFT< T >	R2C

hydra::detail::FFTPolicy< T, detail::FFTW >

struct hydra::detail::FFTPolicy< T, detail::FFTW >

template<typename T>
struct hydra::detail::FFTPolicy< T, detail::FFTW >

Collaboration diagram for hydra::detail::FFTPolicy< T, detail::FFTW >:

Data Fields
typedef ComplexToComplexFFTW< T >	C2C
typedef ComplexToRealFFTW< T >	C2R
typedef sys_t	device_backend_type
typedef sys_t	host_backend_type
typedef RealToComplexFFTW< T >	R2C

hydra::detail::find_unique_type_impl

struct hydra::detail::find_unique_type_impl

template<size_t I, class T, class... Types>
struct hydra::detail::find_unique_type_impl< I, T, Types >

Inheritance diagram for hydra::detail::find_unique_type_impl< I, T, Types >:

Collaboration diagram for hydra::detail::find_unique_type_impl< I, T, Types >:

hydra::detail::function_traits

struct hydra::detail::function_traits

template<typename T>
struct hydra::detail::function_traits< T >

Collaboration diagram for hydra::detail::function_traits< T >:

hydra::detail::functor_traits

struct hydra::detail::functor_traits

template<typename T>
struct hydra::detail::functor_traits< T >

Inheritance diagram for hydra::detail::functor_traits< T >:

Collaboration diagram for hydra::detail::functor_traits< T >:

hydra::detail::functor_traits< ReturnType(ClassType::*)(Args...) >

struct hydra::detail::functor_traits< ReturnType(ClassType::*)(Args...) >

template<typename ClassType, typename ReturnType, typename... Args>
struct hydra::detail::functor_traits< ReturnType(ClassType::*)(Args...) >

Collaboration diagram for hydra::detail::functor_traits< ReturnType(ClassType::*)(Args...) >:

hydra::detail::if_then_else

class hydra::detail::if_then_else

template<bool C, typename T1, typename T2>
class hydra::detail::if_then_else< C, T1, T2 >

Collaboration diagram for hydra::detail::if_then_else< C, T1, T2 >:

hydra::detail::if_then_else< false, T1, T2 >

class hydra::detail::if_then_else< false, T1, T2 >

template<typename T1, typename T2>
class hydra::detail::if_then_else< false, T1, T2 >

Collaboration diagram for hydra::detail::if_then_else< false, T1, T2 >:

Data Fields
typedef T2	type

hydra::detail::if_then_else< true, T1, T2 >

class hydra::detail::if_then_else< true, T1, T2 >

template<typename T1, typename T2>
class hydra::detail::if_then_else< true, T1, T2 >

Collaboration diagram for hydra::detail::if_then_else< true, T1, T2 >:

Data Fields
typedef T1	type

hydra::detail::if_then_else_tt

struct hydra::detail::if_then_else_tt

template<bool Condition, template< typename ... > class T1, template< typename ... > class T2>
struct hydra::detail::if_then_else_tt< Condition, T1, T2 >

Collaboration diagram for hydra::detail::if_then_else_tt< Condition, T1, T2 >:

hydra::detail::if_then_else_tt< false, T1, T2 >

struct hydra::detail::if_then_else_tt< false, T1, T2 >

template<template< typename ... > class T1, template< typename ... > class T2>
struct hydra::detail::if_then_else_tt< false, T1, T2 >

Collaboration diagram for hydra::detail::if_then_else_tt< false, T1, T2 >:

Data Fields
	type

hydra::detail::if_then_else_tt< true, T1, T2 >

struct hydra::detail::if_then_else_tt< true, T1, T2 >

template<template< typename ... > class T1, template< typename ... > class T2>
struct hydra::detail::if_then_else_tt< true, T1, T2 >

Collaboration diagram for hydra::detail::if_then_else_tt< true, T1, T2 >:

Data Fields
	type

hydra::detail::index_in_tuple

struct hydra::detail::index_in_tuple

template<typename Type, typename Tuple>
struct hydra::detail::index_in_tuple< Type, Tuple >

Collaboration diagram for hydra::detail::index_in_tuple< Type, Tuple >:

hydra::detail::int_fast_t

struct hydra::detail::int_fast_t

template<typename LeastInt>
struct hydra::detail::int_fast_t< LeastInt >

Collaboration diagram for hydra::detail::int_fast_t< LeastInt >:

Data Fields
typedef LeastInt	fast
typedef fast	type

hydra::detail::is_function_argument

struct hydra::detail::is_function_argument

template<typename Arg, bool B = fa_impl::_is_function_argument<Arg>::value>
struct hydra::detail::is_function_argument< Arg, B >

Collaboration diagram for hydra::detail::is_function_argument< Arg, B >:

hydra::detail::is_valid_type_pack

struct hydra::detail::is_valid_type_pack

template<typename RefT, typename ... T>
struct hydra::detail::is_valid_type_pack< RefT, T >

Collaboration diagram for hydra::detail::is_valid_type_pack< RefT, T >:

hydra::detail::merged_tuple

struct hydra::detail::merged_tuple

template<typename ... T>
struct hydra::detail::merged_tuple< T >

Inheritance diagram for hydra::detail::merged_tuple< T >:

Collaboration diagram for hydra::detail::merged_tuple< T >:

hydra::detail::merged_tuple< hydra::tuple< T... > >

struct hydra::detail::merged_tuple< hydra::tuple< T... > >

template<typename ... T>
struct hydra::detail::merged_tuple< hydra::tuple< T... > >

Collaboration diagram for hydra::detail::merged_tuple< hydra::tuple< T... > >:

Data Fields
	type

hydra::detail::merged_zip_iterator

struct hydra::detail::merged_zip_iterator

template<typename ... T>
struct hydra::detail::merged_zip_iterator< T >

Inheritance diagram for hydra::detail::merged_zip_iterator< T >:

Collaboration diagram for hydra::detail::merged_zip_iterator< T >:

hydra::detail::merged_zip_iterator< hydra::thrust::zip_iterator< T... > >

struct hydra::detail::merged_zip_iterator< hydra::thrust::zip_iterator< T... > >

template<typename ... T>
struct hydra::detail::merged_zip_iterator< hydra::thrust::zip_iterator< T... > >

Collaboration diagram for hydra::detail::merged_zip_iterator< hydra::thrust::zip_iterator< T... > >:

Data Fields
	type

hydra::detail::minus_result

struct hydra::detail::minus_result

template<typename F1, typename F2, typename ... Fs>
struct hydra::detail::minus_result< F1, F2, Fs >

Collaboration diagram for hydra::detail::minus_result< F1, F2, Fs >:

Data Fields
	type

hydra::detail::multidimensional

struct hydra::detail::multidimensional

Collaboration diagram for hydra::detail::multidimensional:

hydra::detail::multiply_result

struct hydra::detail::multiply_result

template<typename F1, typename F2, typename ... Fs>
struct hydra::detail::multiply_result< F1, F2, Fs >

Collaboration diagram for hydra::detail::multiply_result< F1, F2, Fs >:

Data Fields
	type

hydra::detail::ObjSelector

struct hydra::detail::ObjSelector

template<bool FLAG>
struct hydra::detail::ObjSelector< FLAG >

Collaboration diagram for hydra::detail::ObjSelector< FLAG >:

hydra::detail::random_traits

struct hydra::detail::random_traits

template<typename Engine>
struct hydra::detail::random_traits< Engine >

Inheritance diagram for hydra::detail::random_traits< Engine >:

Collaboration diagram for hydra::detail::random_traits< Engine >:

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::remove_device_reference

struct hydra::detail::remove_device_reference

template<typename T>
struct hydra::detail::remove_device_reference< T >

Collaboration diagram for hydra::detail::remove_device_reference< T >:

Data Fields
typedef T	type

hydra::detail::remove_device_reference< hydra::thrust::device_reference< T > >

struct hydra::detail::remove_device_reference< hydra::thrust::device_reference< T > >

template<typename T>
struct hydra::detail::remove_device_reference< hydra::thrust::device_reference< T > >

Collaboration diagram for hydra::detail::remove_device_reference< hydra::thrust::device_reference< T > >:

Data Fields
typedef T	type

hydra::detail::remove_device_reference< T & >

struct hydra::detail::remove_device_reference< T & >

template<typename T>
struct hydra::detail::remove_device_reference< T & >

Collaboration diagram for hydra::detail::remove_device_reference< T & >:

Data Fields
typedef T	type

hydra::detail::repeat

struct hydra::detail::repeat

template<typename T, unsigned int N, template< typename... > class TT>
struct hydra::detail::repeat< T, N, TT >

Collaboration diagram for hydra::detail::repeat< T, N, TT >:

Data Fields
typedef typename append_to_type_seq< T, typename repeat< T, N-1, TT >::type >::type	type

hydra::detail::repeat< T, 0, TT >

struct hydra::detail::repeat< T, 0, TT >

template<typename T, template< typename... > class TT>
struct hydra::detail::repeat< T, 0, TT >

Collaboration diagram for hydra::detail::repeat< T, 0, TT >:

Data Fields
typedef TT<>	type

hydra::detail::ResultPHSP

struct hydra::detail::ResultPHSP

Collaboration diagram for hydra::detail::ResultPHSP:

Data Fields
GReal_t	fM2
GReal_t	fMean
GReal_t	fW

hydra::detail::ResultVegas

struct hydra::detail::ResultVegas

Collaboration diagram for hydra::detail::ResultVegas:

Data Fields
GReal_t	fM2
GReal_t	fMean
GReal_t	fN

hydra::detail::selected_tuple

struct hydra::detail::selected_tuple

template<template< typename Type > class Selector, typename TypeList>
struct hydra::detail::selected_tuple< Selector, TypeList >

Collaboration diagram for hydra::detail::selected_tuple< Selector, TypeList >:

hydra::detail::selected_tuple< Selector, hydra::tuple< Head, Tail... > >

struct hydra::detail::selected_tuple< Selector, hydra::tuple< Head, Tail... > >

template<template< typename T > class Selector, typename Head, typename ... Tail>
struct hydra::detail::selected_tuple< Selector, hydra::tuple< Head, Tail... > >

Collaboration diagram for hydra::detail::selected_tuple< Selector, hydra::tuple< Head, Tail... > >:

Data Fields
	type

hydra::detail::selected_tuple< Selector, hydra::tuple< Type > >

struct hydra::detail::selected_tuple< Selector, hydra::tuple< Type > >

template<template< typename T > class Selector, typename Type>
struct hydra::detail::selected_tuple< Selector, hydra::tuple< Type > >

Collaboration diagram for hydra::detail::selected_tuple< Selector, hydra::tuple< Type > >:

Data Fields
typedef conditional< Selector< Type >::value, tuple< Type >, tuple<> >::type	type

hydra::detail::signature_traits

struct hydra::detail::signature_traits

template<typename S>
struct hydra::detail::signature_traits< S >

Collaboration diagram for hydra::detail::signature_traits< S >:

hydra::detail::signature_type

struct hydra::detail::signature_type

template<typename R, typename ... A>
struct hydra::detail::signature_type< R, A >

Collaboration diagram for hydra::detail::signature_type< R, A >:

Data Fields
	type

hydra::detail::signature_type_impl

struct hydra::detail::signature_type_impl

template<typename T>
struct hydra::detail::signature_type_impl< T >

Collaboration diagram for hydra::detail::signature_type_impl< T >:

Data Fields
typedef T	type

hydra::detail::stripped_tuple

struct hydra::detail::stripped_tuple

template<typename T>
struct hydra::detail::stripped_tuple< T >

Collaboration diagram for hydra::detail::stripped_tuple< T >:

hydra::detail::stripped_type

struct hydra::detail::stripped_type

template<typename Arg, bool T = is_function_argument<Arg>::value>
struct hydra::detail::stripped_type< Arg, T >

Collaboration diagram for hydra::detail::stripped_type< Arg, T >:

hydra::detail::stripped_type< Arg, false >

struct hydra::detail::stripped_type< Arg, false >

template<typename Arg>
struct hydra::detail::stripped_type< Arg, false >

Collaboration diagram for hydra::detail::stripped_type< Arg, false >:

Data Fields
typedef Arg	type

hydra::detail::stripped_type< Arg, true >

struct hydra::detail::stripped_type< Arg, true >

template<typename Arg>
struct hydra::detail::stripped_type< Arg, true >

Collaboration diagram for hydra::detail::stripped_type< Arg, true >:

Data Fields
typedef value_type	type

hydra::detail::sum_result

struct hydra::detail::sum_result

template<typename F1, typename F2, typename ... Fs>
struct hydra::detail::sum_result< F1, F2, Fs >

Collaboration diagram for hydra::detail::sum_result< F1, F2, Fs >:

Data Fields
	type

hydra::detail::tag_type

struct hydra::detail::tag_type

template<class T, class R = void>
struct hydra::detail::tag_type< T, R >

Collaboration diagram for hydra::detail::tag_type< T, R >:

Data Fields
typedef R	type

hydra::detail::trimmed_lambda_signature

struct hydra::detail::trimmed_lambda_signature

template<typename T>
struct hydra::detail::trimmed_lambda_signature< T >

Collaboration diagram for hydra::detail::trimmed_lambda_signature< T >:

hydra::detail::trimmed_lambda_signature< hydra::thrust::tuple< Head, Neck, Tail... > >

struct hydra::detail::trimmed_lambda_signature< hydra::thrust::tuple< Head, Neck, Tail... > >

template<typename Head, typename Neck, typename ... Tail>
struct hydra::detail::trimmed_lambda_signature< hydra::thrust::tuple< Head, Neck, Tail... > >

Collaboration diagram for hydra::detail::trimmed_lambda_signature< hydra::thrust::tuple< Head, Neck, Tail... > >:

Data Fields
	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

hydra::detail::unidimensional

struct hydra::detail::unidimensional

Collaboration diagram for hydra::detail::unidimensional:

Typedef Documentation

are_all_same

template<class R , class... Ts>

using hydra::detail::are_all_same = typedef all_true<std::is_same<Ts, R>::value...>

common_type_t

template<class... T>

using hydra::detail::common_type_t = typedef typename std::common_type<T...>::type

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kInvalidNumber

Backend

enum hydra::detail::Backend

Enumerator
Host
Device
Cpp
Omp
Tbb
Cuda

Examples:

dalitz_plot.C, and dalitz_plot.inl.

FFTCalculator

enum hydra::detail::FFTCalculator

Enumerator
CuFFT
FFTW

Function Documentation

_get_element() [1/2]

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 *&    )

inline

_get_element() [2/2]

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  )

inline

accumulate() [1/2]

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  )

inline

accumulate() [2/2]

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  )

inline

accumulate2() [1/2]

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  )

inline

accumulate2() [2/2]

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  )

inline

add_parameters_in_tuple() [1/2]

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... > &    )

inline

add_parameters_in_tuple() [2/2]

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  )

inline

add_tuple_values() [1/2]

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 &    )

inline

add_tuple_values() [2/2]

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  )

inline

addTuples() [1/2]

template<typename ... T, size_t ... I>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::addTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b, index_sequence< I... >    )

inline

addTuples() [2/2]

template<typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::addTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

addTuplesHelper()

template<size_t I, typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<I, hydra::thrust::tuple<T...> >::type hydra::detail::addTuplesHelper ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

ApproximatelyEqual()

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::detail::ApproximatelyEqual ( T  a, T  b, T  tolerance = machine_eps_f64()  )

inline

ApproximatelyZero()

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::detail::ApproximatelyZero ( T  a, T  tolerance = machine_eps_f64()  )

inline

arrayToTuple() [1/2]

template<typename T , size_t N>

auto hydra::detail::arrayToTuple

(

std::array< T, N >const &

Array

)

-> decltype(arrayToTupleHelper(Array, make_index_sequence<N>

arrayToTuple() [2/2]

template<typename T , size_t N>

__hydra_host__ __hydra_device__ auto hydra::detail::arrayToTuple ( T *  Array ) -> decltype( arrayToTupleHelper(Array, make_index_sequence<N>

inline

arrayToTupleHelper() [1/2]

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]...))

arrayToTupleHelper() [2/2]

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]...))

inline

assignArrayToTuple() [1/4]

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 *    )

inline

assignArrayToTuple() [2/4]

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  )

inline

assignArrayToTuple() [3/4]

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 *    )

inline

assignArrayToTuple() [4/4]

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  )

inline

assignTupleToArray() [1/8]

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]  )

inline

assignTupleToArray() [2/8]

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]  )

inline

assignTupleToArray() [3/8]

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 > &    )

inline

assignTupleToArray() [4/8]

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  )

inline

assignTupleToArray() [5/8]

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]  )

inline

assignTupleToArray() [6/8]

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]  )

inline

assignTupleToArray() [7/8]

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 > &    )

inline

assignTupleToArray() [8/8]

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  )

inline

callOnTuple()

template<typename F , typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::callOnTuple ( F const &  f, const hydra::thrust::tuple< T... > &  tuple  )

inline

callOnTupleHelper()

template<typename F , typename ... T, size_t ... I>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::callOnTupleHelper ( F const &  f, const hydra::thrust::tuple< T... > &  tuple, index_sequence< I... >    )

inline

CheckValue()

template<typename T , typename ... Ts>

__hydra_host__ __hydra_device__ T hydra::detail::CheckValue ( T &&  x, char const *  fmt, char const *  file, char const *  function, unsigned int  line, Ts &&...  par  )

inline

divideTuples() [1/2]

template<typename ... T, size_t ... I>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::divideTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b, index_sequence< I... >    )

inline

divideTuples() [2/2]

template<typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::divideTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

divideTuplesHelper()

template<size_t I, typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<I, hydra::thrust::tuple<T...> >::type hydra::detail::divideTuplesHelper ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

eval_on_tuple_element() [1/2]

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 &    )

inline

eval_on_tuple_element() [2/2]

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  )

inline

eval_tuple_element() [1/2]

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 &    )

inline

eval_tuple_element() [2/2]

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  )

inline

extract()

template<typename Type , typename Tuple >

__hydra_host__ __hydra_device__ Type hydra::detail::extract ( const int  idx, const Tuple &  t  )

inline

get_element()

template<typename R , typename ... T>

__hydra_host__ __hydra_device__ R& hydra::detail::get_element ( const size_t  index, hydra::thrust::tuple< T... > &  t  )

inline

get_functor_tuple()

template<typename Tup >

auto hydra::detail::get_functor_tuple ( Tup &  pdfs ) -> decltype(get_functor_tuple_helper(pdfs, make_index_sequence< hydra::thrust::tuple_size<Tup>::value>

inline

get_functor_tuple_helper() [1/2]

template<typename Tup , size_t ... index>

auto hydra::detail::get_functor_tuple_helper ( Tup &  pdfs, index_sequence< index... >    ) -> decltype(hydra::thrust::make_tuple(hydra::thrust::get<index>(pdfs).GetFunctor()...))

inline

get_functor_tuple_helper() [2/2]

return hydra::detail::get_functor_tuple_helper	(	pdfs	,
		make_index_sequence< Size > { }
	)

get_indexes() [1/4]

template<typename T , size_t DIM, size_t I>

std::enable_if< (I==DIM) && (std::is_integral<T>::value), void >::type hydra::detail::get_indexes	(	size_t	,
		std::array< T, DIM > const &	,
		std::array< T, DIM > &
	)

get_indexes() [2/4]

template<typename T , size_t DIM, size_t I = 0>

std::enable_if< (I<DIM) && (std::is_integral<T>::value), void >::type hydra::detail::get_indexes	(	size_t	index,
		std::array< T, DIM > const &	depths,
		std::array< T, DIM > &	indexes
	)

get_indexes() [3/4]

template<typename T , size_t DIM, size_t I>

std::enable_if< (I==DIM) && (std::is_integral<T>::value), void >::type hydra::detail::get_indexes	(	size_t	,
		const	T(&)[DIM],
		T(&)	[DIM]
	)

get_indexes() [4/4]

template<typename T , size_t DIM, size_t I = 0>

std::enable_if< (I<DIM) && (std::is_integral<T>::value), void >::type hydra::detail::get_indexes	(	size_t	index,
		const T(&)	depths[DIM],
		T(&)	indexes[DIM]
	)

get_tuple_element() [1/11]

template<typename T , typename... Types>

__hydra_host__ __hydra_device__ T& hydra::detail::get_tuple_element

(

hydra::thrust::tuple< Types... > &

t

)

get_tuple_element() [2/11]

template<class T , class... Types>

__hydra_host__ __hydra_device__ const T& hydra::detail::get_tuple_element

(

const hydra::thrust::tuple< Types... > &

t

)

get_tuple_element() [3/11]

template<class T , class... Types>

__hydra_host__ __hydra_device__ T&& hydra::detail::get_tuple_element

(

hydra::thrust::tuple< Types... > &&

t

)

get_tuple_element() [4/11]

template<typename T , typename... Types>

__hydra_host__ __hydra_device__ hydra::thrust::device_reference<T> hydra::detail::get_tuple_element

(

hydra::thrust::tuple< hydra::thrust::device_reference< Types >... > &

t

)

get_tuple_element() [5/11]

template<class T , class... Types>

__hydra_host__ __hydra_device__ const hydra::thrust::device_reference<T> hydra::detail::get_tuple_element

(

const hydra::thrust::tuple< hydra::thrust::device_reference< Types >... > &

t

)

get_tuple_element() [6/11]

template<class T , class... Types>

__hydra_host__ __hydra_device__ hydra::thrust::device_reference<T>&& hydra::detail::get_tuple_element

(

hydra::thrust::tuple< hydra::thrust::device_reference< Types >... > &&

t

)

get_tuple_element() [7/11]

template<typename T , typename... Types>

__hydra_host__ __hydra_device__ hydra::thrust::device_reference<T> hydra::detail::get_tuple_element

(

hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< Types >... > &

t

)

get_tuple_element() [8/11]

template<class T , class... Types>

__hydra_host__ __hydra_device__ const hydra::thrust::device_reference<T> hydra::detail::get_tuple_element

(

const hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< Types >... > &

t

)

get_tuple_element() [9/11]

template<class T , class... Types>

__hydra_host__ __hydra_device__ hydra::thrust::device_reference<T> hydra::detail::get_tuple_element

(

hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< Types >... > &&

t

)

get_tuple_element() [10/11]

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 &    )

inline

get_tuple_element() [11/11]

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  )

inline

get_zip_iterator() [1/2]

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>

inline

get_zip_iterator() [2/2]

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>

inline

get_zip_iterator_helper() [1/2]

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]...)) )

inline

get_zip_iterator_helper() [2/2]

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]...)) )

inline

hash_combine()

template<class T >

void hydra::detail::hash_combine ( std::size_t &  seed, T const &  v  )

inline

hash_range() [1/2]

template<class It >

std::size_t hydra::detail::hash_range ( It  first, It  last  )

inline

hash_range() [2/2]

template<class It >

void hydra::detail::hash_range ( std::size_t &  seed, It  first, It  last  )

inline

hash_tuple() [1/2]

template<typename ... T>

void hydra::detail::hash_tuple ( std::size_t &  seed, hydra::tuple< T... > const &  _tuple  )

inline

hash_tuple() [2/2]

template<typename ... T>

std::size_t hydra::detail::hash_tuple ( hydra::tuple< T... > const &  _tuple )

inline

invoke() [1/4]

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>

inline

invoke() [2/4]

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>

inline

invoke() [3/4]

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>

inline

invoke() [4/4]

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>

inline

invoke_helper() [1/5]

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))...))

inline

invoke_helper() [2/5]

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)...))

inline

invoke_helper() [3/5]

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))...) )

inline

invoke_helper() [4/5]

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)...) )

inline

invoke_helper() [5/5]

return hydra::detail::invoke_helper	(	x	,
		y	,
		tup	,
		make_index_sequence< Size > { }
	)

invoke_normalized() [1/2]

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>

inline

invoke_normalized() [2/2]

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>

inline

invoke_normalized_helper() [1/3]

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)...))

inline

invoke_normalized_helper() [2/3]

return hydra::detail::invoke_normalized_helper	(	x	,
		tup	,
		make_index_sequence< Size > { }
	)

invoke_normalized_helper() [3/3]

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))...))

inline

iter_swap()

template<class Iterator >

__hydra_host__ __hydra_device__ void hydra::detail::iter_swap	(	Iterator	first,
		Iterator	second
	)

kill()

template<typename T , typename ... Ts>

__hydra_host__ __hydra_device__ T hydra::detail::kill ( T &&  x )

inline

launch_decayer() [1/4]

template<size_t N, typename GRND , typename Iterator >

void hydra::detail::launch_decayer ( Iterator  begin, Iterator  end, DecayMother< N, GRND > const &  decayer  )

inline

launch_decayer() [2/4]

template<size_t N, typename GRND , typename Iterator , hydra::detail::Backend BACKEND>

void hydra::detail::launch_decayer ( hydra::detail::BackendPolicy< BACKEND > const &  exec_policy, Iterator  begin, Iterator  end, DecayMother< N, GRND > const &  decayer  )

inline

launch_decayer() [3/4]

template<size_t N, typename GRND , typename IteratorMother , typename IteratorDaughter >

void hydra::detail::launch_decayer ( IteratorMother  begin_mothers, IteratorMother  end_mothers, IteratorDaughter  begin_daugters, DecayMothers< N, GRND > const &  decayer  )

inline

launch_decayer() [4/4]

template<size_t N, typename GRND , typename IteratorMother , typename IteratorDaughter , hydra::detail::Backend BACKEND>

void hydra::detail::launch_decayer ( hydra::detail::BackendPolicy< BACKEND > const &  exec_policy, IteratorMother  begin_mothers, IteratorMother  end_mothers, IteratorDaughter  begin_daugters, DecayMothers< N, GRND > const &  decayer  )

inline

launch_evaluator() [1/2]

template<size_t N, typename FUNCTOR , typename ... FUNCTORS, typename GRND , typename Iterator >

void hydra::detail::launch_evaluator ( Iterator  begin, Iterator  end, detail::EvalMother< N, GRND, FUNCTOR, FUNCTORS... > const &  evaluator  )

inline

launch_evaluator() [2/2]

template<size_t N, typename FUNCTOR , typename ... FUNCTORS, typename GRND , typename IteratorMother , typename Iterator >

void hydra::detail::launch_evaluator ( IteratorMother  mbegin, IteratorMother  mend, Iterator  begin, detail::EvalMothers< N, GRND, FUNCTOR, FUNCTORS... > const &  evaluator  )

inline

launch_reducer() [1/2]

template<size_t N, hydra::detail::Backend BACKEND, typename FUNCTOR , typename GRND , typename Iterator >

StatsPHSP hydra::detail::launch_reducer ( hydra::detail::BackendPolicy< BACKEND >const &  policy, Iterator  begin, Iterator  end, detail::AverageMother< N, GRND, FUNCTOR > const &  evaluator  )

inline

launch_reducer() [2/2]

template<size_t N, typename FUNCTOR , typename GRND , typename Iterator >

StatsPHSP hydra::detail::launch_reducer ( Iterator  begin, Iterator  end, detail::AverageMothers< N, GRND, FUNCTOR > const &  evaluator  )

inline

lsb() [1/2]

template<typename Integer >

__hydra_host__ __hydra_device__ std::enable_if< std::is_integral<Integer>::value && !(std::is_signed<Integer>::value) && (sizeof(Integer)==8) , unsigned>::type hydra::detail::lsb ( Integer  x )

inline

lsb() [2/2]

template<typename Integer >

__hydra_host__ __hydra_device__ std::enable_if< std::is_integral<Integer>::value && !(std::is_signed<Integer>::value) && (sizeof(Integer)==4) , unsigned>::type hydra::detail::lsb ( Integer  x )

inline

machine_eps_f32()

__hydra_host__ __hydra_device__ float hydra::detail::machine_eps_f32 ( float  value = 1.0 )

inline

machine_eps_f64()

__hydra_host__ __hydra_device__ double hydra::detail::machine_eps_f64 ( double  value = 1.0 )

inline

make_rtuple()

template<typename ... T>

auto hydra::detail::make_rtuple

(

hydra::thrust::tuple< T... > &

t

)

-> hydra::thrust::tuple<T&...>

make_rtuple_helper()

template<typename ... T, size_t... I>

auto hydra::detail::make_rtuple_helper	(	hydra::thrust::tuple< T... > &	t,
		index_sequence< I... >
	)		-> hydra::thrust::tuple<T&...>

make_tuple()

T ::type TupleType hydra::detail::make_tuple

(

T &&

value

)

max()

template<typename ... T>

__hydra_host__ __hydra_device__ size_t hydra::detail::max ( hydra::thrust::tuple< T... > const &  tuple )

inline

max_helper()

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 &    )

inline

max_helper< T, C, N, I+1 >()

hydra::detail::max_helper< T, C, N, I+1 >	(	tuple	,
		max_value	,
		max_index
	)

meld_iterators()

template<typename ... Iterators>

auto hydra::detail::meld_iterators

(

Iterators &&...

iterators

)

-> decltype( hydra::thrust::make_zip_iterator( hydra::thrust::tuple_cat( meld_iterators_ns::convert_to_tuple(std::forward<Iterators>(iterators))... ) ))

msb() [1/2]

template<typename Integer >

__hydra_host__ __hydra_device__ std::enable_if< std::is_integral<Integer>::value && !(std::is_signed<Integer>::value) && (std::numeric_limits<Integer>::digits==64) , unsigned>::type hydra::detail::msb ( Integer  x )

inline

msb() [2/2]

template<typename Integer >

__hydra_host__ __hydra_device__ std::enable_if< std::is_integral<Integer>::value && !(std::is_signed<Integer>::value) && (std::numeric_limits<Integer>::digits<=32) , unsigned>::type hydra::detail::msb ( Integer  x )

inline

multiply() [1/4]

template<typename T , size_t N, size_t I>

std::enable_if< (I==N), void >::type hydra::detail::multiply	(	std::array< T, N > const &	,
		T &
	)

multiply() [2/4]

template<typename T , size_t N, size_t I = 0>

std::enable_if< (I<N), void >::type hydra::detail::multiply	(	std::array< T, N > const &	obj,
		T &	result
	)

multiply() [3/4]

template<typename T , size_t N, size_t I>

std::enable_if< (I==N), void >::type hydra::detail::multiply	(	const	T(&)[N],
		T &
	)

multiply() [4/4]

template<typename T , size_t N, size_t I = 0>

std::enable_if< (I<N), void >::type hydra::detail::multiply	(	const T(&)	obj[N],
		T &	result
	)

multiply_array_tuple()

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)>

inline

multiply_array_tuple_helper()

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... >    )

inline

multiply_tuple() [1/4]

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 &    )

inline

multiply_tuple() [2/4]

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  )

inline

multiply_tuple() [3/4]

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... > &&    )

inline

multiply_tuple() [4/4]

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  )

inline

multiplyTuples() [1/2]

template<typename ... T, size_t ... I>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::multiplyTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b, index_sequence< I... >    )

inline

multiplyTuples() [2/2]

template<typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::multiplyTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

multiplyTuplesHelper()

template<size_t I, typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<I, hydra::thrust::tuple<T...> >::type hydra::detail::multiplyTuplesHelper ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

next_permutation()

template<class BidirIt >

__hydra_host__ __hydra_device__ bool hydra::detail::next_permutation	(	BidirIt	first,
		BidirIt	last
	)

nth_permutation()

template<typename Iterator , typename Integer , typename Comparator >

std::enable_if< std::is_integral< Integer >::value, void >::type __hydra_host__ __hydra_device__ hydra::detail::nth_permutation	(	Iterator	begin,
		Iterator	end,
		Integer	n,
		Comparator	comp
	)

operator+() [1/2]

template<typename Type >

__hydra_host__ __hydra_device__ GenzMalikBoxResult<Type> hydra::detail::operator+	(	GenzMalikBoxResult< Type >	left,
		GenzMalikBoxResult< Type > const &	right
	)

operator+() [2/2]

template<typename Type , size_t N>

__hydra_host__ __hydra_device__ GenzMalikBoxResult<Type> hydra::detail::operator+	(	GenzMalikBoxResult< Type >	left,
		GenzMalikBox< N > const &	right
	)

pow_helper() [1/2]

template<typename T , unsigned int N, unsigned int I>

__hydra_host__ __hydra_device__ std::enable_if<I==N, void >::type hydra::detail::pow_helper ( T  const, T &    )

inline

pow_helper() [2/2]

template<typename T , unsigned int N, unsigned int I>

__hydra_host__ __hydra_device__ std::enable_if< (I< N), void >::type hydra::detail::pow_helper ( T const  x, T &  r  )

inline

print_parameters_in_tuple() [1/2]

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... > &  )

inline

print_parameters_in_tuple() [2/2]

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 )

inline

product() [1/2]

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  )

inline

product() [2/2]

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  )

inline

product2() [1/2]

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  )

inline

product2() [2/2]

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  )

inline

product_tuple() [1/4]

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 &    )

inline

product_tuple() [2/4]

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  )

inline

product_tuple() [3/4]

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 &&    )

inline

product_tuple() [4/4]

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  )

inline

product_tuple2() [1/4]

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 &    )

inline

product_tuple2() [2/4]

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  )

inline

product_tuple2() [3/4]

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 &&    )

inline

product_tuple2() [4/4]

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  )

inline

product_tuple3() [1/4]

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 &    )

inline

product_tuple3() [2/4]

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  )

inline

product_tuple3() [3/4]

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 &&    )

inline

product_tuple3() [4/4]

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  )

inline

ptr_setter() [1/2]

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
	)

ptr_setter() [2/2]

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 *
	)

rotate()

template<class Iterator >

__hydra_host__ __hydra_device__ Iterator hydra::detail::rotate	(	Iterator	first,
		Iterator	n_first,
		Iterator	last
	)

SafeGreaterThan()

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::detail::SafeGreaterThan ( T  a, T  b, T  tolerance = machine_eps_f64()  )

inline

SafeLessThan()

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::detail::SafeLessThan ( T  a, T  b, T  tolerance = machine_eps_f64()  )

inline

set_functors_in_tuple() [1/2]

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 > &    )

inline

set_functors_in_tuple() [2/2]

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  )

inline

set_ptr_to_tuple_element() [1/2]

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 *&    )

inline

set_ptr_to_tuple_element() [2/2]

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  )

inline

set_ptrs_to_tuple() [1/2]

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 **    )

inline

set_ptrs_to_tuple() [2/2]

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  )

inline

set_tuple_element() [1/2]

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 &    )

inline

set_tuple_element() [2/2]

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  )

inline

split_tuple() [1/2]

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  )

inline

split_tuple() [2/2]

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>

inline

split_tuple_helper() [1/2]

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... >    )

inline

split_tuple_helper() [2/2]

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)... ) ) )

inline

subtractTuples() [1/2]

template<typename ... T, size_t ... I>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::subtractTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b, index_sequence< I... >    )

inline

subtractTuples() [2/2]

template<typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple<T...> hydra::detail::subtractTuples ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

subtractTuplesHelper()

template<size_t I, typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<I, hydra::thrust::tuple<T...> >::type hydra::detail::subtractTuplesHelper ( const hydra::thrust::tuple< T... > &  a, const hydra::thrust::tuple< T... > &  b  )

inline

sum_tuple() [1/4]

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 &&    )

inline

sum_tuple() [2/4]

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  )

inline

sum_tuple() [3/4]

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 &    )

inline

sum_tuple() [4/4]

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  )

inline

sum_tuple2() [1/4]

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 &&    )

inline

sum_tuple2() [2/4]

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  )

inline

sum_tuple2() [3/4]

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 &    )

inline

sum_tuple2() [4/4]

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  )

inline

tupler() [1/2]

template<typename T >

__hydra_host__ __hydra_device__ std::enable_if< detail::is_tuple<T>::value, T>::type hydra::detail::tupler

(

T const &

data

)

tupler() [2/2]

template<typename T >

__hydra_host__ __hydra_device__ std::enable_if<!detail::is_tuple<T>::value, hydra::tuple<T> >::type hydra::detail::tupler

(

T const &

data

)

tupleToArray() [1/5]

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 > &    )

inline

tupleToArray() [2/5]

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  )

inline

tupleToArray() [3/5]

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 *    )

inline

tupleToArray() [4/5]

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  )

inline

tupleToArray() [5/5]

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  )

inline

WithinPrecisionInterval()

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::detail::WithinPrecisionInterval ( T  b, T  a, unsigned int  interval_size = 1  )

inline

zip_iterator_cat()

template<typename ... T>

std::enable_if< all_true<is_zip_iterator<T>::value...>::value, typename detail::merged_zip_iterator<T...>::type >::type hydra::detail::zip_iterator_cat

(

T const &...

zip_iterators

)

Variable Documentation

make_index_sequence< sizeof...(T) -N >

hydra::detail::make_index_sequence< sizeof...(T) -N >

max_value

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)

inline