hydra Namespace Reference

Generic policies definition. More...

Namespaces
	arguments
	cpp
	cuda
	detail
	device
	experimental
	fft
	host
	math_constants
	omp
	placeholders
	random
	tbb

Data Structures
class	AnalyticalIntegral
class	AnalyticalIntegral< Functor, 1 >
struct	Argument
class	ArgusShape
	Implementation describing the ARGUS background shape. More...
class	BaseCompositeFunctor
class	BaseCompositeFunctor< Composite, hydra::thrust::tuple< F1, F2, Fs... >, Signature >
class	BaseCuFFT
class	BaseFFTW
class	BaseFunctor
	Base class for all functors in hydra. More...
class	BifurcatedGaussian
class	BreitWignerLineShape
	Breit-Wigner line shape for 3 body resonant decays \( A -> r c , r-> a b\) , where A is a "long-lived" particle and \( a, b\) and \(c\) are the final states. More...
class	BreitWignerNR
class	Chebychev
	The Chebyshev polynomials \( T_n \) (first kind) are polynomials with the largest possible leading coefficient, but subject to the condition that their absolute value on the interval [−1,1] is bounded by 1. More...
class	ChiSquare
	The chi-squared distribution (also chi-square or \( \chi^2 \) -distribution) with \( k \) degrees of freedom is the distribution of a sum of the squares of k independent standard normal random variables. More...
class	ComplexToComplexCuFFT
class	ComplexToComplexFFTW
class	ComplexToRealCuFFT
class	ComplexToRealFFTW
class	Compose
struct	Constant
class	ConvolutionFunctor
class	ConvolutionFunctor< Functor, Kernel, detail::BackendPolicy< BACKEND >, detail::FFTPolicy< typename std::common_type< typename Functor::return_type, typename Kernel::return_type >::type, FFT >, ArgType >
class	CosHelicityAngle
class	CrystalBallShape
	Implementation the Crystal Ball line shape. More...
class	CubicSpiline
	A simple method for a one—dimensional interpolation on a given set of data points (xi, yi). More...
class	Decays
class	Decays< hydra::tuple< Particles... >, hydra::detail::BackendPolicy< Backend > >
	This class provides storage for N-particle states. More...
class	DeltaDMassBackground
class	DenseHistogram
class	DenseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional >
	Class representing one-dimensional dense histogram. More...
class	DenseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional >
	Class representing multidimensional dense histograms. More...
class	Distribution
struct	Distribution< Class, false >
struct	Distribution< Functor, true >
class	Divide
class	DoubleExponential
	distribution https://en.wikipedia.org/wiki/Laplace_distribution More...
class	Exponential
	https://en.wikipedia.org/wiki/Exponential_function More...
class	FCN
	FCN base class. More...
class	FCN< Estimator< PDF, Iterator >, true >
class	FCN< Estimator< PDF, Iterator, Iterators... >, true >
class	FCN< hydra::thrust::tuple< FCN< ESTIMATORS >... >, false >
class	Gaussian
	Gaussian functions are often used to represent the probability density function of a normally distributed random variable with expected value \( \mu \) and variance \( \sigma \). More...
class	GaussianKDE
class	GaussKronrodAdaptiveQuadrature
class	GaussKronrodAdaptiveQuadrature< NRULE, NBIN, hydra::detail::BackendPolicy< BACKEND > >
struct	GaussKronrodBinary
struct	GaussKronrodCall
class	GaussKronrodQuadrature
class	GaussKronrodQuadrature< NRULE, NBIN, hydra::detail::BackendPolicy< BACKEND > >
struct	GaussKronrodRule
	Rules for Gauss-Kronrod quadrature. More...
struct	GaussKronrodRuleSelector
struct	GaussKronrodRuleSelector< 15 >
	Rules for Gauss-Kronrod quadrature. More...
struct	GaussKronrodRuleSelector< 21 >
	Rules for Gauss-Kronrod quadrature. More...
struct	GaussKronrodRuleSelector< 31 >
	Rules for Gauss-Kronrod quadrature. More...
struct	GaussKronrodRuleSelector< 41 >
	Rules for Gauss-Kronrod quadrature. More...
struct	GaussKronrodRuleSelector< 51 >
	Rules for Gauss-Kronrod quadrature. More...
struct	GaussKronrodRuleSelector< 61 >
	Rules for Gauss-Kronrod quadrature. More...
struct	GaussKronrodUnary
class	GenzMalikQuadrature
class	GenzMalikQuadrature< N, hydra::detail::BackendPolicy< BACKEND > >
	Non-adaptive Genz-Malik multidimensional quadrature. More...
class	GenzMalikRule
class	GenzMalikRule< DIM, hydra::detail::BackendPolicy< BACKEND > >
	Class representing Genz-Malik rule. More...
class	GenzMalikRuleBase
struct	Integral
struct	Integral< Algorithm, 1 >
class	IntegrationFormula
class	IntegrationFormula< ArgusShape< ArgType >, 1 >
class	IntegrationFormula< BifurcatedGaussian< ArgType >, 1 >
class	IntegrationFormula< BreitWignerNR< ArgType >, 1 >
class	IntegrationFormula< Chebychev< Order, ArgType >, 1 >
class	IntegrationFormula< ChiSquare< ArgType >, 1 >
class	IntegrationFormula< CrystalBallShape< ArgType >, 1 >
class	IntegrationFormula< DeltaDMassBackground< ArgType >, 1 >
class	IntegrationFormula< DoubleExponential< ArgType >, 2 >
class	IntegrationFormula< Exponential< ArgType >, 1 >
class	IntegrationFormula< Gaussian< ArgType >, 1 >
class	IntegrationFormula< Ipatia< ArgType >, 1 >
class	IntegrationFormula< JohnsonSU< ArgType >, 1 >
class	IntegrationFormula< LogNormal< ArgType >, 1 >
class	IntegrationFormula< Polynomial< Order, ArgType >, 1 >
class	IntegrationFormula< TrapezoidalShape< ArgType >, 1 >
class	IntegrationFormula< TriangularShape< ArgType >, 1 >
class	IntegrationFormula< UniformShape< ArgType >, 1 >
class	Ipatia
	version of the Ipatia distribution as described in the reference https://doi.org/10.1016/j.nima.2014.06.081. More...
class	JohnsonSU
class	Lambda
class	Lambda< LambdaType, 0 >
class	LogLikelihoodFCN
class	LogLikelihoodFCN< Pdf< Functor, Integrator >, IteratorD, IteratorW... >
class	LogLikelihoodFCN< PDFSumExtendable< Pdfs... >, IteratorD, IteratorW... >
class	LogLikelihoodFCN< PDFSumNonExtendable< Pdfs... >, IteratorD, IteratorW... >
class	LogNormal
	In probability theory, a log-normal (or lognormal) distribution is a continuous probability distribution of a random variable whose logarithm is normally distributed. More...
class	M12PhaseSpaceLineShape
	Two-body phase-space distribution for \( m_{12}\): \[ \frac{dN}{dm_{m_12}} \propto q.p \] . More...
class	M12SqPhaseSpaceLineShape
	Two-body phase-space distribution for \( m_{12}^2\): \[ \frac{dN}{dm^2_{12}} \propto q.p/m^2_{12} \] . More...
class	Minus
class	multiarray
class	multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >
class	Multiply
class	multivector
class	multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND > >
	This class implements storage in SoA layouts for table where all elements have the same type. More...
struct	null_type
class	NumericalIntegral
struct	Parameter
	, More...
class	Pdf
	Class representing probability density functions. More...
class	PDFSumExtendable
	Class representing a pdf object built summing up other pdfs. More...
class	PDFSumNonExtendable
	Class representing a pdf object built summing a pdf adding other pdfs. More...
class	PhaseSpace
	This class implements phase-space Monte Carlo generation in hydra. More...
class	PhaseSpaceIntegrator
class	PhaseSpaceIntegrator< N, hydra::detail::BackendPolicy< BACKEND >, GRND >
class	PhaseSpaceReweight
class	PhaseSpaceWeight
struct	Plain
class	Plain< N, hydra::detail::BackendPolicy< BACKEND >, GRND >
	This class implements the Plain MC numerical integration algorithm in Hydra. More...
struct	PlainState
	Simple structure to hold the results of the Plain MC numerical integration. More...
class	PlanesDeltaAngle
	This functor calculates the delta angle between decay plane of the particle with four-vector d2 and d3 (same plane) and h1 (other plane) More...
class	Polynomial
	From : https://en.wikipedia.org/wiki/Polynomial More...
class	Print
struct	ProcessGaussKronrodAdaptiveQuadrature
class	Range
class	Range< Iterator >
class	Range< Iterator, Functor >
class	RealToComplexCuFFT
class	RealToComplexFFTW
struct	RngBase
class	RngFormula
struct	RngFormula< BifurcatedGaussian< ArgType > >
struct	RngFormula< BreitWignerNR< ArgType > >
struct	RngFormula< ChiSquare< ArgType > >
struct	RngFormula< Exponential< ArgType > >
struct	RngFormula< Gaussian< ArgType > >
struct	RngFormula< JohnsonSU< ArgType > >
struct	RngFormula< LogNormal< ArgType > >
struct	RngFormula< TrapezoidalShape< ArgType > >
struct	RngFormula< TriangularShape< ArgType > >
struct	RngFormula< UniformShape< ArgType > >
class	ScopedBuffer
class	ScopedBuffer< T, detail::BackendPolicy< BACKEND > >
class	SeedRNG
class	sobol_engine
	Instantiations of class template sobol. The sobol_engine uses the algorithm described in [Bratley+Fox, TOMS 14, 88 (1988)] and [Antonov+Saleev, USSR Comput. Maths. Math. Phys. 19, 252 (1980)] . More...
class	SparseHistogram
class	SparseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional >
	Class representing one-dimensional sparse histogram. More...
class	SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional >
	Class representing multidimensional sparse histogram. More...
class	Spline2DFunctor
class	Spline3DFunctor
class	Spline4DFunctor
class	SplineFunctor
class	SPlot
	Implementation of {s}_{Plot} technique for statistical unfolding of sample containing events from different sources. More...
class	Sum
class	ThreeBodyMassThresholdBackground
class	TrapezoidalShape
	In probability theory and statistics, the trapezoidal distribution is a continuous probability distribution the graph of whose probability density function resembles a trapezoid. More...
class	TriangularShape
	From: https://en.wikipedia.org/wiki/Triangular_distribution. More...
class	UniformShape
	From: https://en.wikipedia.org/wiki/Uniform_distribution_(continuous) More...
class	UserParameters
	Class implementing a interface to ROOT::Minuit2::MnUserParameters. More...
class	Vegas
class	Vegas< N, hydra::detail::BackendPolicy< BACKEND >, GRND >
	Class to perform numerical integration using Vegas algorithm. More...
class	VegasState
	Class to hold resources and state of hydra::Vegas integration algorithm. More...
class	VegasState< N, hydra::detail::BackendPolicy< BACKEND > >
	Class to hold resources and state of hydra::Vegas integration algorithm. More...
class	WignerDMatrix
	Calculates the beta-term \[ d^j_{mn}(beta) \] in the matrix element of the finite rotation operator (Wigner's D-function), according to formula 4.3.4(eq. More...
class	ZemachFunction
	Zemach's angular probability distribution for 3-body decays of spinless particle into spinless final states as a function of \(\theta\), the helicity angle: More...

Typedefs
typedef hydra::random::ars	ars
	Ars uses the crypotgraphic AES round function, but a non-cryptographc key schedule to save time and space. More...
template<typename T >
using	complex = hydra::thrust::complex< T >
typedef hydra::random::squares3	default_random_engine
	An implementation-defined "default" random number engine. More...
typedef detail::SobolTable	default_sobol_table
typedef bool	GBool_t
	Boolean (0=false, 1=true) (bool) More...
typedef unsigned char	GByte_t
	Byte (8 bits) (unsigned char) More...
typedef char	GChar_t
	Signed Character 1 byte (char) More...
typedef double	GDouble_t
	Double 8 bytes. More...
typedef float	GFloat_t
	Float 4 bytes (float) More...
typedef int	GInt_t
	Signed integer 4 bytes (int) More...
typedef long long	GLong64_t
	Portable signed long integer 8 bytes. More...
typedef long	GLong_t
	Signed long integer 4 bytes (long) More...
typedef long double	GLongDouble_t
	Long Double. More...
typedef double	GReal_t
	Double 16 bytes or float 4 bytes. More...
typedef short	GShort_t
	Signed Short integer 2 bytes (short) More...
typedef char	GText_t
	General string (char) More...
typedef unsigned char	GUChar_t
	Unsigned Character 1 byte (unsigned char) More...
typedef unsigned int	GUInt_t
	Unsigned integer 4 bytes (unsigned int) More...
typedef unsigned long long	GULong64_t
	Portable unsigned long integer 8 bytes. More...
typedef unsigned long	GULong_t
typedef unsigned short	GUShort_t
	Unsigned Short integer 2 bytes (unsigned short) More...
template<typename T >
using	mc_device_vector = hydra::thrust::device_vector< T >
	Generic template typedef for hydra::thrust::host_vector. More...
template<typename T >
using	mc_host_vector = hydra::thrust::host_vector< T, hydra::thrust::system::cuda::experimental::pinned_allocator< T > >
	Generic template typedef for hydra::thrust::host_vector. More...
typedef hydra::thrust::random::minstd_rand	minstd_rand
	A random number engine with predefined parameters which implements a version of the Minimal Standard random number generation algorithm. More...
typedef hydra::thrust::random::minstd_rand0	minstd_rand0
	A random number engine with predefined parameters which implements a version of the Minimal Standard random number generation algorithm. More...
template<typename T1 , typename T2 >
using	pair = hydra::thrust::pair< T1, T2 >
	pair template is an alias to the hydra::thrust::pair structure. More...
typedef hydra::random::philox	philox
	The Philox family of counter-based RNGs use integer multiplication, xor and permutation of W-bit words to scramble its N-word input key. More...
typedef hydra::random::philox_long	philox_long
typedef hydra::thrust::random::ranlux24	ranlux24
	A random number engine with predefined parameters which implements the RANLUX level-3 random number generation algorithm. More...
typedef hydra::thrust::random::ranlux48	ranlux48
	A random number engine with predefined parameters which implements the RANLUX level-4 random number generation algorithm. More...
template<unsigned D>
using	sobol = sobol_engine< uint_least64_t, D, 64u, default_sobol_table >
typedef hydra::random::squares3	squares3
	Ars uses the crypotgraphic AES round function, but a non-cryptographc key schedule to save time and space. More...
typedef hydra::random::squares4	squares4
	Ars uses the crypotgraphic AES round function, but a non-cryptographc key schedule to save time and space. More...
typedef hydra::thrust::random::taus88	taus88
	A random number engine with predefined parameters which implements L'Ecuyer's 1996 three-component Tausworthe random number generator. More...
typedef hydra::random::threefry	threefry
	Threefry uses integer addition, bitwise rotation, xor and permutation of words to randomize its output. More...
typedef hydra::random::threefry_long	threefry_long
	Threefry uses integer addition, bitwise rotation, xor and permutation of words to randomize its output. More...
template<typename... T>
using	tuple = hydra::thrust::tuple< T... >
	tuple template is an alias to the variadic version of hydra::thrust::tuple and that can be instantiated with a indefinite number of arguments. More...
template<int N, class T >
using	tuple_element = hydra::thrust::tuple_element< N, T >
	The get function returns a const reference to a tuple element of interest. More...
template<class T >
using	tuple_size = hydra::thrust::tuple_size< T >
	This metafunction returns the number of elements of a tuple type of interest. More...

Enumerations
enum	{ MODE_IMPORTANCE = 1, MODE_IMPORTANCE_ONLY = 0, MODE_STRATIFIED = -1, BINS_MAX = 50 }
enum	{ INFO =0, WARNING =1, ERROR =2 }
enum	Wave {   SWave =0, PWave, DWave, FWave,   GWave, HWave }
	Orbital angular momentum tags. More...

Functions
class	__hydra_align__ (16) Vector3R
	This class represents three-dimensional Euclidian vectors and implements common operation performed on it. More...
template<typename T >
__hydra_host__ __hydra_device__ T	abs (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	acos (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	acosh (const complex< T > &z)
template<typename PDF1 , typename PDF2 , typename ... PDFs>
PDFSumNonExtendable< PDF1, PDF2, PDFs... >	add_pdfs (std::array< Parameter, sizeof...(PDFs)+1 >const &var_list, PDF1 const &pdf1, PDF2 const &pdf2, PDFs const &...pdfs)
	Function to build up non-extendable pdfs models. More...
template<typename PDF1 , typename PDF2 , typename ... PDFs>
PDFSumExtendable< PDF1, PDF2, PDFs... >	add_pdfs (std::array< Parameter, sizeof...(PDFs)+2 >const &var_list, PDF1 const &pdf1, PDF2 const &pdf2, PDFs const &...pdfs)
	Function to build up extendable pdfs models. More...
template<typename T >
__hydra_host__ __hydra_device__ T	arg (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	asin (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	asinh (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	atan (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	atanh (const complex< T > &z)
template<hydra::Wave L>
__hydra_host__ __hydra_device__ double	BarrierFactor (const double d, const double p0, const double p)
	Blatt-Weisskopf B' functions. More...
template<>
__hydra_host__ __hydra_device__ double	BarrierFactor< hydra::DWave > (const double radi, const double p0, const double p)
template<>
__hydra_host__ __hydra_device__ double	BarrierFactor< hydra::FWave > (const double radi, const double p0, const double p)
template<>
__hydra_host__ __hydra_device__ double	BarrierFactor< hydra::GWave > (const double radi, const double p0, const double p)
template<>
__hydra_host__ __hydra_device__ double	BarrierFactor< hydra::HWave > (const double radi, const double p0, const double p)
template<>
__hydra_host__ __hydra_device__ double	BarrierFactor< hydra::PWave > (const double radi, const double p0, const double p)
template<>
__hydra_host__ __hydra_device__ double	BarrierFactor< hydra::SWave > (const double, const double, const double)
template<class C >
auto	begin (const C &c) -> decltype(c.begin())
template<class C >
auto	begin (C &&c) -> decltype(std::forward< C >(c).begin())
template<class T , size_t N>
T *	begin (T(&array)[N])
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	begin (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.begin(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	begin (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.begin(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	begin (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.begin(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	begin (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.begin(placeholders::placeholder< I >
__hydra_host__ __hydra_device__ double	bessel_i (const int n, const double x)
	Modified Bessel function of first kind and order n. More...
__hydra_host__ __hydra_device__ double	bessel_i0 (const double x)
	Modified Bessel function of first kind and order 0. More...
__hydra_host__ __hydra_device__ double	bessel_i1 (const double x)
	Modified Bessel function of first kind and order 1. More...
__hydra_host__ __hydra_device__ double	bessel_j (const int n, const double x)
	Bessel function of first kind and order n. More...
__hydra_host__ __hydra_device__ double	bessel_j0 (const double x)
	Bessel function of first kind and order 0. More...
__hydra_host__ __hydra_device__ double	bessel_j1 (const double x)
	Bessel function of first kind and order 1. More...
__hydra_host__ __hydra_device__ double	bessel_k (const int n, const double x)
	Modified Bessel function of second kind and order n. More...
__hydra_host__ __hydra_device__ double	bessel_k0 (const double x)
	Modified Bessel function of second kind and order 0. More...
__hydra_host__ __hydra_device__ double	bessel_k1 (const double x)
	Modified Bessel function of second kind and order 1. More...
__hydra_host__ __hydra_device__ double	bessel_y (const int n, const double x)
	Bessel function of second kind and order n. More...
__hydra_host__ __hydra_device__ double	bessel_y0 (const double x)
	Bessel function of second kind and order 0. More...
__hydra_host__ __hydra_device__ double	bessel_y1 (const double x)
	Bessel function of second kind and order 1. More...
template<typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< hydra::thrust::permutation_iterator< decltype(std::declval< Iterable & >).begin()), hydra::thrust::transform_iterator< detail::RndUniform< size_t, hydra::thrust::random::default_random_engine >,hydra::thrust::counting_iterator< size_t >, size_t > > > >::type	boost_strapped_range (Iterable &&iterable, size_t seed)
__hydra_host__ __hydra_device__ Vector4R	boostTo (const Vector4R &rs, const Vector4R &p4, bool inverse=false)
__hydra_host__ __hydra_device__ Vector4R	boostTo (const Vector4R &rs, const Vector3R &boost, bool inverse=false)
__hydra_host__ __hydra_device__ double	chebychev_1st_kind (unsigned n, const double x)
	Implementation of Chebychev polynomials of first kind \( P_n(n) \) using the recursive relation. More...
__hydra_host__ __hydra_device__ double	chebychev_2nd_kind (unsigned n, const double x)
	Implementation of Chebychev polynomials of second kind \( P_n(n) \) using the recursive relation. More...
template<typename Iterable_Index , typename Iterable_Values >
auto	collect (Iterable_Index &indexing_scheme, Iterable_Values &collected_values) -> typename std::enable_if< hydra::detail::is_iterable< Iterable_Index >::value &&hydra::detail::is_iterable< Iterable_Values >::value, Range< hydra::thrust::permutation_iterator< decltype(std::declval< Iterable_Values &>().begin()), decltype(std::declval< Iterable_Index &>().begin())> >::type
template<hydra::detail::Backend BACKEND, typename T , size_t N, unsigned int... I>
auto	columns (multiarray< T, N, detail::BackendPolicy< BACKEND >>const &other, placeholders::placeholder< I >...cls) -> Range< decltype(std::declval< multiarray< T, N, detail::BackendPolicy< BACKEND >>const &>().begin(placeholders::placeholder< I >
template<hydra::detail::Backend BACKEND, typename T , size_t N, unsigned int... I>
auto	columns (multiarray< T, N, detail::BackendPolicy< BACKEND >> &other, placeholders::placeholder< I >...cls) -> Range< decltype(std::declval< multiarray< T, N, detail::BackendPolicy< BACKEND >> &&>().begin(placeholders::placeholder< I >
template<hydra::detail::Backend BACKEND, typename ... T, unsigned int... I>
auto	columns (multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >>const &other, placeholders::placeholder< I >...cls) -> Range< decltype(std::declval< multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >> const &>().begin(placeholders::placeholder< I >
template<hydra::detail::Backend BACKEND, typename ... T, unsigned int... I>
auto	columns (multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >> &other, placeholders::placeholder< I >...cls) -> Range< decltype(std::declval< multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >> &>().begin(placeholders::placeholder< I >
template<typename Type , hydra::detail::Backend BACKEND, typename ... T>
auto	columns (multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >> &other) -> Range< decltype(std::declval< multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >> &>().begin(placeholders::placeholder< detail::index_in_tuple< Type, hydra::thrust::tuple< T... > >::value >
template<typename T0 , typename T1 , typename ... Ts>
std::enable_if<(detail::is_hydra_functor< T0 >::value||detail::is_hydra_lambda< T0 >::value) &&(detail::is_hydra_functor< T1 >::value||detail::is_hydra_lambda< T1 >::value) &&detail::all_true<(detail::is_hydra_functor< Ts >::value||detail::is_hydra_lambda< Ts >::value)... >::value, Compose< T0, T1, Ts... > >::type	compose (T0 const &F0, T1 const &F1, Ts const &...Fs)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	conj (const complex< T > &z)
template<typename Value_Type >
Range< hydra::thrust::constant_iterator< Value_Type > >	constant_range (const Value_Type &value)
template<detail::Backend BACKEND, detail::FFTCalculator FFTBackend, typename Functor , typename Kernel , typename Iterable , typename T = typename detail::stripped_type<typename hydra::thrust::iterator_traits<decltype(std::declval<Iterable>().begin())>::value_type>::type, typename USING_CUDA_BACKEND = typename std::conditional< std::is_convertible<detail::BackendPolicy<BACKEND>,hydra::thrust::system::cuda::tag >::value, std::integral_constant<int, 1>,std::integral_constant<int, 0>>::type, typename USING_CUFFT = typename std::conditional< FFTBackend==detail::CuFFT, std::integral_constant<int, 1>,std::integral_constant<int, 0>>::type, typename GPU_DATA = typename std::conditional< std::is_convertible<typename hydra::thrust::iterator_system< decltype(std::declval<Iterable>().begin())>::type, hydra::thrust::system::cuda::tag>::value , std::integral_constant<int, 1>, std::integral_constant<int, 0> >::type>
std::enable_if< std::is_floating_point< T >::value &&hydra::detail::is_iterable< Iterable >::value,void >::type	convolute (detail::BackendPolicy< BACKEND > policy, detail::FFTPolicy< T, FFTBackend > fft_policy, Functor const &functor, Kernel const &kernel, T min, T max, Iterable &&output, bool power_up=true)
template<typename Iterable_Source , typename Iterable_Target >
std::enable_if< hydra::detail::is_iterable< Iterable_Source >::value &&hydra::detail::is_iterable< Iterable_Target >::value, Range< decltype(std::declval< Iterable_Target & >).begin())> >::type	copy (Iterable_Source &&source, Iterable_Target &&destination)
template<typename InputIterator , typename OutputIterator >
OutputIterator	copy (InputIterator first, InputIterator last, OutputIterator result)
template<detail::Backend Backend, typename InputIterator , typename OutputIterator >
OutputIterator	copy (hydra::detail::BackendPolicy< Backend > const &policy, InputIterator first, InputIterator last, OutputIterator result)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	cos (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	cosh (const complex< T > &z)
__hydra_host__ __hydra_device__ Vector3R	cross (const Vector3R &p1, const Vector3R &p2)
template<typename Iterator >
__hydra_host__ __hydra_device__ auto	distance (Iterator first, Iterator last) -> decltype(hydra::thrust::distance< Iterator >(first, last))
template<typename F1 , typename F2 , typename ... Fs>
std::enable_if<(detail::is_hydra_functor< F1 >::value||detail::is_hydra_lambda< F1 >::value) &&(detail::is_hydra_functor< F2 >::value||detail::is_hydra_lambda< F2 >::value), Divide< F1, F2 > >::type	divide (F1 const &f1, F2 const &f2)
template<class C >
auto	end (const C &c) -> decltype(c.end())
template<class C >
auto	end (C &&c) -> decltype(std::forward< C >(c).end())
template<class T , size_t N>
T *	end (T(&array)[N])
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	end (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.end(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	end (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.end(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	end (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.end(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	end (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.end(placeholders::placeholder< I >
__hydra_host__ __hydra_device__ long double	erfinv (double x)
template<hydra::detail::Backend BACKEND, typename Iterator , typename Functor >
auto	eval (hydra::detail::BackendPolicy< BACKEND >, Functor const &functor, Iterator begin, Iterator end) -> typename hydra::detail::BackendPolicy< BACKEND >::template container< typename Functor::return_type >
	Evaluate a hydra functor on a range using the parallel policy. More...
template<hydra::detail::Backend BACKEND, typename Iterator , typename ... Functors>
auto	eval (hydra::detail::BackendPolicy< BACKEND >,hydra::thrust::tuple< Functors... > const &functors, Iterator begin, Iterator end) -> multivector< hydra::thrust::tuple< typename Functors::return_type ... >, hydra::detail::BackendPolicy< BACKEND >>
	Evaluate a tuple of hydra functors on a range using the parallel policy. More...
template<hydra::detail::Backend BACKEND, typename Functor , typename Iterator , typename ... Iterators>
auto	eval (hydra::detail::BackendPolicy< BACKEND >, Functor const &functor, Iterator begin, Iterator end, Iterators... begins) -> typename hydra::detail::BackendPolicy< BACKEND >::template container< typename Functor::return_type >
	Evaluate a functor over a list of ranges. More...
template<hydra::detail::Backend BACKEND, typename Iterator , typename ... Iterators, typename ... Functors>
auto	eval (hydra::detail::BackendPolicy< BACKEND >, hydra::thrust::tuple< Functors... > const &functors, Iterator begin, Iterator end, Iterators... begins) -> multivector< hydra::thrust::tuple< typename Functors::return_type ... >, hydra::detail::BackendPolicy< BACKEND > >
	Evaluate a tuple of functors over a list of ranges. More...
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	exp (const complex< T > &z)
template<typename Engine , hydra::detail::Backend BACKEND, typename Iterator , typename FUNCTOR >
std::enable_if< hydra::detail::has_rng_formula< FUNCTOR >::value &&std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename hydra::thrust::iterator_traits< Iterator >::value_type >::value, void >::type	fill_random (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterator begin, Iterator end, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution using a RNG analytical formula. More...
template<typename Engine , typename Iterator , typename FUNCTOR >
std::enable_if< hydra::detail::has_rng_formula< FUNCTOR >::value &&std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename hydra::thrust::iterator_traits< Iterator >::value_type >::value, void >::type	fill_random (Iterator begin, Iterator end, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution using a RNG analytical formula. More...
template<typename Engine , hydra::detail::Backend BACKEND, typename Iterable , typename FUNCTOR >
std::enable_if< detail::random::is_matching_iterable< Engine, FUNCTOR, Iterable >::value, void >::type	fill_random (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterable &&iterable, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename Engine , typename Iterable , typename FUNCTOR >
std::enable_if< detail::random::is_matching_iterable< Engine, FUNCTOR, Iterable >::value, void >::type	fill_random (Iterable &&iterable, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename Engine , hydra::detail::Backend BACKEND, typename Iterator , typename FUNCTOR >
std::enable_if< !hydra::detail::has_rng_formula< FUNCTOR >::value, void >::type	fill_random (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterator begin, Iterator end, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fall back function if RngFormula is not implemented for the requested functor. More...
template<typename Engine , typename Iterator , typename FUNCTOR >
std::enable_if< !hydra::detail::has_rng_formula< FUNCTOR >::value, void >::type	fill_random (Iterator begin, Iterator end, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fall back function if RngFormula is not implemented for the requested functor. More...
template<typename Engine , hydra::detail::Backend BACKEND, typename Iterator , typename FUNCTOR >
std::enable_if< !std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename std::iterator_traits< Iterator >::value_type >::value &&hydra::detail::has_rng_formula< FUNCTOR >::value, void >::type	fill_random (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterator begin, Iterator end, FUNCTOR const &funct, size_t seed, size_t rng_jump)
	Fall back function if RngFormula::Generate() return value is not convertible to functor return value. More...
template<typename Engine , typename Iterator , typename FUNCTOR >
std::enable_if< !std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename std::iterator_traits< Iterator >::value_type >::value &&hydra::detail::has_rng_formula< FUNCTOR >::value, void >::type	fill_random (Iterator begin, Iterator end, FUNCTOR const &funct, size_t seed, size_t rng_jump)
	Fall back function if RngFormula::Generate() return value is not convertible to functor return value. More...
template<typename Engine , hydra::detail::Backend BACKEND, typename Iterable , typename FUNCTOR >
std::enable_if< !(detail::random::is_matching_iterable< Engine, FUNCTOR, Iterable >::value), void >::type	fill_random (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterable &&iterable, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fall back function if the argument is not an Iterable or if it is not convertible to the Functor return value. More...
template<typename Engine , typename Iterable , typename FUNCTOR >
std::enable_if<!detail::random::is_matching_iterable< Engine, FUNCTOR, Iterable >::value, void >::type	fill_random (Iterable &&iterable, FUNCTOR const &functor, size_t seed, size_t rng_jump)
	Fall back function if the argument is not an Iterable or if it is not convertible to the Functor return value. More...
template<typename Engine = hydra::default_random_engine, typename Iterable , typename FUNCTOR >
std::enable_if<!(detail::random::is_matching_iterable< Engine, FUNCTOR, Iterable >::value), void >::type	fill_random (Iterable &&iterable, FUNCTOR const &functor, size_t seed=0x254a0afcf7da74a2, size_t rng_jump=0)
	Fall back function if the argument is not an Iterable or if itis not convertible to the Functor return value. More...
template<typename Iterable , typename Functor >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, hydra::Range< decltype(std::declval< Iterable >).begin())> >::type	filter (Iterable &&container, Functor &&filter)
template<typename Iterable , typename Functor >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, hydra::Range< decltype(std::declval< Iterable >).begin())> >::type	filter (Iterable &&container, Functor const &filter)
	Apply a filter to the range [first, last] and return a pair of iterators for the filtered events. More...
template<typename Iterable , typename Functor >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable & >).begin())> >::type	for_each (Iterable &&iterable, Functor const &functor)
template<class ... T>
__hydra_host__ __hydra_device__ auto	forward_as_tuple (T &&...t) -> decltype(hydra::thrust::forward_as_tuple(std::forward< T >(t)...))
	Constructs a tuple of references to the arguments in args suitable for forwarding as an argument to a function. More...
template<typename Iterable_Source , typename Iterable_Target , typename Iterable_Map >
std::enable_if< hydra::detail::is_iterable< Iterable_Source >::value &&hydra::detail::is_iterable< Iterable_Target >::value &&hydra::detail::is_iterable< Iterable_Map >::value, Range< decltype(std::declval< Iterable_Target & >).begin())> >::type	gather (Iterable_Source &&source, Iterable_Map &&map, Iterable_Target &&target)
template<int I, int N, typename T >
__hydra_host__ __hydra_device__ T	get (T(&array)[N])
template<int I, typename T >
__hydra_host__ __hydra_device__ T	get (T *array)
template<typename Type , typename ... T>
__hydra_host__ __hydra_device__ Type &	get (hydra::thrust::tuple< T... > const &t)
	The get function returns a reference to a tuple element of interest. More...
template<int N, typename ... T>
__hydra_host__ __hydra_device__ const hydra::thrust::tuple_element< N, hydra::thrust::tuple< T... > >::type &	get (hydra::thrust::tuple< T... > const &t)
template<typename Type , typename ... T>
__hydra_host__ __hydra_device__ Type &	get (hydra::thrust::tuple< T... > &t)
template<int N, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< N, hydra::thrust::tuple< T... > >::type &	get (hydra::thrust::tuple< T... > &t)
template<typename Type , typename ... T>
__hydra_host__ __hydra_device__ Type &&	get (hydra::thrust::tuple< T... > &&t)
template<int N, typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< N, hydra::thrust::tuple< T... > >::type &&	get (hydra::thrust::tuple< T... > &&t)
template<int N, typename T1 , typename T2 >
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< N, hydra::thrust::pair< T1, T2 > >::type &	get (hydra::thrust::pair< T1, T2 > &t)
template<int N, typename T1 , typename T2 >
__hydra_host__ __hydra_device__ const hydra::thrust::tuple_element< N, hydra::thrust::pair< T1, T2 > >::type &	get (hydra::thrust::pair< T1, T2 > const &t)
template<int N, typename T1 , typename T2 >
__hydra_host__ __hydra_device__ hydra::thrust::tuple_element< N, hydra::thrust::pair< T1, T2 > >::type &&	get (hydra::thrust::pair< T1, T2 > &&t)
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	get (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.column(placeholders::placeholder< I >
	Return the column _I of the hydra::multiarray. More...
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	get (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.column(placeholders::placeholder< I >
	Return the column _I of the hydra::multiarray. More...
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	get (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.column(placeholders::placeholder< I >
template<typename ... T>
__hydra_host__ __hydra_device__ detail::tuple_utility::flat_tuple< T... >::type	get_flat_tuple (T const &... args)
template<typename... Args>
std::string	GetFormatedString (const char *format, Args... args)
__hydra_host__ __hydra_device__ double	hermite (unsigned n, const double x)
	Implementation of Hermite polynomials \( P_n(n) \) using the recursive relation. More...
__hydra_host__ __hydra_device__ double	jacobi (double a, double b, unsigned n, const double x)
	P_{n-1}^{(,)}(z) - 2 (n+ - 1) (n + -1) (2n+ + ) P_{n-2}^{(, )}(z), {align}</math> More...
__hydra_host__ __hydra_device__ double	laguerre (unsigned n, const double x)
	Implementation of Laguerre polynomials \( P_n(n) \) using the recursive relation. More...
__hydra_host__ __hydra_device__ double	legendre (unsigned n, const double x)
	Implementation of Legendre polynomials \( P_n(n) \) using the recursive relation. More...
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	log (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	log10 (const complex< T > &z)
template<typename ArgType , typename Functor , typename Kernel , detail::Backend BACKEND, detail::FFTCalculator FFT, typename T = typename detail::stripped_type<typename std::common_type<typename Functor::return_type, typename Kernel::return_type>::type>::type>
std::enable_if< std::is_floating_point< T >::value, ConvolutionFunctor< Functor, Kernel, detail::BackendPolicy< BACKEND >, detail::FFTPolicy< T, FFT >, ArgType > >::type	make_convolution (detail::BackendPolicy< BACKEND > const &, detail::FFTPolicy< T, FFT > const &, Functor const &functor, Kernel const &kernel, T kmin, T kmax, unsigned nsamples=1024, bool interpolate=true, bool power_up=true)
template<typename T , typename Iterator1 , typename Iterator2 , size_t N, hydra::detail::Backend BACKEND>
DenseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional >	make_dense_histogram (detail::BackendPolicy< BACKEND >, std::array< size_t, N > const &grid, std::array< double, N > const &lowerlimits, std::array< double, N > const &upperlimits, Iterator1 first, Iterator1 end, Iterator2 wfirst)
template<typename T , typename Iterator , size_t N, hydra::detail::Backend BACKEND>
DenseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional >	make_dense_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N >const &grid, std::array< double, N > const &lowerlimits, std::array< double, N > const &upperlimits, Iterator first, Iterator end)
	Function to make a N-dimensional dense histogram. More...
template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, DenseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > >::type	make_dense_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N > const &grid, std::array< double, N > const &lowerlimits, std::array< double, N > const &upperlimits, Iterable &&data)
	Function to make a N-dimensional dense histogram. More...
template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable1 , typename Iterable2 >
std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value, DenseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > >::type	make_dense_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N > const &grid, std::array< double, N > const &lowerlimits, std::array< double, N > const &upperlimits, Iterable1 &&data, Iterable2 &&weight)
	Function to make a N-dimensional dense histogram. More...
template<typename T , typename Iterator , hydra::detail::Backend BACKEND>
DenseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional >	make_dense_histogram (detail::BackendPolicy< BACKEND > backend, size_t nbins, double lowerlimit, double upperlimit, Iterator first, Iterator end)
	Function to make a 1-dimensional dense histogram. More...
template<typename T , typename Iterator1 , typename Iterator2 , hydra::detail::Backend BACKEND>
DenseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional >	make_dense_histogram (detail::BackendPolicy< BACKEND > backend, size_t nbins, double lowerlimit, double upperlimit, Iterator1 first, Iterator1 end, Iterator2 wfirst)
	Function to make a 1-dimensional dense histogram. More...
template<typename T , hydra::detail::Backend BACKEND, typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, DenseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional > >::type	make_dense_histogram (detail::BackendPolicy< BACKEND > backend, size_t nbins, double lowerlimits, double upperlimits, Iterable &&data)
	Function to make a N-dimensional dense histogram. More...
template<typename T , hydra::detail::Backend BACKEND, typename Iterable1 , typename Iterable2 >
std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value, DenseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional > >::type	make_dense_histogram (detail::BackendPolicy< BACKEND > backend, size_t nbins, double lowerlimits, double upperlimits, Iterable1 &&data, Iterable2 &&weight)
	Function to make a N-dimensional dense histogram. More...
template<typename... Pdfs, typename Iterator , typename ... Iterators>
std::enable_if< detail::is_iterator< Iterator >::value &&detail::are_iterators< Iterators... >::value, LogLikelihoodFCN< PDFSumExtendable< Pdfs... >, Iterator, Iterators... > >::type	make_loglikehood_fcn (PDFSumExtendable< Pdfs... > const &functor, Iterator first, Iterator last, Iterators... weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename... Pdfs, typename Iterator , typename ... Iterators>
std::enable_if< hydra::detail::is_iterator< Iterator >::value &&detail::are_iterators< Iterators... >::value, LogLikelihoodFCN< PDFSumExtendable< Pdfs... >, Iterator, Iterators... > >::type	make_loglikehood_fcn (PDFSumExtendable< Pdfs... > const &functor, Iterator first, Iterator last, Iterators... weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename Functor , typename Integrator , typename Iterator , typename ... Iterators>
std::enable_if< detail::is_iterator< Iterator >::value &&detail::are_iterators< Iterators... >::value, LogLikelihoodFCN< Pdf< Functor, Integrator >, Iterator, Iterators... > >::type	make_loglikehood_fcn (Pdf< Functor, Integrator > const &pdf, Iterator first, Iterator last, Iterators... weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename... Pdfs, typename Iterator , typename ... Iterators>
std::enable_if< hydra::detail::is_iterator< Iterator >::value &&detail::are_iterators< Iterators... >::value, LogLikelihoodFCN< PDFSumNonExtendable< Pdfs... >, Iterator, Iterators... > >::type	make_loglikehood_fcn (PDFSumNonExtendable< Pdfs... >const &pdf, Iterator first, Iterator last, Iterators... weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename ... Pdfs, typename Iterable , typename ... Iterables>
std::enable_if<(!detail::is_iterator< Iterable >::value) &&((sizeof...(Iterables)==0)||!detail::are_iterators< Iterables... >::value) &&(!hydra::detail::is_hydra_dense_histogram< typename std::remove_reference< Iterable >::type >::value) &&(!hydra::detail::is_hydra_sparse_histogram< typename std::remove_reference< Iterable >::type >::value) &&detail::is_iterable< Iterable >::value &&detail::are_iterables< Iterables... >::value,LogLikelihoodFCN< PDFSumExtendable< Pdfs... >, decltype(std::declval< Iterable >).begin()), decltype(std::declval< Iterables >).begin())... > >::type	make_loglikehood_fcn (PDFSumExtendable< Pdfs... > const &functor, Iterable &&points, Iterables &&... weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename ... Pdfs, typename Iterable , typename... Iterables>
std::enable_if<(!detail::is_iterator< Iterable >::value) &&((sizeof...(Iterables)==0)||!detail::are_iterators< Iterables... >::value) &&(!hydra::detail::is_hydra_dense_histogram< typename std::remove_reference< Iterable >::type >::value) &&(!hydra::detail::is_hydra_sparse_histogram< typename std::remove_reference< Iterable >::type >::value) &&detail::is_iterable< Iterable >::value &&detail::are_iterables< Iterables... >::value, LogLikelihoodFCN< PDFSumExtendable< Pdfs... >, decltype(std::declval< Iterable >).begin()), decltype(std::declval< Iterables >).begin())... > >::type	make_loglikehood_fcn (PDFSumExtendable< Pdfs... > const &functor, Iterable &&points, Iterables &&...weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename Functor , typename Integrator , typename Iterable , typename ... Iterables>
std::enable_if<(!detail::is_iterator< Iterable >::value) &&((sizeof...(Iterables)==0)||!detail::are_iterators< Iterables... >::value) &&(!hydra::detail::is_hydra_dense_histogram< typename std::remove_reference< Iterable >::type >::value) &&(!hydra::detail::is_hydra_sparse_histogram< typename std::remove_reference< Iterable >::type >::value) &&detail::is_iterable< Iterable >::value &&detail::are_iterables< Iterables... >::value, LogLikelihoodFCN< Pdf< Functor, Integrator >, decltype(std::declval< Iterable >).begin()), decltype(std::declval< Iterables >).begin())... > >::type	make_loglikehood_fcn (Pdf< Functor, Integrator > const &pdf, Iterable &&points, Iterables &&... weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename ... Pdfs, typename Iterable , typename ... Iterables>
std::enable_if<(!detail::is_iterator< Iterable >::value) &&((sizeof...(Iterables)==0)||!detail::are_iterators< Iterables... >::value) &&(!hydra::detail::is_hydra_dense_histogram< typename std::remove_reference< Iterable >::type >::value) &&(!hydra::detail::is_hydra_sparse_histogram< typename std::remove_reference< Iterable >::type >::value) &&hydra::detail::is_iterable< Iterable >::value &&detail::are_iterables< Iterables... >::value, LogLikelihoodFCN< PDFSumNonExtendable< Pdfs... >, decltype(std::declval< Iterable >).begin()), decltype(std::declval< Iterables >).begin())... > >::type	make_loglikehood_fcn (PDFSumNonExtendable< Pdfs... > const &functor, Iterable &&points, Iterables &&... weights)
	Conveniency function to build up loglikehood fcns. More...
template<typename ... Pdfs, typename Histogram >
std::enable_if< detail::is_hydra_dense_histogram< Histogram >::value||detail::is_hydra_sparse_histogram< Histogram >::value, LogLikelihoodFCN< PDFSumExtendable< Pdfs... >, decltype(std::declval< const Histogram & >).GetBinsCenters().begin()), decltype(std::declval< const Histogram & >).GetBinsContents().begin()) > >::type	make_loglikehood_fcn (PDFSumExtendable< Pdfs... > const &functor, Histogram const &points)
template<typename ... Pdfs, typename Histogram >
std::enable_if< detail::is_hydra_dense_histogram< Histogram >::value||detail::is_hydra_sparse_histogram< Histogram >::value, LogLikelihoodFCN< PDFSumNonExtendable< Pdfs... >, decltype(std::declval< const Histogram & >).GetBinsCenters().begin()), decltype(std::declval< const Histogram & >).GetBinsContents().begin()) > >::type	make_loglikehood_fcn (PDFSumNonExtendable< Pdfs... > const &functor, Histogram const &points)
	Convenience function to build up loglikehood fcns for densely and sparsely binned datasets. More...
template<typename Functor , typename Integrator , typename Histogram >
std::enable_if< detail::is_hydra_dense_histogram< Histogram >::value||detail::is_hydra_sparse_histogram< Histogram >::value, LogLikelihoodFCN< Pdf< Functor, Integrator >, decltype(std::declval< const Histogram & >).GetBinsCenters().begin()), decltype(std::declval< const Histogram & >).GetBinsContents().begin())> >::type	make_loglikehood_fcn (Pdf< Functor, Integrator > const &pdf, Histogram const &points)
	Convenience function to build up loglikehood fcns for densely and sparsely binned datasets. More...
template<typename Functor , typename Integrator , typename Histogram >
std::enable_if< detail::is_hydra_dense_histogram< Histogram >::value||detail::is_hydra_sparse_histogram< Histogram >::value, LogLikelihoodFCN< Pdf< Functor, Integrator >, decltype(std::declval< const Histogram >).GetBinsCenters().begin()), decltype(std::declval< const Histogram >).GetBinsContents().begin())> >::type	make_loglikehood_fcn (Pdf< Functor, Integrator > const &pdf, Histogram const &points)
	Convenience function to build up loglikehood fcns for densely and sparsely binned datasets. More...
template<class T1 , class T2 >
__hydra_host__ __hydra_device__ auto	make_pair (T1 &&t1, T2 &&t2) -> decltype(hydra::thrust::make_pair(std::forward< T1 >(t1), std::forward< T2 >(t2)))
	This version of make_pair creates a new pair object from a list of objects. More...
template<typename FUNCTOR , typename INTEGRATOR >
Pdf< FUNCTOR, INTEGRATOR >	make_pdf (FUNCTOR const &functor, INTEGRATOR integrator)
	Build a hydra::Pdf given a shape described by a functor and a integrator (algorithm or functor). More...
template<typename Iterator , typename Functor >
hydra::thrust::detail::enable_if< detail::is_hydra_functor< Functor >::value, Range< Iterator, Functor > >::type	make_range (Iterator begin, Iterator end, Functor const &functor)
template<typename Iterator >
Range< Iterator >	make_range (Iterator begin, Iterator end)
template<typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable >).begin())> >::type	make_range (Iterable const &container)
template<typename Iterable , typename Functor >
hydra::thrust::detail::enable_if< detail::is_iterable< Iterable >::value &&detail::is_hydra_functor< Functor >::value, Range< decltype(std::declval< Iterable >).begin()), Functor > >::type	make_range (Iterable const &iterable, Functor const &functor)
template<typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable >).begin())> >::type	make_range (Iterable &&container)
template<typename Iterable , typename Functor >
hydra::thrust::detail::enable_if< detail::is_iterable< Iterable >::value &&detail::is_hydra_functor< Functor >::value, Range< decltype(std::declval< Iterable >).begin()), Functor > >::type	make_range (Iterable &&iterable, Functor const &functor)
template<typename Iterator , typename Functor >
hydra::thrust::detail::enable_if< detail::is_hydra_functor< Functor >::value, Range< hydra::thrust::reverse_iterator< Iterator >, Functor > >::type	make_reverse_range (Iterator begin, Iterator end, Functor const &functor)
template<typename Iterator >
Range< hydra::thrust::reverse_iterator< Iterator > >	make_reverse_range (Iterator begin, Iterator end)
template<typename Iterable >
std::enable_if< hydra::detail::is_reverse_iterable< Iterable >::value, Range< decltype(std::declval< Iterable >).rbegin())> >::type	make_reverse_range (Iterable const &container)
template<typename Iterable >
std::enable_if< hydra::detail::is_reverse_iterable< Iterable >::value, Range< decltype(std::declval< Iterable >).rbegin())> >::type	make_reverse_range (Iterable &&container)
template<typename Iterable , typename Functor >
hydra::thrust::detail::enable_if< detail::is_reverse_iterable< Iterable >::value &&detail::is_hydra_functor< Functor >::value, Range< decltype(std::declval< Iterable >).rbegin()), Functor > >::type	make_reverse_range (Iterable const &iterable, Functor const &functor)
template<typename Iterable , typename Functor >
hydra::thrust::detail::enable_if< detail::is_reverse_iterable< Iterable >::value &&detail::is_hydra_functor< Functor >::value, Range< decltype(std::declval< Iterable >).rbegin()), Functor > >::type	make_reverse_range (Iterable &&iterable, Functor const &functor)
template<typename ... ESTIMATORS>
FCN< hydra::thrust::tuple< FCN< ESTIMATORS >... >, false >	make_simultaneous_fcn (FCN< ESTIMATORS >const &... fcns)
	Convenience function to build up simultaneous fcn simultaneous. More...
template<typename T , typename Iterator , size_t N, hydra::detail::Backend BACKEND>
SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional >	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N > grid, std::array< double, N > const &lowerlimits, std::array< double, N > const &upperlimits, Iterator first, Iterator end)
	Function to make a N-dimensional sparse histogram. More...
template<typename T , typename Iterator1 , typename Iterator2 , size_t N, hydra::detail::Backend BACKEND>
SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional >	make_sparse_histogram (detail::BackendPolicy< BACKEND >, std::array< size_t, N > grid, std::array< double, N > const &lowerlimits, std::array< double, N > const &upperlimits, Iterator1 first, Iterator1 end, Iterator2 wfirst)
	Function to make a N-dimensional sparse histogram. More...
template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > >::type	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N > grid, std::array< double, N >lowerlimits, std::array< double, N > upperlimits, Iterable &&data)
template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable1 , typename Iterable2 >
std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value, SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > >::type	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N > grid, std::array< double, N >lowerlimits, std::array< double, N > upperlimits, Iterable1 &&data, Iterable2 &&weights)
template<typename T , typename Iterator , hydra::detail::Backend BACKEND>
SparseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional >	make_sparse_histogram (detail::BackendPolicy< BACKEND >, size_t grid, double lowerlimits, double upperlimits, Iterator first, Iterator end)
	Function to make a 1-dimensional sparse histogram. More...
template<typename T , typename Iterator1 , typename Iterator2 , hydra::detail::Backend BACKEND>
SparseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional >	make_sparse_histogram (detail::BackendPolicy< BACKEND >, size_t nbins, double lowerlimit, double upperlimit, Iterator1 first, Iterator1 end, Iterator2 wfirst)
	Function to make a 1-dimensional sparse histogram. More...
template<typename T , hydra::detail::Backend BACKEND, typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, SparseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional > >::type	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, size_t nbins, double lowerlimit, double upperlimit, Iterable &&data)
	Function to make a 1-dimensional sparse histogram. More...
template<typename T , hydra::detail::Backend BACKEND, typename Iterable1 , typename Iterable2 >
std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value, SparseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional > >::type	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, size_t nbins, double lowerlimit, double upperlimit, Iterable1 &&data, Iterable2 &&weights)
	Function to make a 1-dimensional sparse histogram. More...
template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > >::type	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N >const &grid, std::array< double, N >const &lowerlimits, std::array< double, N >const &upperlimits, Iterable &&data)
	Function to make a N-dimensional sparse histogram. More...
template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable1 , typename Iterable2 >
std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value, SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > >::type	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, std::array< size_t, N >const &grid, std::array< double, N >const &lowerlimits, std::array< double, N >const &upperlimits, Iterable1 &&data, Iterable2 &&weights)
	Function to make a N-dimensional sparse histogram. More...
template<typename T , typename Iterator , hydra::detail::Backend BACKEND>
SparseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::multidimensional >	make_sparse_histogram (detail::BackendPolicy< BACKEND > backend, size_t nbins, double lowerlimit, double upperlimit, Iterator first, Iterator end)
	Function to make a 1-dimensional sparse histogram. More...
template<typename ArgType , typename Iterator1 , typename Iterator2 >
SplineFunctor< Iterator1, Iterator2, ArgType >	make_spline (Iterator1 firstX, Iterator1 lastX, Iterator2 firstY)
template<typename ArgType , typename Iterable1 , typename Iterable2 >
std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value, SplineFunctor< decltype(std::declval< Iterable1 >).begin()), decltype(std::declval< Iterable2 >).begin()), ArgType > >::type	make_spline (Iterable1 &&x, Iterable2 &&y)
template<typename T , hydra::detail::Backend BACKEND>
SplineFunctor< decltype(std::declval< DenseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > >).GetBinsCenters().begin()), decltype(std::declval< DenseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > >).GetBinsContents().begin()), T >	make_spline (DenseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > const &histogram)
template<typename T , hydra::detail::Backend BACKEND>
std::enable_if< std::is_convertible< T, double >::value, Spline2DFunctor< decltype(std::declval< DenseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_0).begin()), decltype(std::declval< DenseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_1).begin()), decltype(std::declval< DenseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsContents().begin()), double, double > >::type	make_spline (DenseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &histogram)
template<typename T , hydra::detail::Backend BACKEND>
SplineFunctor< decltype(std::declval< SparseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > >).GetBinsCenters().begin()), decltype(std::declval< SparseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > >).GetBinsContents().begin()), T >	make_spline (SparseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > const &histogram)
template<typename T , hydra::detail::Backend BACKEND>
std::enable_if< std::is_convertible< T, double >::value, Spline2DFunctor< decltype(std::declval< SparseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_0).begin()), decltype(std::declval< SparseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_1).begin()), decltype(std::declval< SparseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsContents().begin()), double, double > >::type	make_spline (SparseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &histogram)
template<typename T , hydra::detail::Backend BACKEND>
std::enable_if< std::is_convertible< T, double >::value, Spline3DFunctor< decltype(std::declval< DenseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_0).begin()), decltype(std::declval< DenseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_1).begin()), decltype(std::declval< DenseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_2).begin()), decltype(std::declval< DenseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsContents().begin()), double, double, double > >::type	make_spline (DenseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &histogram)
template<typename T , hydra::detail::Backend BACKEND>
std::enable_if< std::is_convertible< T, double >::value, Spline3DFunctor< decltype(std::declval< SparseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_0).begin()), decltype(std::declval< SparseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_1).begin()), decltype(std::declval< SparseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_2).begin()), decltype(std::declval< SparseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsContents().begin()), double, double, double > >::type	make_spline (SparseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &histogram)
template<typename T , hydra::detail::Backend BACKEND>
std::enable_if< std::is_convertible< T, double >::value, Spline4DFunctor< decltype(std::declval< DenseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_0).begin()), decltype(std::declval< DenseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_1).begin()), decltype(std::declval< DenseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_2).begin()), decltype(std::declval< DenseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_3).begin()), decltype(std::declval< DenseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsContents().begin()), double, double, double, double > >::type	make_spline (DenseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &histogram)
template<typename T , hydra::detail::Backend BACKEND>
std::enable_if< std::is_convertible< T, double >::value, Spline4DFunctor< decltype(std::declval< SparseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_0).begin()), decltype(std::declval< SparseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_1).begin()), decltype(std::declval< SparseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_2).begin()), decltype(std::declval< SparseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsCenters(placeholders::_3).begin()), decltype(std::declval< SparseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > >).GetBinsContents().begin()), double, double, double, double > >::type	make_spline (SparseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &histogram)
template<typename ArgTypeX , typename ArgTypeY , typename IteratorX , typename IteratorY , typename IteratorZ >
Spline2DFunctor< IteratorX, IteratorY, IteratorZ, ArgTypeX, ArgTypeY >	make_spline2D (IteratorX firstX, IteratorX lastX, IteratorY firstY, IteratorY lastY, IteratorZ firstZ)
template<typename ArgTypeX , typename ArgTypeY , typename IterableX , typename IterableY , typename IterableZ >
std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableZ >::value, Spline2DFunctor< decltype(std::declval< IterableX >).begin()),decltype(std::declval< IterableY >).begin()), decltype(std::declval< IterableZ >).begin()), ArgTypeX, ArgTypeY > >::type	make_spline2D (IterableX &&x, IterableY &&y, IterableZ &&z)
template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeZ , typename IteratorX , typename IteratorY , typename IteratorZ , typename IteratorM >
Spline3DFunctor< IteratorX, IteratorY, IteratorZ, IteratorM, ArgTypeX, ArgTypeY, ArgTypeZ >	make_spline3D (IteratorX firstX, IteratorX lastX, IteratorY firstY, IteratorY lastY, IteratorZ firstZ, IteratorZ lastZ, IteratorM measurements_first)
template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeZ , typename IterableX , typename IterableY , typename IterableZ , typename IterableM >
std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableZ >::value &&hydra::detail::is_iterable< IterableM >::value, Spline3DFunctor< decltype(std::declval< IterableX >).begin()),decltype(std::declval< IterableY >).begin()), decltype(std::declval< IterableZ >).begin()), decltype(std::declval< IterableM >).begin()), ArgTypeX, ArgTypeY, ArgTypeZ > >::type	make_spline3D (IterableX &&x, IterableY &&y, IterableZ &&z, IterableM &&measurements)
template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeW , typename ArgTypeZ , typename IteratorX , typename IteratorY , typename IteratorW , typename IteratorZ , typename IteratorM >
Spline4DFunctor< IteratorX, IteratorY, IteratorW, IteratorZ, IteratorM, ArgTypeX, ArgTypeY, ArgTypeW, ArgTypeZ >	make_spline4D (IteratorX firstX, IteratorX lastX, IteratorY firstY, IteratorY lastY, IteratorW firstW, IteratorW lastW, IteratorZ firstZ, IteratorZ lastZ, IteratorM measurements_first)
template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeW , typename ArgTypeZ , typename IterableX , typename IterableY , typename IterableW , typename IterableZ , typename IterableM >
std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableW >::value &&hydra::detail::is_iterable< IterableZ >::value &&hydra::detail::is_iterable< IterableM >::value, Spline4DFunctor< decltype(std::declval< IterableX >).begin()), decltype(std::declval< IterableY >).begin()), decltype(std::declval< IterableW >).begin()), decltype(std::declval< IterableZ >).begin()), decltype(std::declval< IterableM >).begin()), ArgTypeX, ArgTypeY, ArgTypeW, ArgTypeZ > >::type	make_spline4D (IterableX &&x, IterableY &&y, IterableW &&w, IterableZ &&z, IterableM &&measurements)
template<typename Iterator , typename PDF1 , typename PDF2 , typename ... PDFs>
std::enable_if< detail::is_iterator< Iterator >::value, SPlot< Iterator, PDF1, PDF2, PDFs... > >::type	make_splot (PDFSumExtendable< PDF1, PDF2, PDFs... > const &pdf, Iterator first, Iterator last)
	Convenience function for instantiating SPlot objects using type deduction. More...
template<typename Iterable , typename PDF1 , typename PDF2 , typename ... PDFs>
std::enable_if< detail::is_iterable< Iterable >::value, SPlot< decltype(std::declval< Iterable >).begin()), PDF1, PDF2, PDFs... > >::type	make_splot (PDFSumExtendable< PDF1, PDF2, PDFs... > const &pdf, Iterable &&data)
	Convenience function for instantiating SPlot objects using type deduction. More...
template<class ... T>
__hydra_host__ __hydra_device__ auto	make_tuple (T &&... t) -> decltype(hydra::thrust::make_tuple(std::forward< T >(t)...))
	This version of make_tuple creates a new tuple object from a list of objects. More...
template<hydra::detail::Backend BACKEND, typename ... T, typename ... U>
hydra::Range< hydra::thrust::zip_iterator< typename detail::tuple_cat_type< typename multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND > >::iterator_tuple, typename multivector< hydra::thrust::tuple< U... >, detail::BackendPolicy< BACKEND > >::iterator_tuple >::type > >	meld (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &left, multivector< hydra::thrust::tuple< U... >, detail::BackendPolicy< BACKEND >> &right)
template<typename F1 , typename F2 >
std::enable_if<(detail::is_hydra_functor< F1 >::value||detail::is_hydra_lambda< F1 >::value) &&(detail::is_hydra_functor< F2 >::value||detail::is_hydra_lambda< F2 >::value), Minus< F1, F2 > >::type	minus (F1 const &f1, F2 const &f2)
template<typename F1 , typename F2 , typename ... Fs>
std::enable_if<(detail::is_hydra_functor< F1 >::value||detail::is_hydra_lambda< F1 >::value) &&(detail::is_hydra_functor< F2 >::value||detail::is_hydra_lambda< F2 >::value) &&detail::all_true<(detail::is_hydra_functor< Fs >::value||detail::is_hydra_lambda< Fs >::value)... >::value, Multiply< F1, F2, Fs... > >::type	multiply (F1 const &f1, F2 const &f2, Fs const &... functors)
template<typename T >
__hydra_host__ __hydra_device__ int	nint (const T x)
	Round to nearest integer. More...
template<typename T >
__hydra_host__ __hydra_device__ T	norm (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ bool	operator!= (const complex< T > &lhs, const complex< T > &rhs)
template<typename T >
__hydra_host__ __hydra_device__ bool	operator!= (const T &lhs, const complex< T > &rhs)
template<typename T >
__hydra_host__ __hydra_device__ bool	operator!= (const complex< T > &lhs, const T &rhs)
template<typename T , size_t N, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>
bool	operator!= (const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND1 >> &lhs, const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND2 >> &rhs)
template<typename ... T, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>
bool	operator!= (const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND1 >> &lhs, const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND2 >> &rhs)
__hydra_host__ __hydra_device__ Vector3R	operator* (GReal_t c, const Vector3R &v2)
__hydra_host__ __hydra_device__ Vector3R	operator* (const Vector3R &v1, GReal_t c)
__hydra_host__ __hydra_device__ GReal_t	operator* (const Vector3R &v1, const Vector3R &v2)
template<typename T1 , typename T2 >
std::enable_if<(detail::is_hydra_functor< T1 >::value||detail::is_hydra_lambda< T1 >::value) &&(detail::is_hydra_functor< T2 >::value||detail::is_hydra_lambda< T2 >::value), Multiply< T1, T2 > >::type	operator* (T1 const &F1, T2 const &F2)
__hydra_host__ __hydra_device__ Vector4R	operator* (GReal_t c, const Vector4R &v2)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Multiply< Constant< U >, T > >::type	operator* (U const cte, T const &F)
__hydra_host__ __hydra_device__ Vector4R	operator* (const Vector4R &v2, GReal_t c)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Multiply< Constant< U >, T > >::type	operator* (T const &F, U cte)
__hydra_host__ __hydra_device__ GReal_t	operator* (const Vector4R &v1, const Vector4R &v2)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Multiply< Constant< hydra::complex< U > >, T > >::type	operator* (hydra::complex< U > const &cte, T const &F)
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	operator* (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Multiply< Constant< U >, T > >::type	operator* (T const &F, hydra::complex< U > const &cte)
__hydra_host__ __hydra_device__ Parameter	operator* (Parameter par1, Parameter const &par2)
__hydra_host__ __hydra_device__ GReal_t	operator* (Parameter par1, GReal_t par2)
__hydra_host__ __hydra_device__ GReal_t	operator* (GReal_t par1, Parameter const &par2)
__hydra_host__ __hydra_device__ Vector3R	operator+ (const Vector3R &v1, const Vector3R &v2)
template<typename T1 , typename T2 >
std::enable_if<(detail::is_hydra_functor< T1 >::value||detail::is_hydra_lambda< T1 >::value) &&(detail::is_hydra_functor< T2 >::value||detail::is_hydra_lambda< T2 >::value), Sum< T1, T2 > >::type	operator+ (T1 const &F1, T2 const &F2)
	operator+ for two functors. More...
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	operator+ (const hydra::thrust::tuple< T... > a, const hydra::thrust::tuple< T... > &b)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Sum< Constant< U >, T > >::type	operator+ (U const cte, T const &F)
	operator+ for a value and a functor. More...
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Sum< Constant< U >, T > >::type	operator+ (T const &F, U cte)
	operator+ for a value and a functor. More...
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Sum< Constant< hydra::complex< U > >, T > >::type	operator+ (hydra::complex< U > const &cte, T const &F)
	operator+ for a complex value and a functor. More...
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Sum< Constant< U >, T > >::type	operator+ (T const &F, hydra::complex< U > const &cte)
	operator+ for a complex value and a functor. More...
__hydra_host__ __hydra_device__ Vector4R	operator+ (const Vector4R &v1, const Vector4R &v2)
__hydra_host__ __hydra_device__ Parameter	operator+ (Parameter par1, Parameter const &par2)
__hydra_host__ __hydra_device__ GReal_t	operator+ (Parameter par1, GReal_t par2)
template<typename T1 , typename T2 >
std::enable_if<(detail::is_hydra_functor< T1 >::value||detail::is_hydra_lambda< T1 >::value) &&(detail::is_hydra_functor< T2 >::value||detail::is_hydra_lambda< T2 >::value), Minus< T1, T2 > >::type	operator- (T1 const &F1, T2 const &F2)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Minus< Constant< U >, T > >::type	operator- (U const cte, T const &F)
__hydra_host__ __hydra_device__ Vector3R	operator- (const Vector3R &v1, const Vector3R &v2)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Minus< Constant< U >, T > >::type	operator- (T const &F, U cte)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Minus< Constant< hydra::complex< U > >, T > >::type	operator- (hydra::complex< U > const &cte, T const &F)
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	operator- (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Minus< Constant< U >, T > >::type	operator- (T const &F, hydra::complex< U > const &cte)
__hydra_host__ __hydra_device__ Vector4R	operator- (const Vector4R &v1, const Vector4R &v2)
__hydra_host__ __hydra_device__ Parameter	operator- (Parameter par1, Parameter const &par2)
__hydra_host__ __hydra_device__ GReal_t	operator- (Parameter par1, GReal_t par2)
__hydra_host__ __hydra_device__ GReal_t	operator- (GReal_t par1, Parameter par2)
template<typename T1 , typename T2 >
std::enable_if<(detail::is_hydra_functor< T1 >::value||detail::is_hydra_lambda< T1 >::value) &&(detail::is_hydra_functor< T2 >::value||detail::is_hydra_lambda< T2 >::value), Divide< T1, T2 > >::type	operator/ (T1 const &F1, T2 const &F2)
__hydra_host__ __hydra_device__ Vector3R	operator/ (const Vector3R &v1, GReal_t c)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Divide< Constant< U >, T > >::type	operator/ (U const cte, T const &F)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Divide< Constant< U >, T > >::type	operator/ (T const &F, U cte)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Divide< Constant< hydra::complex< U > >, T > >::type	operator/ (hydra::complex< U > const &cte, T const &F)
template<typename T , typename U >
std::enable_if<(detail::is_hydra_functor< T >::value||detail::is_hydra_lambda< T >::value) &&(std::is_arithmetic< U >::value), Divide< Constant< hydra::complex< U > >, T > >::type	operator/ (T const &F, hydra::complex< U > const &cte)
__hydra_host__ __hydra_device__ Vector4R	operator/ (const Vector4R &v2, GReal_t c)
template<typename ... T>
__hydra_host__ __hydra_device__ hydra::thrust::tuple< T... >	operator/ (const hydra::thrust::tuple< T... > &a, const hydra::thrust::tuple< T... > &b)
__hydra_host__ __hydra_device__ Parameter	operator/ (Parameter par1, Parameter const par2)
__hydra_host__ __hydra_device__ GReal_t	operator/ (Parameter par1, GReal_t par2)
__hydra_host__ __hydra_device__ GReal_t	operator/ (GReal_t par1, Parameter par2)
template<size_t N, typename T >
std::ostream &	operator<< (std::ostream &os, std::array< T, N > const &obj)
template<typename ... T>
std::ostream &	operator<< (std::ostream &os, std::tuple< T... > const &obj)
template<typename T1 , typename T2 >
std::ostream &	operator<< (std::ostream &os, std::pair< T1, T2 > const &obj)
ostream &	operator<< (ostream &s, const Vector3R &v)
ostream &	operator<< (ostream &s, const Vector4R &v)
std::ostream &	operator<< (std::ostream &os, UserParameters const &par)
	Print the ROOT::Minuit2 state to stream. More...
template<typename ValueType , class charT , class traits >
std::basic_ostream< charT, traits > &	operator<< (std::basic_ostream< charT, traits > &os, const complex< ValueType > &z)
std::ostream &	operator<< (std::ostream &os, Parameter const &var)
template<typename T >
__hydra_host__ __hydra_device__ bool	operator== (const complex< T > &lhs, const complex< T > &rhs)
template<typename T >
__hydra_host__ __hydra_device__ bool	operator== (const T &lhs, const complex< T > &rhs)
template<typename T >
__hydra_host__ __hydra_device__ bool	operator== (const complex< T > &lhs, const T &rhs)
template<typename T , size_t N, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>
bool	operator== (const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND1 >> &lhs, const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND2 >> &rhs)
template<typename ... T, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>
bool	operator== (const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND1 >> &lhs, const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND2 >> &rhs)
template<typename ValueType , typename charT , class traits >
std::basic_istream< charT, traits > &	operator>> (std::basic_istream< charT, traits > &is, complex< ValueType > &z)
template<typename Iterable , typename Functor >
hydra::thrust::detail::enable_if< detail::is_iterable< Iterable >::value &&(detail::is_hydra_functor< Functor >::value||detail::is_hydra_lambda< Functor >::value), Range< decltype(std::declval< const Iterable >).begin()), Functor > >::type	operator| (Iterable const &iterable, Functor const &functor)
template<typename Iterable , typename Functor >
hydra::thrust::detail::enable_if< detail::is_iterable< Iterable >::value &&(detail::is_hydra_functor< Functor >::value||detail::is_hydra_lambda< Functor >::value), Range< decltype(std::declval< Iterable >).begin()), Functor > >::type	operator| (Iterable &&iterable, Functor const &functor)
template<size_t N>
Range< hydra::thrust::transform_iterator< detail::GenerateDecay< N, hydra::thrust::random::default_random_engine >, hydra::thrust::counting_iterator< size_t >, typename hydra::detail::tuple_cat_type< hydra::thrust::tuple< double >, typename hydra::detail::tuple_type< N, Vector4R >::type >::type > >	phase_space_range (Vector4R const &mother, std::array< double, N > masses, size_t seed, size_t length=0)
__hydra_host__ __hydra_device__ double	pmf (const double mother_mass, const double daughter1_mass, const double daughter2_mass)
	Momentum in mother frame of daughter particle in two-body-decay. More...
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	polar (const T &m, const T &theta=0)
template<typename T , unsigned int N>
__hydra_host__ __hydra_device__ T	pow (T x)
	Power with integer exponent. More...
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	pow (const complex< T > &x, const complex< T > &y)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	pow (const complex< T > &x, const T &y)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	pow (const T &x, const complex< T > &y)
template<typename T , typename U >
__hydra_host__ __hydra_device__ complex< typename hydra::thrust::detail::promoted_numerical_type< T, U >::type >	pow (const complex< T > &x, const complex< U > &y)
template<typename T , typename U >
__hydra_host__ __hydra_device__ complex< typename hydra::thrust::detail::promoted_numerical_type< T, U >::type >	pow (const complex< T > &x, const U &y)
template<typename T , typename U >
__hydra_host__ __hydra_device__ complex< typename hydra::thrust::detail::promoted_numerical_type< T, U >::type >	pow (const T &x, const complex< U > &y)
template<typename... Args>
void	PrintToStream (std::ostream &ostream, const char *format, Args... args)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	proj (const T &z)
template<typename Engine = hydra::default_random_engine, typename Functor >
Range< hydra::thrust::transform_iterator< detail::Sampler< Functor, Engine >, hydra::thrust::counting_iterator< size_t >, typename detail::Sampler< Functor, Engine >::value_type > >	random_range (Functor const &functor, size_t seed=0x8ec74d321e6b5a27, size_t length=0, size_t rng_jump=0)
Range< hydra::thrust::counting_iterator< long int > >	range (long int first, long int last)
template<typename T >
std::enable_if< std::is_floating_point< T >::value, Range< hydra::thrust::counting_iterator< unsigned >, detail::range::Shift< T > > >::type	range (T min, T max, unsigned nbins)
return	Range< iterator_type > (other.begin(cls...), other.end(cls...))
return	Range< iterator_type > (other.begin(placeholders::placeholder< I >{}), other.end(placeholders::placeholder< I >{}))
template<class C >
auto	rbegin (C &&c) -> decltype(std::forward< C >(c).rbegin())
template<class C >
auto	rbegin (const C &c) -> decltype(c.rbegin())
template<class T , size_t N>
T *	rbegin (T(&array)[N])
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	rbegin (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.rbegin(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	rbegin (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.rbegin(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	rbegin (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.rbegin(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	rbegin (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.rbegin(placeholders::placeholder< I >
template<typename Iterable >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, typename hydra::thrust::iterator_traits< decltype(std::declval< Iterable >).begin())>::value_type >::type	reduce (Iterable &&iterable)
template<typename Iterable , typename Functor , typename T = typename hydra::thrust::iterator_traits< decltype(std::declval<Iterable>().begin())>::value_type>
std::enable_if< hydra::detail::is_iterable< Iterable >::value, T >::type	reduce (Iterable &&iterable, T const &init, Functor const &binary_functor)
template<class C >
auto	rend (C &&c) -> decltype(std::forward< C >(c).rend())
template<class C >
auto	rend (const C &c) -> decltype(c.rend())
template<class T , size_t N>
T *	rend (T(&array)[N])
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	rend (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.rend(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>
auto	rend (placeholders::placeholder< I >, multiarray< T, N, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.rend(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	rend (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &other) -> decltype(other.rend(placeholders::placeholder< I >
template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>
auto	rend (multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &other) -> decltype(other.rend(placeholders::placeholder< I >
template<typename Iterable >
hydra::thrust::detail::enable_if< detail::is_iterable< Iterable >::value, Range< hydra::thrust::reverse_iterator< decltype(std::declval< Iterable >).begin()) > > >::type	reverse (Iterable &&iterable)
template<typename T >
__hydra_host__ __hydra_device__ double	rint (T x)
__hydra_host__ __hydra_device__ Vector4R	rotateEuler (const Vector4R &rs, GReal_t alpha, GReal_t beta, GReal_t gamma)
__hydra_host__ __hydra_device__ Vector3R	rotateEuler (const Vector3R &v, GReal_t phi, GReal_t theta, GReal_t ksi)
template<typename RNG , typename DerivedPolicy , typename Functor , typename Iterator >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type	sample (hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &policy, Iterator begin, Iterator end, double min, double max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename Functor , typename Iterator , hydra::detail::Backend BACKEND>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type	sample (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterator begin, Iterator end, double min, double max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename Functor , typename Iterator >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type	sample (Iterator begin, Iterator end, double min, double max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename Functor , typename Iterable >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value,Range< decltype(std::declval< Iterable >).begin())> >::type	sample (Iterable &&output, double min, double max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename DerivedPolicy , typename Functor , typename Iterator , size_t N>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator >>::type	sample (hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &policy, Iterator begin, Iterator end, std::array< double, N > const &min, std::array< double, N > const &max, Functor const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename Functor , typename Iterator , hydra::detail::Backend BACKEND, size_t N>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type	sample (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterator begin, Iterator end, std::array< double, N >const &min, std::array< double, N >const &max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename Functor , typename Iterator , size_t N>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator >>::type	sample (Iterator begin, Iterator end, std::array< double, N >const &min, std::array< double, N >const &max, Functor const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename Functor , typename Iterator >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value &&detail::is_tuple_type< decltype(*std::declval< Iterator >))>::value, Range< Iterator > >::type	sample (Iterator begin, Iterator end, typename Functor::argument_type const &min, typename Functor::argument_type const &max, Functor const &functor, size_t seed, size_t rng_jump)
template<typename RNG , typename Functor , typename Iterable , size_t N>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable >).begin())>>::type	sample (Iterable &&output, std::array< double, N >const &min, std::array< double, N >const &max, Functor const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG , typename Functor , typename Iterable >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value &&detail::is_tuple_type< decltype(*std::declval< Iterable >).begin())>::value,Range< decltype(std::declval< Iterable >).begin())> >::type	sample (Iterable &&output, typename Functor::argument_type const &min, typename Functor::argument_type const &max, Functor const &functor, size_t seed, size_t rng_jump)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG = default_random_engine, typename Functor , typename Iterator , size_t N>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type	sample (Iterator begin, Iterator end, std::array< double, N >const &min, std::array< double, N >const &max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG = default_random_engine, typename DerivedPolicy , typename Functor , typename Iterator , size_t N>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type	sample (hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &policy, Iterator begin, Iterator end, std::array< double, N >const &min, std::array< double, N >const &max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename RNG = default_random_engine, typename Functor , typename Iterable , size_t N>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value,Range< decltype(std::declval< Iterable >).begin())> >::type	sample (Iterable &&output, std::array< double, N >const &min, std::array< double, N >const &max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...
template<typename Iterable_Source , typename Iterable_Target , typename Iterable_Map >
std::enable_if< hydra::detail::is_iterable< Iterable_Source >::value &&hydra::detail::is_iterable< Iterable_Target >::value &&hydra::detail::is_iterable< Iterable_Map >::value, Range< decltype(std::declval< Iterable_Target & >).begin())> >::type	scatter (Iterable_Source &&source, Iterable_Map &&map, Iterable_Target &&target)
template<typename Iterable , typename Functor >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, std::pair< hydra::Range< decltype(std::declval< Iterable >).begin())>, hydra::Range< decltype(std::declval< Iterable >).begin())> > >::type	segregate (Iterable &&container, Functor &&filter)
template<typename Iterable , typename Functor >
std::enable_if< hydra::detail::is_iterable< Iterable >::value, std::pair< hydra::Range< decltype(std::declval< Iterable >).begin())>, hydra::Range< decltype(std::declval< Iterable >).begin())> > >::type	segregate (Iterable &&container, Functor const &filter)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	sin (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	sinh (const complex< T > &z)
template<typename Iterable , typename Iterator = decltype(std::declval<Iterable>().begin())>
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable & >).begin())> >::type	sort (Iterable &iterable)
template<typename Iterable , typename Functor , typename Iterator = decltype(std::declval<Iterable>().begin())>
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable & >).begin())> >::type	sort (Iterable &iterable, Functor const &comparator)
template<typename Iterable , typename Iterable_Key , typename Iterator = decltype(std::declval<Iterable>().begin()), typename Iterator_Key = decltype(std::declval<Iterable_Key>().begin()), typename Value_Key = decltype(*std::declval<Iterator_Key>().begin())>
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable & >).begin())> >::type	sort_by_key (Iterable &iterable, Iterable_Key &keys)
template<typename Iterable , typename Iterator_Key , typename Functor , typename Iterator = decltype(std::declval<Iterable>().begin()), typename Value_Key = decltype(*std::declval<Range<Iterator_Key,Functor>>().begin())>
std::enable_if< hydra::detail::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable & >).begin())> >::type	sort_by_key (Iterable &iterable, Range< Iterator_Key, Functor > keys)
template<typename IterableX , typename IterableY , typename IterableM , typename TypeX , typename TypeY >
__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableM >::value &&std::is_convertible< typename IterableX::value_type, double >::value &&std::is_convertible< typename IterableY::value_type, double >::value &&std::is_convertible< typename IterableM::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value, double >::type	spline (IterableX &&abcissa_x, IterableY &&abcissa_y, IterableM measurements, TypeX x, TypeX y)
template<typename Iterator1 , typename Iterator2 , typename Type >
__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< Iterator1 >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< Iterator2 >::value_type, double >::value &&std::is_convertible< Type, double >::value, Type >::type	spline (Iterator1 first, Iterator1 last, Iterator2 measurements, Type value)
	Cubic monotone spline interpolation. More...
template<typename Iterable1 , typename Iterable2 , typename Type >
__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value &&std::is_convertible< typename Iterable1::value_type, double >::value &&std::is_convertible< typename Iterable2::value_type, double >::value &&std::is_convertible< Type, double >::value, Type >::type	spline (Iterable1 &&abscissae, Iterable2 &&ordinate, Type value)
template<typename IteratorX , typename IteratorY , typename IteratorM , typename TypeX , typename TypeY >
__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< IteratorX >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorY >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorM >::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value, double >::type	spline2D (IteratorX firstx, IteratorX lastx, IteratorY firsty, IteratorY lasty, IteratorM measurements, TypeX x, TypeY y)
template<typename IterableX , typename IterableY , typename IterableM , typename TypeX , typename TypeY >
__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableM >::value &&std::is_convertible< typename IterableX::value_type, double >::value &&std::is_convertible< typename IterableY::value_type, double >::value &&std::is_convertible< typename IterableM::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value, double >::type	spline2D (IterableX &&abscissa_x, IterableY &&abscissa_y, IterableM measurements, TypeX x, TypeX y)
template<typename IteratorX , typename IteratorY , typename IteratorZ , typename IteratorM , typename TypeX , typename TypeY , typename TypeZ >
__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< IteratorX >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorY >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorZ >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorM >::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type	spline3D (IteratorX firstx, IteratorX lastx, IteratorY firsty, IteratorY lasty, IteratorZ firstz, IteratorZ lastz, IteratorM measurements, TypeX x, TypeY y, TypeZ z)
template<typename IterableX , typename IterableY , typename IterableZ , typename IterableM , typename TypeX , typename TypeY , typename TypeZ >
__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableZ >::value &&hydra::detail::is_iterable< IterableM >::value &&std::is_convertible< typename IterableX::value_type, double >::value &&std::is_convertible< typename IterableY::value_type, double >::value &&std::is_convertible< typename IterableZ::value_type, double >::value &&std::is_convertible< typename IterableM::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type	spline3D (IterableX &&abscissa_x, IterableY &&abscissa_y, IterableZ &&abscissa_z, IterableM measurements, TypeX x, TypeX y, TypeZ z)
template<typename IteratorX , typename IteratorY , typename IteratorZ , typename IteratorM , typename TypeX , typename TypeY , typename TypeZ >
__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< IteratorX >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorY >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorZ >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorM >::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type	spline3D (IteratorX firstx, IteratorX lastx, IteratorY firsty, IteratorY lasty, IteratorY firstz, IteratorY lastz, IteratorM measurements, TypeX x, TypeY y, TypeZ z)
template<typename IterableX , typename IterableY , typename IterableW , typename IterableZ , typename IterableM , typename TypeX , typename TypeY , typename TypeW , typename TypeZ >
__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableW >::value &&hydra::detail::is_iterable< IterableZ >::value &&hydra::detail::is_iterable< IterableM >::value &&std::is_convertible< typename IterableX::value_type, double >::value &&std::is_convertible< typename IterableY::value_type, double >::value &&std::is_convertible< typename IterableW::value_type, double >::value &&std::is_convertible< typename IterableZ::value_type, double >::value &&std::is_convertible< typename IterableM::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeW, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type	spline3D (IterableX &&abscissa_x, IterableY &&abscissa_y, IterableW &&abscissa_w, IterableZ &&abscissa_z, IterableM measurements, TypeX x, TypeX y, TypeW w, TypeZ z)
template<typename IteratorX , typename IteratorY , typename IteratorW , typename IteratorZ , typename IteratorM , typename TypeX , typename TypeY , typename TypeW , typename TypeZ >
__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< IteratorX >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorY >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorW >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorZ >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorM >::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeW, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type	spline4D (IteratorX firstx, IteratorX lastx, IteratorY firsty, IteratorY lasty, IteratorW firstw, IteratorW lastw, IteratorZ firstz, IteratorZ lastz, IteratorM measurements, TypeX x, TypeY y, TypeW w, TypeZ z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	sqrt (const complex< T > &z)
template<size_t N, typename T , size_t I>
std::enable_if<(I==N), void >::type	stream_array_helper (std::ostream &, std::array< T, N > const &)
	array streamer helper More...
template<size_t N, typename T , size_t I = 0>
std::enable_if<(I< N), void >::type	stream_array_helper (std::ostream &os, std::array< T, N > const &obj)
template<size_t I, typename ... T>
std::enable_if<(I==sizeof ...(T)), void >::type	stream_tuple_helper (std::ostream &, std::tuple< T... > const &)
	tuple streamer helper More...
template<size_t I = 0, typename ... T>
std::enable_if<(I< sizeof ...(T)), void >::type	stream_tuple_helper (std::ostream &os, std::tuple< T... > const &obj)
template<typename F1 , typename F2 , typename ... Fs>
std::enable_if<(detail::is_hydra_functor< F1 >::value||detail::is_hydra_lambda< F1 >::value) &&(detail::is_hydra_functor< F2 >::value||detail::is_hydra_lambda< F2 >::value) &&detail::all_true<(detail::is_hydra_functor< Fs >::value||detail::is_hydra_lambda< Fs >::value)... >::value, Sum< F1, F2, Fs... > >::type	sum (F1 const &f1, F2 const &f2, Fs const &... functors)
__hydra_host__ __hydra_device__ void	swap (Vector3R &v1, Vector3R &v2)
__hydra_host__ __hydra_device__ void	swap (Vector4R &v1, Vector4R &v2)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	tan (const complex< T > &z)
template<typename T >
__hydra_host__ __hydra_device__ complex< T >	tanh (const complex< T > &z)
template<class ... T>
__hydra_host__ __hydra_device__ auto	tie (T &...t) -> decltype(hydra::thrust::tie(t...))
	This version of tie creates a new tuple whose elements are references which refers to this function's arguments. More...
template<typename Iterable_Input , typename Iterable_Output , typename Functor , typename Iterator = decltype(std::declval<Iterable_Output>().begin())>
std::enable_if< hydra::detail::is_iterable< Iterable_Output >::value, Range< decltype(std::declval< Iterable_Output & >).begin())> >::type	transform (Iterable_Input &&iterable_input, Iterable_Output &&iterable_output, Functor const &unary_functor)
template<typename RNG , typename DerivedPolicy , typename IteratorData , typename IteratorWeight >
std::enable_if< detail::random::is_iterator< IteratorData >::value &&detail::random::is_iterator< IteratorWeight >::value, Range< IteratorData >>::type	unweight (hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &policy, IteratorData data_begin, IteratorData data_end, IteratorWeight weights_begin, double max_pdf, size_t rng_seed, size_t rng_jump)
	This functions reorder a dataset to produce a unweighted sample according to the weights [wbegin, wend]. More...
template<typename RNG , typename IteratorData , typename IteratorWeight , hydra::detail::Backend BACKEND>
std::enable_if< detail::random::is_iterator< IteratorData >::value &&detail::random::is_iterator< IteratorWeight >::value, Range< IteratorData >>::type	unweight (detail::BackendPolicy< BACKEND > const &policy, IteratorData data_begin, IteratorData data_end, IteratorWeight weights_begin, double max_pdf, size_t rng_seed, size_t rng_jump)
	This functions reorder a dataset to produce a unweighted sample according to the weights [wbegin, wend]. More...
template<typename RNG , typename IteratorData , typename IteratorWeight >
std::enable_if< detail::random::is_iterator< IteratorData >::value &&detail::random::is_iterator< IteratorWeight >::value, Range< IteratorData > >::type	unweight (IteratorData data_begin, IteratorData data_end, IteratorWeight weights_begin, double max_pdf, size_t rng_seed, size_t rng_jump)
template<typename RNG , typename IterableData , typename IterableWeight , hydra::detail::Backend BACKEND>
std::enable_if< detail::random::is_iterable< IterableData >::value &&detail::random::is_iterable< IterableWeight >::value, Range< decltype(std::declval< IterableData >).begin())> >::type	unweight (hydra::detail::BackendPolicy< BACKEND > const &policy, IterableData &&data, IterableWeight &&weights, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce a unweighted sample according to a weights. More...
template<typename RNG , typename IterableData , typename IterableWeight >
std::enable_if< detail::random::is_iterable< IterableData >::value &&detail::random::is_iterable< IterableWeight >::value, Range< decltype(std::declval< IterableData >).begin())> >::type	unweight (IterableData &&data, IterableWeight &&weights, double max_pdf, size_t rng_seed, size_t rng_jump)
template<typename RNG = default_random_engine, typename DerivedPolicy , typename IteratorData , typename IteratorWeight >
std::enable_if< detail::random::is_iterator< IteratorData >::value &&detail::random::is_iterator< IteratorWeight >::value, Range< IteratorData > >::type	unweight (hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &policy, IteratorData data_begin, IteratorData data_end, IteratorWeight weights_begin, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce a unweighted sample according to the weights [wbegin, wend]. More...
template<typename RNG , typename Functor , typename Iterator , typename DerivedPolicy >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator >>::type	unweight (hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &policy, Iterator begin, Iterator end, Functor const &functor, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce an unweighted sample according to. More...
template<typename RNG = default_random_engine, typename IteratorData , typename IteratorWeight , hydra::detail::Backend BACKEND>
std::enable_if< detail::random::is_iterator< IteratorData >::value &&detail::random::is_iterator< IteratorWeight >::value, Range< IteratorData > >::type	unweight (detail::BackendPolicy< BACKEND > const &policy, IteratorData data_begin, IteratorData data_end, IteratorWeight weights_begin, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce a unweighted sample according to the weights [wbegin, wend]. More...
template<typename RNG , typename Functor , typename Iterator , hydra::detail::Backend BACKEND>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator >>::type	unweight (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterator begin, Iterator end, Functor const &functor, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce an unweighted sample according to. More...
template<typename RNG = default_random_engine, typename IteratorData , typename IteratorWeight >
std::enable_if< detail::random::is_iterator< IteratorData >::value &&detail::random::is_iterator< IteratorWeight >::value, Range< IteratorData >>::type	unweight (IteratorData data_begin, IteratorData data_end, IteratorData weights_begin, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce a unweighted sample according to the weights [wbegin, wend]. More...
template<typename RNG , typename Functor , typename Iterator >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator >>::type	unweight (Iterator begin, Iterator end, Functor const &functor, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce an unweighted sample according to. More...
template<typename RNG , typename Functor , typename Iterable , hydra::detail::Backend BACKEND>
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable >).begin())>>::type	unweight (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterable &&iterable, Functor const &functor, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce an unweighted sample according to. More...
template<typename RNG , typename Functor , typename Iterable >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value, Range< decltype(std::declval< Iterable >).begin())>>::type	unweight (Iterable &&iterable, Functor const &functor, double max_pdf, size_t rng_seed, size_t rng_jump)
	This functions reorder a dataset to produce an unweighted sample according to. More...
template<typename RNG = default_random_engine, typename IterableData , typename IterableWeight >
std::enable_if< detail::random::is_iterable< IterableData >::value &&detail::random::is_iterable< IterableWeight >::value, Range< decltype(std::declval< IterableData >).begin())>>::type	unweight (IterableData data, IterableWeight weights, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce an unweighted sample according to a weights. More...
template<typename RNG = default_random_engine, typename Functor , typename Iterable >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value,Range< decltype(std::declval< Iterable >).begin())> >::type	unweight (Iterable &&iterable, Functor const &functor, double max_pdf=-1.0, size_t rng_seed=0x8ec74d321e6b5a27, size_t rng_jump=0)
	This functions reorder a dataset to produce an unweighted sample according to. More...
template<typename T >
__hydra_host__ __hydra_device__ T	wigner_d_matrix (double j, double m, double n, const T theta)
__hydra_host__ __hydra_device__ double	wigner_d_matrix (unsigned j, unsigned m, unsigned n, const double theta)
template<typename LambdaType >
hydra::Lambda< LambdaType, 0 >	wrap_lambda (LambdaType const &lambda)
template<typename LambdaType , typename ... T>
std::enable_if< detail::all_true< std::is_same< T, hydra::Parameter >::value... >::value, hydra::Lambda< LambdaType, sizeof...(T)> >::type	wrap_lambda (LambdaType const &lambda, T const &...parameters)
template<typename ... Iterables>
std::enable_if< detail::all_true< detail::is_iterable< Iterables >::value... >::value, Range< hydra::thrust::zip_iterator< decltype(hydra::thrust::make_tuple(std::declval< Iterables & >).begin()...))> > >::type	zip (Iterables &&... iterables)

Variables
template<typename Engine = hydra::default_random_engine, hydra::detail::Backend BACKEND, typename Iterator , typename FUNCTOR >
std::enable_if< hydra::detail::has_rng_formula< FUNCTOR >::value &&std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename hydra::thrust::iterator_traits< Iterator >::value_type >::value, void >::type	fill_random (hydra::detail::BackendPolicy< BACKEND > const &policy, Iterator begin, Iterator end, FUNCTOR const &functor, size_t seed=0x254a0afcf7da74a2, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution using a RNG analytical formula. More...
decltype(other.begin(placeholders::placeholder< I >{})) typedef	iterator_type
const GBool_t	kFalse = false
const GBool_t	kTrue = true
template<typename ... Pdfs, typename Histogram >
std::enable_if< detail::is_hydra_dense_histogram< Histogram >::value||detail::is_hydra_sparse_histogram< Histogram >::value, LogLikelihoodFCN< PDFSumExtendable< Pdfs... >, decltype(std::declval< const Histogram & >).GetBinsCenters().begin()), decltype(std::declval< const Histogram & >).GetBinsContents().begin()) > >::type	make_loglikehood_fcn (PDFSumExtendable< Pdfs... > const &pdf, Histogram const &data)
	Convenience function to build up loglikehood fcns for densely and sparsely binned datasets. More...
int	PrintLevel = WARNING
template<typename RNG = default_random_engine, typename Functor , typename Iterator >
std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value &&detail::is_tuple_type< decltype(*std::declval< Iterator >))>::value, Range< Iterator > >::type	sample (Iterator begin, Iterator end, typename Functor::argument_type const &min, typename Functor::argument_type const &max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)
	Fill a range with numbers distributed according a user defined distribution. More...

Detailed Description

Generic policies definition.

namespace thrust

thrust is the top-level namespace which contains all Hydra functions and types.

Todo:

: fix compile error in nvcc adding variants to vectors

---

Data Structure Documentation

hydra::BaseCompositeFunctor

class hydra::BaseCompositeFunctor

template<typename Composite, typename FunctorList, typename Signature>
class hydra::BaseCompositeFunctor< Composite, FunctorList, Signature >

Inheritance diagram for hydra::BaseCompositeFunctor< Composite, FunctorList, Signature >:

Collaboration diagram for hydra::BaseCompositeFunctor< Composite, FunctorList, Signature >:

hydra::ConvolutionFunctor

class hydra::ConvolutionFunctor

template<typename Functor, typename Kernel, typename Backend, typename FFT, typename ArgType>
class hydra::ConvolutionFunctor< Functor, Kernel, Backend, FFT, ArgType >

Collaboration diagram for hydra::ConvolutionFunctor< Functor, Kernel, Backend, FFT, ArgType >:

hydra::Distribution

class hydra::Distribution

template<typename Functor, bool Implemented = detail::has_rng_formula<Functor>::value>
class hydra::Distribution< Functor, Implemented >

Examples:

basic_distributions.inl.

Collaboration diagram for hydra::Distribution< Functor, Implemented >:

hydra::Distribution< Class, false >

struct hydra::Distribution< Class, false >

template<typename Class>
struct hydra::Distribution< Class, false >

Collaboration diagram for hydra::Distribution< Class, false >:

hydra::GaussKronrodAdaptiveQuadrature

class hydra::GaussKronrodAdaptiveQuadrature

template<size_t NRULE, size_t NBIN, typename BACKEND>
class hydra::GaussKronrodAdaptiveQuadrature< NRULE, NBIN, BACKEND >

Examples:

adaptive_gauss_kronrod.inl.

Collaboration diagram for hydra::GaussKronrodAdaptiveQuadrature< NRULE, NBIN, BACKEND >:

hydra::GaussKronrodQuadrature

class hydra::GaussKronrodQuadrature

template<size_t NRULE, size_t NBIN, typename BACKEND>
class hydra::GaussKronrodQuadrature< NRULE, NBIN, BACKEND >

Examples:

convolute_functions.inl, fit_convoluted_pdfs.inl, and gauss_kronrod.inl.

Collaboration diagram for hydra::GaussKronrodQuadrature< NRULE, NBIN, BACKEND >:

hydra::GaussKronrodRuleSelector

struct hydra::GaussKronrodRuleSelector

template<size_t N>
struct hydra::GaussKronrodRuleSelector< N >

Collaboration diagram for hydra::GaussKronrodRuleSelector< N >:

hydra::GenzMalikQuadrature

class hydra::GenzMalikQuadrature

template<size_t N, typename BACKEND>
class hydra::GenzMalikQuadrature< N, BACKEND >

Collaboration diagram for hydra::GenzMalikQuadrature< N, BACKEND >:

hydra::GenzMalikRule

class hydra::GenzMalikRule

template<size_t DIM, typename BACKEND>
class hydra::GenzMalikRule< DIM, BACKEND >

Inheritance diagram for hydra::GenzMalikRule< DIM, BACKEND >:

Collaboration diagram for hydra::GenzMalikRule< DIM, BACKEND >:

hydra::LogLikelihoodFCN

class hydra::LogLikelihoodFCN

template<typename PDF, typename Iterator, typename... Extensions>
class hydra::LogLikelihoodFCN< PDF, Iterator, Extensions >

Collaboration diagram for hydra::LogLikelihoodFCN< PDF, Iterator, Extensions >:

hydra::multiarray

class hydra::multiarray

template<typename T, size_t N, typename BACKEND>
class hydra::multiarray< T, N, BACKEND >

Examples:

multiarray_container.inl, pseudo_experiment.inl, sample_distribution.inl, and splot.inl.

Inheritance diagram for hydra::multiarray< T, N, BACKEND >:

Collaboration diagram for hydra::multiarray< T, N, BACKEND >:

hydra::multivector

class hydra::multivector

template<typename T, typename BACKEND>
class hydra::multivector< T, BACKEND >

Examples:

dense_histogram.inl, multidimensional_fit.inl, multivector_container.inl, phsp_chain.inl, pseudo_experiment.inl, range_semantics.inl, and splot.inl.

Inheritance diagram for hydra::multivector< T, BACKEND >:

Collaboration diagram for hydra::multivector< T, BACKEND >:

hydra::null_type

struct hydra::null_type

Collaboration diagram for hydra::null_type:

hydra::Plain

struct hydra::Plain

template<size_t N, typename BACKEND, typename GRND = hydra::default_random_engine>
struct hydra::Plain< N, BACKEND, GRND >

Examples:

multidimensional_fit.inl, and plain_mc.inl.

Collaboration diagram for hydra::Plain< N, BACKEND, GRND >:

hydra::Range

class hydra::Range

template<typename ... T>
class hydra::Range< T >

Collaboration diagram for hydra::Range< T >:

hydra::ScopedBuffer

class hydra::ScopedBuffer

template<typename T, typename BACKEND>
class hydra::ScopedBuffer< T, BACKEND >

Collaboration diagram for hydra::ScopedBuffer< T, BACKEND >:

hydra::Vegas

class hydra::Vegas

template<size_t N, typename BACKEND, typename GRND = hydra::default_random_engine>
class hydra::Vegas< N, BACKEND, GRND >

Examples:

vegas.inl.

Collaboration diagram for hydra::Vegas< N, BACKEND, GRND >:

Typedef Documentation

ars

hydra::ars

Ars uses the crypotgraphic AES round function, but a non-cryptographc key schedule to save time and space.

complex

template<typename T >

using hydra::complex = typedef hydra::thrust::complex<T>

default_random_engine

hydra::default_random_engine

An implementation-defined "default" random number engine.

Note

default_random_engine is currently an alias for hydra::random::squares3, and may change in a future version.

Examples:

basic_distributions.inl, and fill_basic_distributions.inl.

default_sobol_table

typedef detail::SobolTable hydra::default_sobol_table

GBool_t

typedef bool hydra::GBool_t

Boolean (0=false, 1=true) (bool)

GByte_t

typedef unsigned char hydra::GByte_t

Byte (8 bits) (unsigned char)

GChar_t

typedef char hydra::GChar_t

Signed Character 1 byte (char)

GDouble_t

typedef double hydra::GDouble_t

Double 8 bytes.

GFloat_t

typedef float hydra::GFloat_t

Float 4 bytes (float)

GInt_t

typedef int hydra::GInt_t

Signed integer 4 bytes (int)

GLong64_t

typedef long long hydra::GLong64_t

Portable signed long integer 8 bytes.

GLong_t

typedef long hydra::GLong_t

Signed long integer 4 bytes (long)

GLongDouble_t

typedef long double hydra::GLongDouble_t

Long Double.

GReal_t

typedef double hydra::GReal_t

Double 16 bytes or float 4 bytes.

GShort_t

typedef short hydra::GShort_t

Signed Short integer 2 bytes (short)

GText_t

typedef char hydra::GText_t

General string (char)

GUChar_t

typedef unsigned char hydra::GUChar_t

Unsigned Character 1 byte (unsigned char)

GUInt_t

typedef unsigned int hydra::GUInt_t

Unsigned integer 4 bytes (unsigned int)

GULong64_t

typedef unsigned long long hydra::GULong64_t

Portable unsigned long integer 8 bytes.

GULong_t

typedef unsigned long hydra::GULong_t

GUShort_t

typedef unsigned short hydra::GUShort_t

Unsigned Short integer 2 bytes (unsigned short)

mc_device_vector

template<typename T >

using hydra::mc_device_vector = typedef hydra::thrust::device_vector<T>

Generic template typedef for hydra::thrust::host_vector.

Use it instead of Thrust implementation in order to avoid problems to compile OpenMP based applications using gcc and without a cuda runtime installation.

mc_host_vector

template<typename T >

using hydra::mc_host_vector = typedef hydra::thrust::host_vector<T, hydra::thrust::system::cuda::experimental::pinned_allocator<T> >

Generic template typedef for hydra::thrust::host_vector.

Use it instead of Thrust implementation in order to avoid problems to compile OpenMP based applications using gcc and without a cuda runtime installation. mc_host_vectot will always allocate page locked memory on CUDA backends in order to maximize speed in memory transfers to the device.

minstd_rand

hydra::minstd_rand

A random number engine with predefined parameters which implements a version of the Minimal Standard random number generation algorithm.

Note

The 10000th consecutive invocation of a default-constructed object of type minstd_rand shall produce the value 399268537 .

minstd_rand0

hydra::minstd_rand0

A random number engine with predefined parameters which implements a version of the Minimal Standard random number generation algorithm.

Note

The 10000th consecutive invocation of a default-constructed object of type minstd_rand0 shall produce the value 1043618065 .

pair

template<typename T1 , typename T2 >

using hydra::pair = typedef hydra::thrust::pair<T1,T2>

pair template is an alias to the hydra::thrust::pair structure.

Template Parameters

T1	The type of pair's first object type. There are no requirements on the type of T1. T1's type is provided by pair::first_type.
T2	The type of pair's second object type. There are no requirements on the type of T2. T2's type is provided by pair::second_type.

philox

hydra::philox

The Philox family of counter-based RNGs use integer multiplication, xor and permutation of W-bit words to scramble its N-word input key.

Philox is a mnemonic for Product HI LO Xor). This generator has a period of 2^128

Philox is a mnemonic for Product HI LO Xor). This generator has a period of 2^256

philox_long

typedef hydra::random::philox_long hydra::philox_long

ranlux24

hydra::ranlux24

A random number engine with predefined parameters which implements the RANLUX level-3 random number generation algorithm.

Note

The 10000th consecutive invocation of a default-constructed object of type ranlux24 shall produce the value 9901578 .

Examples:

pseudo_experiment.inl.

ranlux48

hydra::ranlux48

A random number engine with predefined parameters which implements the RANLUX level-4 random number generation algorithm.

Note

The 10000th consecutive invocation of a default-constructed object of type ranlux48 shall produce the value 88229545517833 .

sobol

template<unsigned D>

using hydra::sobol = typedef sobol_engine<uint_least64_t, D, 64u, default_sobol_table>

Attention

This specialization of supports up to 3667 dimensions.

Data on the primitive binary polynomials a and the corresponding starting values m for Sobol sequences in up to 21201 dimensions was taken from

S. Joe and F. Y. Kuo, Constructing Sobol sequences with better two-dimensional projections, SIAM J. Sci. Comput. 30, 2635-2654 (2008).

See the original tables up to dimension 21201: https://web.archive.org/web/20170802022909/http://web.maths.unsw.edu.au/~fkuo/sobol/new-joe-kuo-6.21201

For practical reasons the default table uses only the subset of binary polynomials a < 2¹⁶.

However, it is possible to provide your own table to should the default one be insufficient.

squares3

hydra::squares3

Ars uses the crypotgraphic AES round function, but a non-cryptographc key schedule to save time and space.

squares4

hydra::squares4

Ars uses the crypotgraphic AES round function, but a non-cryptographc key schedule to save time and space.

taus88

hydra::taus88

A random number engine with predefined parameters which implements L'Ecuyer's 1996 three-component Tausworthe random number generator.

Note

The 10000th consecutive invocation of a default-constructed object of type taus88 shall produce the value 3535848941 .

threefry

hydra::threefry

Threefry uses integer addition, bitwise rotation, xor and permutation of words to randomize its output.

This generator has a period of 2^128

threefry_long

hydra::threefry_long

Threefry uses integer addition, bitwise rotation, xor and permutation of words to randomize its output.

This generator has a period of 2^256

tuple

template<typename... T>

using hydra::tuple = typedef hydra::thrust::tuple<T...>

tuple template is an alias to the variadic version of hydra::thrust::tuple and that can be instantiated with a indefinite number of arguments.

Each template argument specifies the type of element in the tuple. Consequently, tuples are heterogeneous, fixed-size collections of values. An instantiation of tuple with two arguments is similar to an instantiation of pair with the same two arguments. Individual elements of a tuple may be accessed with the get function.

Template Parameters

TN	The type of the N tuple element.

The following code snippet demonstrates how to create a new tuple object and inspect and modify the value of its elements.

#include <hydra/tuple.h>
#include <iostream>
...
// create a tuple containing an int, a float, and a string
hydra::tuple<int, float, const char*> t(13, 0.1f, "hydra");

// individual members are accessed with the free function get
std::cout << "The first element's value is " << hydra::get<0>(t) << std::endl;

// or the member function get
std::cout << "The second element's value is " << t.get<1>() << std::endl;

// we can also modify elements with the same function
hydra::get<0>(t) += 10;

tuple_element

template<int N, class T >

using hydra::tuple_element = typedef hydra::thrust::tuple_element<N,T>

The get function returns a const reference to a tuple element of interest.

Parameters

t	A reference to a tuple of interest.

Returns

A const reference to t's Nth element.

Template Parameters

N	The index of the element of interest.

The following code snippet demonstrates how to use get to print the value of a tuple element.

#include <hydra/Tuple.h>
#include <iostream>
...
hydra::tuple<int, const char *> t(13, "hydra");

std::cout << "The 1st value of t is " << hydra::get<0>(t) << std::endl;

This metafunction returns the type of a tuple's Nth element.

Template Parameters

N	This parameter selects the element of interest.
T	A tuple type of interest.

tuple_size

template<class T >

using hydra::tuple_size = typedef hydra::thrust::tuple_size<T>

This metafunction returns the number of elements of a tuple type of interest.

Template Parameters

T	A tuple type of interest.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MODE_IMPORTANCE
MODE_IMPORTANCE_ONLY
MODE_STRATIFIED
BINS_MAX

anonymous enum

anonymous enum

Enumerator
INFO
WARNING
ERROR

Function Documentation

abs()

template<typename T >

__hydra_host__ __hydra_device__ T hydra::abs

(

const complex< T > &

z

)

acos()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::acos

(

const complex< T > &

z

)

acosh()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::acosh

(

const complex< T > &

z

)

arg()

template<typename T >

__hydra_host__ __hydra_device__ T hydra::arg

(

const complex< T > &

z

)

asin()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::asin

(

const complex< T > &

z

)

asinh()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::asinh

(

const complex< T > &

z

)

atan()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::atan

(

const complex< T > &

z

)

atanh()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::atanh

(

const complex< T > &

z

)

BarrierFactor< hydra::DWave >()

template<>

__hydra_host__ __hydra_device__ double hydra::BarrierFactor< hydra::DWave > ( const double  radi, const double  p0, const double  p  )

inline

BarrierFactor< hydra::FWave >()

template<>

__hydra_host__ __hydra_device__ double hydra::BarrierFactor< hydra::FWave > ( const double  radi, const double  p0, const double  p  )

inline

BarrierFactor< hydra::GWave >()

template<>

__hydra_host__ __hydra_device__ double hydra::BarrierFactor< hydra::GWave > ( const double  radi, const double  p0, const double  p  )

inline

BarrierFactor< hydra::HWave >()

template<>

__hydra_host__ __hydra_device__ double hydra::BarrierFactor< hydra::HWave > ( const double  radi, const double  p0, const double  p  )

inline

BarrierFactor< hydra::PWave >()

template<>

__hydra_host__ __hydra_device__ double hydra::BarrierFactor< hydra::PWave > ( const double  radi, const double  p0, const double  p  )

inline

BarrierFactor< hydra::SWave >()

template<>

__hydra_host__ __hydra_device__ double hydra::BarrierFactor< hydra::SWave > ( const double  , const double  , const double    )

inline

begin() [1/7]

template<class C >

auto hydra::begin

(

const C &

c

)

-> decltype(c.begin())

Examples:

multiarray_container.inl.

begin() [2/7]

template<class C >

auto hydra::begin

(

C &&

c

)

-> decltype(std::forward< C >(c).begin())

begin() [3/7]

template<class T , size_t N>

T * hydra::begin

(

T(&)

array[N]

)

begin() [4/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::begin ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> const &  other  ) -> decltype(other.begin(placeholders::placeholder<I>

inline

begin() [5/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::begin ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> &  other  ) -> decltype(other.begin(placeholders::placeholder<I>

inline

begin() [6/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::begin ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &  other ) -> decltype(other.begin(placeholders::placeholder<I>

inline

begin() [7/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::begin ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &  other ) -> decltype(other.begin(placeholders::placeholder<I>

inline

bessel_i()

__hydra_host__ __hydra_device__ double hydra::bessel_i ( const int  n, const double  x  )

inline

Modified Bessel function of first kind and order n.

bessel_i0()

__hydra_host__ __hydra_device__ double hydra::bessel_i0 ( const double  x )

inline

Modified Bessel function of first kind and order 0.

bessel_i1()

__hydra_host__ __hydra_device__ double hydra::bessel_i1 ( const double  x )

inline

Modified Bessel function of first kind and order 1.

bessel_j()

__hydra_host__ __hydra_device__ double hydra::bessel_j ( const int  n, const double  x  )

inline

Bessel function of first kind and order n.

bessel_j0()

__hydra_host__ __hydra_device__ double hydra::bessel_j0 ( const double  x )

inline

Bessel function of first kind and order 0.

bessel_j1()

__hydra_host__ __hydra_device__ double hydra::bessel_j1 ( const double  x )

inline

Bessel function of first kind and order 1.

bessel_k()

__hydra_host__ __hydra_device__ double hydra::bessel_k ( const int  n, const double  x  )

inline

Modified Bessel function of second kind and order n.

bessel_k0()

__hydra_host__ __hydra_device__ double hydra::bessel_k0 ( const double  x )

inline

Modified Bessel function of second kind and order 0.

bessel_k1()

__hydra_host__ __hydra_device__ double hydra::bessel_k1 ( const double  x )

inline

Modified Bessel function of second kind and order 1.

bessel_y()

__hydra_host__ __hydra_device__ double hydra::bessel_y ( const int  n, const double  x  )

inline

Bessel function of second kind and order n.

bessel_y0()

__hydra_host__ __hydra_device__ double hydra::bessel_y0 ( const double  x )

inline

Bessel function of second kind and order 0.

bessel_y1()

__hydra_host__ __hydra_device__ double hydra::bessel_y1 ( const double  x )

inline

Bessel function of second kind and order 1.

boost_strapped_range()

template<typename Iterable >

std::enable_if<hydra::detail::is_iterable<Iterable>::value, Range< hydra::thrust::permutation_iterator<decltype(std::declval<Iterable&>).begin()), hydra::thrust::transform_iterator< detail::RndUniform<size_t, hydra::thrust::random::default_random_engine> ,hydra::thrust::counting_iterator<size_t>,size_t > > > >::type hydra::boost_strapped_range	(	Iterable &&	iterable,
		size_t	seed
	)

Examples:

booststrapping.inl, and pseudo_experiment.inl.

boostTo() [1/2]

__hydra_host__ __hydra_device__ Vector4R hydra::boostTo ( const Vector4R &  rs, const Vector4R &  p4, bool  inverse = false  )

inline

boostTo() [2/2]

__hydra_host__ __hydra_device__ Vector4R hydra::boostTo ( const Vector4R &  rs, const Vector3R &  boost, bool  inverse = false  )

inline

chebychev_1st_kind()

__hydra_host__ __hydra_device__ double hydra::chebychev_1st_kind ( unsigned  n, const double  x  )

inline

Implementation of Chebychev polynomials of first kind \( P_n(n) \) using the recursive relation.

\[P_{n+1}(x) = 2xP_n(x)-P_{n-1}(x) \]

Parameters

n	order of the polynomial
x	argument

Returns

chebychev_2nd_kind()

__hydra_host__ __hydra_device__ double hydra::chebychev_2nd_kind ( unsigned  n, const double  x  )

inline

Implementation of Chebychev polynomials of second kind \( P_n(n) \) using the recursive relation.

\[ P_{n+1}(x) = 2xP_n(x) - P_{n-1}(x) \]

Parameters

n	order of the polynomial
x	argument

Returns

collect()

template<typename Iterable_Index , typename Iterable_Values >

auto hydra::collect	(	Iterable_Index &	indexing_scheme,
		Iterable_Values &	collected_values
	)		-> typename std::enable_if<hydra::detail::is_iterable<Iterable_Index>::value && hydra::detail::is_iterable<Iterable_Values>::value, Range<hydra::thrust::permutation_iterator< decltype(std::declval<Iterable_Values&>().begin()), decltype(std::declval<Iterable_Index&>().begin())> >::type

columns() [1/5]

template<hydra::detail::Backend BACKEND, typename T , size_t N, unsigned int... I>

auto hydra::columns	(	multiarray< T, N, detail::BackendPolicy< BACKEND >>const &	other,
		placeholders::placeholder< I >...	cls
	)		-> Range<decltype(std::declval< multiarray<T,N, detail::BackendPolicy<BACKEND>>const&>().begin(placeholders::placeholder<I>

Examples:

pseudo_experiment.inl, and range_semantics.inl.

columns() [2/5]

template<hydra::detail::Backend BACKEND, typename T , size_t N, unsigned int... I>

auto hydra::columns	(	multiarray< T, N, detail::BackendPolicy< BACKEND >> &	other,
		placeholders::placeholder< I >...	cls
	)		-> Range<decltype(std::declval<multiarray<T,N, detail::BackendPolicy<BACKEND>>&&>().begin(placeholders::placeholder<I>

columns() [3/5]

template<hydra::detail::Backend BACKEND, typename ... T, unsigned int... I>

auto hydra::columns	(	multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >>const &	other,
		placeholders::placeholder< I >...	cls
	)		-> Range<decltype(std::declval<multivector<hydra::thrust::tuple<T...>, hydra::detail::BackendPolicy<BACKEND>> const&>().begin(placeholders::placeholder<I>

columns() [4/5]

template<hydra::detail::Backend BACKEND, typename ... T, unsigned int... I>

auto hydra::columns	(	multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >> &	other,
		placeholders::placeholder< I >...	cls
	)		-> Range<decltype(std::declval<multivector<hydra::thrust::tuple<T...>, hydra::detail::BackendPolicy<BACKEND>>&>().begin(placeholders::placeholder<I>

columns() [5/5]

template<typename Type , hydra::detail::Backend BACKEND, typename ... T>

auto hydra::columns

(

multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND >> &

other

)

-> Range<decltype( std::declval<multivector<hydra::thrust::tuple<T...>, hydra::detail::BackendPolicy<BACKEND>>&>().begin( placeholders::placeholder<detail::index_in_tuple<Type, hydra::thrust::tuple<T...> >::value>

compose()

template<typename T0 , typename T1 , typename ... Ts>

std::enable_if<(detail::is_hydra_functor<T0>::value || detail::is_hydra_lambda<T0>::value ) &&(detail::is_hydra_functor<T1>::value || detail::is_hydra_lambda<T1>::value ) &&detail::all_true<(detail::is_hydra_functor<Ts>::value || detail::is_hydra_lambda<Ts>::value )...>::value,Compose<T0,T1,Ts...> >::type hydra::compose ( T0 const &  F0, T1 const &  F1, Ts const &...  Fs  )

inline

Examples:

dalitz_plot.C, and dalitz_plot.inl.

conj()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::conj

(

const complex< T > &

z

)

constant_range()

template<typename Value_Type >

Range<hydra::thrust::constant_iterator<Value_Type> > hydra::constant_range

(

const Value_Type &

value

)

convolute()

template<detail::Backend BACKEND, detail::FFTCalculator FFTBackend, typename Functor , typename Kernel , typename Iterable , typename T = typename detail::stripped_type<typename hydra::thrust::iterator_traits<decltype(std::declval<Iterable>().begin())>::value_type>::type, typename USING_CUDA_BACKEND = typename std::conditional< std::is_convertible<detail::BackendPolicy<BACKEND>,hydra::thrust::system::cuda::tag >::value, std::integral_constant<int, 1>,std::integral_constant<int, 0>>::type, typename USING_CUFFT = typename std::conditional< FFTBackend==detail::CuFFT, std::integral_constant<int, 1>,std::integral_constant<int, 0>>::type, typename GPU_DATA = typename std::conditional< std::is_convertible<typename hydra::thrust::iterator_system< decltype(std::declval<Iterable>().begin())>::type, hydra::thrust::system::cuda::tag>::value , std::integral_constant<int, 1>, std::integral_constant<int, 0> >::type>

std::enable_if<std::is_floating_point<T>::value && hydra::detail::is_iterable<Iterable>::value ,void>::type hydra::convolute ( detail::BackendPolicy< BACKEND >  policy, detail::FFTPolicy< T, FFTBackend >  fft_policy, Functor const &  functor, Kernel const &  kernel, T  min, T  max, Iterable &&  output, bool  power_up = true  )

inline

Examples:

convolute_functions.inl.

copy() [1/3]

template<typename Iterable_Source , typename Iterable_Target >

std::enable_if<hydra::detail::is_iterable<Iterable_Source>::value&& hydra::detail::is_iterable<Iterable_Target>::value,Range<decltype(std::declval<Iterable_Target&>).begin())> >::type hydra::copy	(	Iterable_Source &&	source,
		Iterable_Target &&	destination
	)

Examples:

basic_fit.inl, fill_basic_distributions.inl, fit_gaussian.C, fit_johnson.C, phsp_chain.inl, simultaneous_fit.inl, and splot.inl.

copy() [2/3]

template<typename InputIterator , typename OutputIterator >

OutputIterator hydra::copy	(	InputIterator	first,
		InputIterator	last,
		OutputIterator	result
	)

copy() [3/3]

template<detail::Backend Backend, typename InputIterator , typename OutputIterator >

OutputIterator hydra::copy	(	hydra::detail::BackendPolicy< Backend > const &	policy,
		InputIterator	first,
		InputIterator	last,
		OutputIterator	result
	)

cos()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::cos

(

const complex< T > &

z

)

Examples:

dalitz_plot.C, and dalitz_plot.inl.

cosh()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::cosh

(

const complex< T > &

z

)

cross()

__hydra_host__ __hydra_device__ Vector3R hydra::cross ( const Vector3R &  p1, const Vector3R &  p2  )

inline

distance()

template<typename Iterator >

__hydra_host__ __hydra_device__ auto hydra::distance ( Iterator  first, Iterator  last  ) -> decltype( hydra::thrust::distance<Iterator>(first,last))

inline

divide()

template<typename F1 , typename F2 , typename ... Fs>

std::enable_if<(detail::is_hydra_functor<F1>::value || detail::is_hydra_lambda<F1>::value ) &&(detail::is_hydra_functor<F2>::value || detail::is_hydra_lambda<F2>::value ),Divide<F1, F2> >::type hydra::divide ( F1 const &  f1, F2 const &  f2  )

inline

end() [1/7]

template<class C >

auto hydra::end

(

const C &

c

)

-> decltype(c.end())

Examples:

multiarray_container.inl, phsp_averaging_functor.inl, phsp_basic.inl, phsp_chain.inl, phsp_reweighting.inl, phsp_unweighting.inl, phsp_unweighting_functor.inl, plain_mc.inl, and pseudo_experiment.inl.

end() [2/7]

template<class C >

auto hydra::end

(

C &&

c

)

-> decltype(std::forward< C >(c).end())

end() [3/7]

template<class T , size_t N>

T * hydra::end

(

T(&)

array[N]

)

end() [4/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::end ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> const &  other  ) -> decltype(other.end(placeholders::placeholder<I>

inline

end() [5/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::end ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> &  other  ) -> decltype(other.end(placeholders::placeholder<I>

inline

end() [6/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::end ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &  other ) -> decltype(other.end(placeholders::placeholder<I>

inline

end() [7/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::end ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &  other ) -> decltype(other.end(placeholders::placeholder<I>

inline

erfinv()

__hydra_host__ __hydra_device__ long double hydra::erfinv ( double  x )

inline

exp()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::exp

(

const complex< T > &

z

)

Examples:

basic_distributions.inl, dense_histogram.inl, fill_basic_distributions.inl, and plain_mc.inl.

fill_random() [1/5]

template<typename Engine , hydra::detail::Backend BACKEND, typename Iterator , typename FUNCTOR >

std::enable_if< hydra::detail::has_rng_formula<FUNCTOR>::value && std::is_convertible< decltype(std::declval<RngFormula<FUNCTOR> >).Generate( std::declval<Engine&>), std::declval<FUNCTOR const&>))), typename hydra::thrust::iterator_traits<Iterator>::value_type >::value, void>::type hydra::fill_random	(	hydra::detail::BackendPolicy< BACKEND > const &	policy,
		Iterator	begin,
		Iterator	end,
		FUNCTOR const &	functor,
		size_t	seed,
		size_t	rng_jump
	)

Fill a range with numbers distributed according a user defined distribution using a RNG analytical formula.

Parameters

policy	backend to perform the calculation.
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
functor	distribution to be sampled

fill_random() [2/5]

template<typename Engine , typename Iterator , typename FUNCTOR >

std::enable_if< hydra::detail::has_rng_formula< FUNCTOR >::value &&std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename hydra::thrust::iterator_traits< Iterator >::value_type >::value, void >::type hydra::fill_random	(	Iterator	begin,
		Iterator	end,
		FUNCTOR const &	functor,
		size_t	seed = 0x254a0afcf7da74a2,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution using a RNG analytical formula.

Parameters

begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
functor	distribution to be sampled
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

fill_random() [3/5]

template<typename Engine , hydra::detail::Backend BACKEND, typename Iterator , typename FUNCTOR >

std::enable_if< !std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename std::iterator_traits< Iterator >::value_type >::value &&hydra::detail::has_rng_formula< FUNCTOR >::value, void >::type hydra::fill_random	(	hydra::detail::BackendPolicy< BACKEND > const &	policy,
		Iterator	begin,
		Iterator	end,
		FUNCTOR const &	funct,
		size_t	seed = 0x254a0afcf7da74a2,
		size_t	rng_jump = 0
	)

Fall back function if RngFormula::Generate() return value is not convertible to functor return value.

Parameters

policy	backend to perform the calculation.
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

fill_random() [4/5]

template<typename Engine , typename Iterator , typename FUNCTOR >

std::enable_if< !std::is_convertible< decltype(std::declval< RngFormula< FUNCTOR > >).Generate(std::declval< Engine & >), std::declval< FUNCTOR const & >))), typename std::iterator_traits< Iterator >::value_type >::value &&hydra::detail::has_rng_formula< FUNCTOR >::value, void >::type hydra::fill_random	(	Iterator	begin,
		Iterator	end,
		FUNCTOR const &	functor,
		size_t	seed = 0x254a0afcf7da74a2,
		size_t	rng_jump = 0
	)

Fall back function if RngFormula::Generate() return value is not convertible to functor return value.

Parameters

begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

fill_random() [5/5]

template<typename Engine , hydra::detail::Backend BACKEND, typename Iterable , typename FUNCTOR >

std::enable_if< !(detail::random::is_matching_iterable< Engine, FUNCTOR, Iterable >::value), void >::type hydra::fill_random	(	hydra::detail::BackendPolicy< BACKEND > const &	policy,
		Iterable &&	iterable,
		FUNCTOR const &	functor,
		size_t	seed = 0x254a0afcf7da74a2,
		size_t	rng_jump = 0
	)

Fall back function if the argument is not an Iterable or if it is not convertible to the Functor return value.

Fall back function if the argument is not an Iterable or if itis not convertible to the Functor return value.

Parameters

policy	backend to perform the calculation.
iterable	range storing the generated values
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

filter() [1/2]

template<typename Iterable , typename Functor >

std::enable_if< hydra::detail::is_iterable<Iterable>::value,hydra::Range<decltype(std::declval<Iterable>).begin())> >::type hydra::filter ( Iterable &&  container, Functor &&  filter  )

inline

Examples:

basic_fit_range_semantics.inl, extended_logLL_fit.inl, fit_johnson.C, fractional_logLL_fit.inl, multidimensional_fit.inl, simultaneous_fit.inl, and splot.inl.

filter() [2/2]

template<typename Iterable , typename Functor >

std::enable_if< hydra::detail::is_iterable<Iterable>::value, hydra::Range<decltype(std::declval<Iterable>).begin())> >::type hydra::filter ( Iterable &&  container, Functor const &  filter  )

inline

Apply a filter to the range [first, last] and return a pair of iterators for the filtered events.

This function will not change the size of the original range, [first, last], but will reorder the entries to put together the accepted entries.

Parameters

first	Iterator pointing to the begin of the range to filter.
last	Iterator pointing to the end of the range to filter.
filter	Functor returning bool.

Returns

for_each()

template<typename Iterable , typename Functor >

std::enable_if<hydra::detail::is_iterable<Iterable>::value, Range<decltype(std::declval<Iterable&>).begin())> >::type hydra::for_each	(	Iterable &&	iterable,
		Functor const &	functor
	)

Examples:

booststrapping.inl, cufft.inl, fft.inl, and range_semantics.inl.

forward_as_tuple()

template<class ... T>

__hydra_host__ __hydra_device__ auto hydra::forward_as_tuple ( T &&...  t ) -> decltype(hydra::thrust::forward_as_tuple(std::forward<T>(t)...))

inline

Constructs a tuple of references to the arguments in args suitable for forwarding as an argument to a function.

The tuple has rvalue reference data members when rvalues are used as arguments, and otherwise has lvalue reference data members.

gather()

template<typename Iterable_Source , typename Iterable_Target , typename Iterable_Map >

std::enable_if<hydra::detail::is_iterable<Iterable_Source>::value && hydra::detail::is_iterable<Iterable_Target>::value && hydra::detail::is_iterable<Iterable_Map>::value,Range<decltype(std::declval<Iterable_Target&>).begin())> >::type hydra::gather	(	Iterable_Source &&	source,
		Iterable_Map &&	map,
		Iterable_Target &&	target
	)

get() [1/14]

template<int I, int N, typename T >

__hydra_host__ __hydra_device__ T hydra::get ( T(&)  array[N] )

inline

get() [2/14]

template<int I, typename T >

__hydra_host__ __hydra_device__ T hydra::get ( T *  array )

inline

get() [3/14]

template<typename Type , typename ... T>

__hydra_host__ __hydra_device__ Type& hydra::get ( hydra::thrust::tuple< T... > const &  t )

inline

The get function returns a reference to a tuple element of interest.

Parameters

t	A reference to a tuple of interest.

Returns

A reference to t's Nth element.

Template Parameters

N	The index of the element of interest.

The following code snippet demonstrates how to use get to print the value of a tuple element.

#include <hydra/Tuple.h>
#include <iostream>
...
hydra::tuple<int, const char *> t(13, "hydra");

std::cout << "The 1st value of t is " << hydra::get<0>(t) << std::endl;

get() [4/14]

template<int N, typename ... T>

__hydra_host__ __hydra_device__ const hydra::thrust::tuple_element<N,hydra::thrust::tuple<T...> >::type& hydra::get ( hydra::thrust::tuple< T... > const &  t )

inline

get() [5/14]

template<typename Type , typename ... T>

__hydra_host__ __hydra_device__ Type& hydra::get ( hydra::thrust::tuple< T... > &  t )

inline

get() [6/14]

template<int N, typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<N,hydra::thrust::tuple<T...> >::type& hydra::get ( hydra::thrust::tuple< T... > &  t )

inline

get() [7/14]

template<typename Type , typename ... T>

__hydra_host__ __hydra_device__ Type&& hydra::get ( hydra::thrust::tuple< T... > &&  t )

inline

get() [8/14]

template<int N, typename ... T>

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<N,hydra::thrust::tuple<T...> >::type&& hydra::get ( hydra::thrust::tuple< T... > &&  t )

inline

get() [9/14]

template<int N, typename T1 , typename T2 >

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<N,hydra::thrust::pair<T1,T2> >::type& hydra::get ( hydra::thrust::pair< T1, T2 > &  t )

inline

get() [10/14]

template<int N, typename T1 , typename T2 >

__hydra_host__ __hydra_device__ const hydra::thrust::tuple_element<N,hydra::thrust::pair<T1,T2> >::type& hydra::get ( hydra::thrust::pair< T1, T2 > const &  t )

inline

get() [11/14]

template<int N, typename T1 , typename T2 >

__hydra_host__ __hydra_device__ hydra::thrust::tuple_element<N,hydra::thrust::pair<T1,T2> >::type&& hydra::get ( hydra::thrust::pair< T1, T2 > &&  t )

inline

get() [12/14]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::get ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> const &  other  ) -> decltype(other.column(placeholders::placeholder<I>

inline

Return the column _I of the hydra::multiarray.

Parameters

other

Returns

get() [13/14]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::get ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> &  other  ) -> decltype(other.column(placeholders::placeholder<I>

inline

Return the column _I of the hydra::multiarray.

Parameters

other

Returns

get() [14/14]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::get ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &  other ) -> decltype(other.column(placeholders::placeholder<I>

inline

get_flat_tuple()

template<typename ... T>

__hydra_host__ __hydra_device__ detail::tuple_utility::flat_tuple<T...>::type hydra::get_flat_tuple

(

T const &...

args

)

GetFormatedString()

template<typename... Args>

std::string hydra::GetFormatedString	(	const char *	format,
		Args...	args
	)

hermite()

__hydra_host__ __hydra_device__ double hydra::hermite ( unsigned  n, const double  x  )

inline

Implementation of Hermite polynomials \( P_n(n) \) using the recursive relation.

\[ P_{n + 1}(x) = 2xP_n(x) - 2nP_{n - 1}(x) \]

Parameters

n	order of the polynomial
x	argument

Returns

jacobi()

__hydra_host__ __hydra_device__ double hydra::jacobi ( double  a, double  b, unsigned  n, const double  x  )

inline

P_{n-1}^{(,)}(z) - 2 (n+ - 1) (n + -1) (2n+ + ) P_{n-2}^{(, )}(z), {align}</math>

for ''n'' = 2, 3, ....

laguerre()

__hydra_host__ __hydra_device__ double hydra::laguerre ( unsigned  n, const double  x  )

inline

Implementation of Laguerre polynomials \( P_n(n) \) using the recursive relation.

\[ P_{n + 1}(x) = \frac{(2n + 1 - x)P_n(x) - n P_{n - 1}(x)}{n + 1} \]

Parameters

n	order of the polynomial
x	argument

Returns

legendre()

__hydra_host__ __hydra_device__ double hydra::legendre ( unsigned  n, const double  x  )

inline

Implementation of Legendre polynomials \( P_n(n) \) using the recursive relation.

\[ (n+1)P_{n+1}(x) = (2n+1)xP_{n}(x) - nP_{n-1}(x) \]

Parameters

n	order of the polynomial
x	argument

Returns

log()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::log

(

const complex< T > &

z

)

log10()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::log10

(

const complex< T > &

z

)

make_convolution()

template<typename ArgType , typename Functor , typename Kernel , detail::Backend BACKEND, detail::FFTCalculator FFT, typename T = typename detail::stripped_type<typename std::common_type<typename Functor::return_type, typename Kernel::return_type>::type>::type>

std::enable_if< std::is_floating_point<T>::value, ConvolutionFunctor<Functor, Kernel, detail::BackendPolicy<BACKEND>, detail::FFTPolicy<T, FFT>, ArgType> >::type hydra::make_convolution ( detail::BackendPolicy< BACKEND > const &  , detail::FFTPolicy< T, FFT > const &  , Functor const &  functor, Kernel const &  kernel, T  kmin, T  kmax, unsigned  nsamples = 1024, bool  interpolate = true, bool  power_up = true  )

inline

make_dense_histogram()

template<typename T , typename Iterator1 , typename Iterator2 , size_t N, hydra::detail::Backend BACKEND>

DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimensional> hydra::make_dense_histogram	(	detail::BackendPolicy< BACKEND >	,
		std::array< size_t, N > const &	grid,
		std::array< double, N > const &	lowerlimits,
		std::array< double, N > const &	upperlimits,
		Iterator1	first,
		Iterator1	end,
		Iterator2	wfirst
	)

make_loglikehood_fcn()

template<typename ... Pdfs, typename Histogram >

std::enable_if<detail::is_hydra_dense_histogram<Histogram>::value || detail::is_hydra_sparse_histogram<Histogram>::value, LogLikelihoodFCN< PDFSumExtendable<Pdfs...>, decltype(std::declval<const Histogram&>).GetBinsCenters().begin()), decltype(std::declval<const Histogram&>).GetBinsContents().begin()) > >::type hydra::make_loglikehood_fcn ( PDFSumExtendable< Pdfs... > const &  functor, Histogram const &  points  )

inline

make_pair()

template<class T1 , class T2 >

__hydra_host__ __hydra_device__ auto hydra::make_pair ( T1 &&  t1, T2 &&  t2  ) -> decltype(hydra::thrust::make_pair( std::forward<T1>(t1), std::forward<T2>(t2) ))

inline

This version of make_pair creates a new pair object from a list of objects.

Parameters

T1	The first object to copy from.
T2	The second object to copy from.

Returns

A pair object with members which are copies of t.

make_range() [1/6]

template<typename Iterator , typename Functor >

hydra::thrust::detail::enable_if< detail::is_hydra_functor<Functor>::value , Range<Iterator, Functor> >::type hydra::make_range	(	Iterator	begin,
		Iterator	end,
		Functor const &	functor
	)

make_range() [2/6]

template<typename Iterator >

Range<Iterator> hydra::make_range	(	Iterator	begin,
		Iterator	end
	)

Examples:

cufft.inl, fft.inl, and pseudo_experiment.inl.

make_range() [3/6]

template<typename Iterable >

std::enable_if<hydra::detail::is_iterable<Iterable>::value,Range<decltype(std::declval<Iterable>).begin())> >::type hydra::make_range

(

Iterable const &

container

)

make_range() [4/6]

template<typename Iterable , typename Functor >

hydra::thrust::detail::enable_if< detail::is_iterable<Iterable>::value && detail::is_hydra_functor<Functor>::value, Range<decltype(std::declval<Iterable>).begin()), Functor> >::type hydra::make_range	(	Iterable const &	iterable,
		Functor const &	functor
	)

make_range() [5/6]

template<typename Iterable >

std::enable_if<hydra::detail::is_iterable<Iterable>::value,Range<decltype(std::declval<Iterable>).begin())> >::type hydra::make_range

(

Iterable &&

container

)

make_range() [6/6]

template<typename Iterable , typename Functor >

hydra::thrust::detail::enable_if< detail::is_iterable<Iterable>::value && detail::is_hydra_functor<Functor>::value, Range<decltype(std::declval<Iterable>).begin()), Functor> >::type hydra::make_range	(	Iterable &&	iterable,
		Functor const &	functor
	)

make_reverse_range() [1/6]

template<typename Iterator , typename Functor >

hydra::thrust::detail::enable_if< detail::is_hydra_functor<Functor>::value , Range<hydra::thrust::reverse_iterator<Iterator>, Functor> >::type hydra::make_reverse_range	(	Iterator	begin,
		Iterator	end,
		Functor const &	functor
	)

make_reverse_range() [2/6]

template<typename Iterator >

Range<hydra::thrust::reverse_iterator<Iterator> > hydra::make_reverse_range	(	Iterator	begin,
		Iterator	end
	)

make_reverse_range() [3/6]

template<typename Iterable >

std::enable_if<hydra::detail::is_reverse_iterable<Iterable>::value,Range<decltype(std::declval<Iterable>).rbegin())> >::type hydra::make_reverse_range

(

Iterable const &

container

)

make_reverse_range() [4/6]

template<typename Iterable >

std::enable_if<hydra::detail::is_reverse_iterable<Iterable>::value,Range<decltype(std::declval<Iterable>).rbegin())> >::type hydra::make_reverse_range

(

Iterable &&

container

)

make_reverse_range() [5/6]

template<typename Iterable , typename Functor >

hydra::thrust::detail::enable_if< detail::is_reverse_iterable<Iterable>::value && detail::is_hydra_functor<Functor>::value , Range<decltype(std::declval<Iterable>).rbegin()), Functor> >::type hydra::make_reverse_range	(	Iterable const &	iterable,
		Functor const &	functor
	)

make_reverse_range() [6/6]

template<typename Iterable , typename Functor >

hydra::thrust::detail::enable_if< detail::is_reverse_iterable<Iterable>::value && detail::is_hydra_functor<Functor>::value , Range<decltype(std::declval<Iterable>).rbegin()), Functor> >::type hydra::make_reverse_range	(	Iterable &&	iterable,
		Functor const &	functor
	)

make_sparse_histogram() [1/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable >

std::enable_if< hydra::detail::is_iterable<Iterable>::value,SparseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimensional> >::type hydra::make_sparse_histogram ( detail::BackendPolicy< BACKEND >  backend, std::array< size_t, N >  grid, std::array< double, N >  lowerlimits, std::array< double, N >  upperlimits, Iterable &&  data  )

inline

make_sparse_histogram() [2/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND, typename Iterable1 , typename Iterable2 >

std::enable_if< hydra::detail::is_iterable<Iterable1>::value&&hydra::detail::is_iterable<Iterable2>::value,SparseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimensional> >::type hydra::make_sparse_histogram ( detail::BackendPolicy< BACKEND >  backend, std::array< size_t, N >  grid, std::array< double, N >  lowerlimits, std::array< double, N >  upperlimits, Iterable1 &&  data, Iterable2 &&  weights  )

inline

make_spline() [1/10]

template<typename ArgType , typename Iterator1 , typename Iterator2 >

SplineFunctor<Iterator1, Iterator2, ArgType> hydra::make_spline ( Iterator1  firstX, Iterator1  lastX, Iterator2  firstY  )

inline

make_spline() [2/10]

template<typename ArgType , typename Iterable1 , typename Iterable2 >

std::enable_if< hydra::detail::is_iterable<Iterable1>::value && hydra::detail::is_iterable<Iterable2>::value, SplineFunctor< decltype(std::declval<Iterable1>).begin()), decltype(std::declval<Iterable2>).begin()), ArgType> >::type hydra::make_spline ( Iterable1 &&  x, Iterable2 &&  y  )

inline

make_spline() [3/10]

template<typename T , hydra::detail::Backend BACKEND>

SplineFunctor<decltype( std::declval< DenseHistogram<T, 1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional > >).GetBinsCenters().begin()),decltype(std::declval< DenseHistogram<T, 1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional > >).GetBinsContents().begin()), T> hydra::make_spline ( DenseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > const &  histogram )

inline

make_spline() [4/10]

template<typename T , hydra::detail::Backend BACKEND>

std::enable_if< std::is_convertible<T, double>::value,Spline2DFunctor<decltype(std::declval<DenseHistogram<T, 2, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_0).begin()),decltype(std::declval<DenseHistogram<T, 2, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_1).begin()),decltype(std::declval<DenseHistogram<T, 2, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional > >).GetBinsContents().begin()), double, double> >::type hydra::make_spline ( DenseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &  histogram )

inline

make_spline() [5/10]

template<typename T , hydra::detail::Backend BACKEND>

SplineFunctor< decltype(std::declval<SparseHistogram<T, 1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional > >).GetBinsCenters().begin()), decltype(std::declval<SparseHistogram<T, 1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional > >).GetBinsContents().begin()), T> hydra::make_spline ( SparseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > const &  histogram )

inline

make_spline() [6/10]

template<typename T , hydra::detail::Backend BACKEND>

std::enable_if< std::is_convertible<T, double>::value,Spline2DFunctor<decltype(std::declval<SparseHistogram<T, 2, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_0).begin()),decltype(std::declval<SparseHistogram<T, 2, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_1).begin()),decltype(std::declval<SparseHistogram<T, 2, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional > >).GetBinsContents().begin()), double, double> >::type hydra::make_spline ( SparseHistogram< T, 2, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &  histogram )

inline

make_spline() [7/10]

template<typename T , hydra::detail::Backend BACKEND>

std::enable_if< std::is_convertible<T, double>::value,Spline3DFunctor<decltype(std::declval<DenseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_0).begin()),decltype(std::declval<DenseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_1).begin()),decltype(std::declval<DenseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_2).begin()),decltype(std::declval<DenseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional > >).GetBinsContents().begin()), double, double, double> >::type hydra::make_spline ( DenseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &  histogram )

inline

make_spline() [8/10]

template<typename T , hydra::detail::Backend BACKEND>

std::enable_if< std::is_convertible<T, double>::value,Spline3DFunctor<decltype(std::declval<SparseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_0).begin()),decltype(std::declval<SparseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_1).begin()),decltype(std::declval<SparseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_2).begin()),decltype(std::declval<SparseHistogram<T, 3, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional > >).GetBinsContents().begin()), double, double, double> >::type hydra::make_spline ( SparseHistogram< T, 3, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &  histogram )

inline

make_spline() [9/10]

template<typename T , hydra::detail::Backend BACKEND>

std::enable_if< std::is_convertible<T, double>::value,Spline4DFunctor<decltype(std::declval<DenseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_0).begin()),decltype(std::declval<DenseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_1).begin()),decltype(std::declval<DenseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_2).begin()),decltype(std::declval<DenseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_3).begin()),decltype(std::declval<DenseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional > >).GetBinsContents().begin()),double, double, double, double> >::type hydra::make_spline ( DenseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &  histogram )

inline

make_spline() [10/10]

template<typename T , hydra::detail::Backend BACKEND>

std::enable_if< std::is_convertible<T, double>::value,Spline4DFunctor<decltype(std::declval<SparseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_0).begin()),decltype(std::declval<SparseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_1).begin()),decltype(std::declval<SparseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_2).begin()),decltype(std::declval<SparseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional> >).GetBinsCenters(placeholders::_3).begin()),decltype(std::declval<SparseHistogram<T, 4, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional > >).GetBinsContents().begin()),double, double, double, double> >::type hydra::make_spline ( SparseHistogram< T, 4, hydra::detail::BackendPolicy< BACKEND >, detail::multidimensional > const &  histogram )

inline

make_spline2D() [1/2]

template<typename ArgTypeX , typename ArgTypeY , typename IteratorX , typename IteratorY , typename IteratorZ >

Spline2DFunctor< IteratorX, IteratorY, IteratorZ, ArgTypeX, ArgTypeY > hydra::make_spline2D ( IteratorX  firstX, IteratorX  lastX, IteratorY  firstY, IteratorY  lastY, IteratorZ  firstZ  )

inline

make_spline2D() [2/2]

template<typename ArgTypeX , typename ArgTypeY , typename IterableX , typename IterableY , typename IterableZ >

std::enable_if< hydra::detail::is_iterable<IterableX>::value && hydra::detail::is_iterable<IterableY>::value && hydra::detail::is_iterable<IterableZ>::value, Spline2DFunctor< decltype(std::declval<IterableX>).begin()) ,decltype(std::declval<IterableY>).begin()), decltype(std::declval<IterableZ>).begin()), ArgTypeX, ArgTypeY> >::type hydra::make_spline2D ( IterableX &&  x, IterableY &&  y, IterableZ &&  z  )

inline

make_spline3D() [1/2]

template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeZ , typename IteratorX , typename IteratorY , typename IteratorZ , typename IteratorM >

Spline3DFunctor< IteratorX, IteratorY, IteratorZ, IteratorM, ArgTypeX, ArgTypeY, ArgTypeZ > hydra::make_spline3D ( IteratorX  firstX, IteratorX  lastX, IteratorY  firstY, IteratorY  lastY, IteratorZ  firstZ, IteratorZ  lastZ, IteratorM  measurements_first  )

inline

make_spline3D() [2/2]

template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeZ , typename IterableX , typename IterableY , typename IterableZ , typename IterableM >

std::enable_if< hydra::detail::is_iterable<IterableX>::value && hydra::detail::is_iterable<IterableY>::value && hydra::detail::is_iterable<IterableZ>::value && hydra::detail::is_iterable<IterableM>::value, Spline3DFunctor< decltype(std::declval<IterableX>).begin()) ,decltype(std::declval<IterableY>).begin()), decltype(std::declval<IterableZ>).begin()), decltype(std::declval<IterableM>).begin()), ArgTypeX, ArgTypeY, ArgTypeZ> >::type hydra::make_spline3D ( IterableX &&  x, IterableY &&  y, IterableZ &&  z, IterableM &&  measurements  )

inline

make_spline4D() [1/2]

template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeW , typename ArgTypeZ , typename IteratorX , typename IteratorY , typename IteratorW , typename IteratorZ , typename IteratorM >

Spline4DFunctor< IteratorX, IteratorY, IteratorW, IteratorZ, IteratorM, ArgTypeX, ArgTypeY, ArgTypeW, ArgTypeZ > hydra::make_spline4D ( IteratorX  firstX, IteratorX  lastX, IteratorY  firstY, IteratorY  lastY, IteratorW  firstW, IteratorW  lastW, IteratorZ  firstZ, IteratorZ  lastZ, IteratorM  measurements_first  )

inline

make_spline4D() [2/2]

template<typename ArgTypeX , typename ArgTypeY , typename ArgTypeW , typename ArgTypeZ , typename IterableX , typename IterableY , typename IterableW , typename IterableZ , typename IterableM >

std::enable_if< hydra::detail::is_iterable<IterableX>::value && hydra::detail::is_iterable<IterableY>::value && hydra::detail::is_iterable<IterableW>::value && hydra::detail::is_iterable<IterableZ>::value && hydra::detail::is_iterable<IterableM>::value, Spline4DFunctor< decltype(std::declval<IterableX>).begin()), decltype(std::declval<IterableY>).begin()), decltype(std::declval<IterableW>).begin()), decltype(std::declval<IterableZ>).begin()), decltype(std::declval<IterableM>).begin()), ArgTypeX, ArgTypeY, ArgTypeW, ArgTypeZ> >::type hydra::make_spline4D ( IterableX &&  x, IterableY &&  y, IterableW &&  w, IterableZ &&  z, IterableM &&  measurements  )

inline

make_splot() [1/2]

template<typename Iterator , typename PDF1 , typename PDF2 , typename ... PDFs>

std::enable_if< detail::is_iterator<Iterator>::value, SPlot<Iterator, PDF1, PDF2, PDFs...> >::type hydra::make_splot	(	PDFSumExtendable< PDF1, PDF2, PDFs... > const &	pdf,
		Iterator	first,
		Iterator	last
	)

Convenience function for instantiating SPlot objects using type deduction.

Parameters

pdf	PDFSumExtendable<PDF1, PDF2, PDFs...> optimized object
first	iterator pointing to beginning of the data range.
last	iterator pointing to end of the data range.

Returns

Examples:

pseudo_experiment.inl, and splot.inl.

make_splot() [2/2]

template<typename Iterable , typename PDF1 , typename PDF2 , typename ... PDFs>

std::enable_if< detail::is_iterable<Iterable>::value, SPlot< decltype(std::declval<Iterable>).begin()), PDF1, PDF2, PDFs...> >::type hydra::make_splot	(	PDFSumExtendable< PDF1, PDF2, PDFs... > const &	pdf,
		Iterable &&	data
	)

Convenience function for instantiating SPlot objects using type deduction.

Parameters

pdf	PDFSumExtendable<PDF1, PDF2, PDFs...> optimized object
data	iterable representing the data-range

Returns

make_tuple()

template<class ... T>

__hydra_host__ __hydra_device__ auto hydra::make_tuple ( T &&...  t ) -> decltype(hydra::thrust::make_tuple( std::forward<T>(t)...))

inline

This version of make_tuple creates a new tuple object from a list of objects.

Parameters

T	The first object to copy from.

Returns

A tuple object with members which are copies of t.

Examples:

dalitz_plot.C, dalitz_plot.inl, multiarray_container.inl, multidimensional_fit.inl, multivector_container.inl, phsp_basic.inl, phsp_chain.inl, phsp_reweighting.inl, phsp_unweighting.inl, phsp_unweighting_functor.inl, and pseudo_experiment.inl.

meld()

template<hydra::detail::Backend BACKEND, typename ... T, typename ... U>

hydra::Range< hydra::thrust::zip_iterator< typename detail::tuple_cat_type<typename multivector<hydra::thrust::tuple<T...>, detail::BackendPolicy<BACKEND> >::iterator_tuple,typename multivector<hydra::thrust::tuple<U...>, detail::BackendPolicy<BACKEND> >::iterator_tuple>::type> > hydra::meld ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &  left, multivector< hydra::thrust::tuple< U... >, detail::BackendPolicy< BACKEND >> &  right  )

inline

minus()

template<typename F1 , typename F2 >

std::enable_if<(detail::is_hydra_functor<F1>::value || detail::is_hydra_lambda<F1>::value ) &&(detail::is_hydra_functor<F2>::value || detail::is_hydra_lambda<F2>::value ),Minus<F1, F2> >::type hydra::minus ( F1 const &  f1, F2 const &  f2  )

inline

multiply()

template<typename F1 , typename F2 , typename ... Fs>

std::enable_if<(detail::is_hydra_functor<F1>::value || detail::is_hydra_lambda<F1>::value ) &&(detail::is_hydra_functor<F2>::value || detail::is_hydra_lambda<F2>::value ) &&detail::all_true<(detail::is_hydra_functor<Fs>::value || detail::is_hydra_lambda<Fs>::value )...>::value,Multiply<F1, F2,Fs...> >::type hydra::multiply ( F1 const &  f1, F2 const &  f2, Fs const &...  functors  )

inline

nint()

template<typename T >

__hydra_host__ __hydra_device__ int hydra::nint ( const T  x )

inline

Round to nearest integer.

Rounds half integers to the nearest even integer.

Parameters

x

Returns

norm()

template<typename T >

__hydra_host__ __hydra_device__ T hydra::norm

(

const complex< T > &

z

)

Examples:

dalitz_plot.C, and dalitz_plot.inl.

operator!=() [1/5]

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::operator!=	(	const complex< T > &	lhs,
		const complex< T > &	rhs
	)

operator!=() [2/5]

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::operator!=	(	const T &	lhs,
		const complex< T > &	rhs
	)

operator!=() [3/5]

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::operator!=	(	const complex< T > &	lhs,
		const T &	rhs
	)

operator!=() [4/5]

template<typename T , size_t N, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>

bool hydra::operator!=	(	const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND1 >> &	lhs,
		const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND2 >> &	rhs
	)

operator!=() [5/5]

template<typename ... T, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>

bool hydra::operator!=	(	const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND1 >> &	lhs,
		const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND2 >> &	rhs
	)

operator*() [1/15]

__hydra_host__ __hydra_device__ Vector3R hydra::operator* ( GReal_t  c, const Vector3R &  v2  )

inline

operator*() [2/15]

__hydra_host__ __hydra_device__ Vector3R hydra::operator* ( const Vector3R &  v1, GReal_t  c  )

inline

operator*() [3/15]

__hydra_host__ __hydra_device__ GReal_t hydra::operator* ( const Vector3R &  v1, const Vector3R &  v2  )

inline

operator*() [4/15]

template<typename T1 , typename T2 >

std::enable_if<(detail::is_hydra_functor<T1>::value || detail::is_hydra_lambda<T1>::value ) &&(detail::is_hydra_functor<T2>::value || detail::is_hydra_lambda<T2>::value ),Multiply<T1, T2> >::type hydra::operator* ( T1 const &  F1, T2 const &  F2  )

inline

operator*() [5/15]

__hydra_host__ __hydra_device__ Vector4R hydra::operator* ( GReal_t  c, const Vector4R &  v2  )

inline

operator*() [6/15]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Multiply< Constant<U>, T> >::type hydra::operator* ( U const  cte, T const &  F  )

inline

operator*() [7/15]

__hydra_host__ __hydra_device__ Vector4R hydra::operator* ( const Vector4R &  v2, GReal_t  c  )

inline

operator*() [8/15]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Multiply< Constant<U>, T> >::type hydra::operator* ( T const &  F, U  cte  )

inline

operator*() [9/15]

__hydra_host__ __hydra_device__ GReal_t hydra::operator* ( const Vector4R &  v1, const Vector4R &  v2  )

inline

operator*() [10/15]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Multiply< Constant<hydra::complex<U> >, T> >::type hydra::operator* ( hydra::complex< U > const &  cte, T const &  F  )

inline

operator*() [11/15]

template<typename ... T>

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

inline

operator*() [12/15]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Multiply< Constant<U>, T> >::type hydra::operator* ( T const &  F, hydra::complex< U > const &  cte  )

inline

operator*() [13/15]

__hydra_host__ __hydra_device__ Parameter hydra::operator* ( Parameter  par1, Parameter const &  par2  )

inline

operator*() [14/15]

__hydra_host__ __hydra_device__ GReal_t hydra::operator* ( Parameter  par1, GReal_t  par2  )

inline

operator*() [15/15]

__hydra_host__ __hydra_device__ GReal_t hydra::operator* ( GReal_t  par1, Parameter const &  par2  )

inline

operator+() [1/10]

__hydra_host__ __hydra_device__ Vector3R hydra::operator+ ( const Vector3R &  v1, const Vector3R &  v2  )

inline

operator+() [2/10]

template<typename T1 , typename T2 >

std::enable_if<(detail::is_hydra_functor<T1>::value || detail::is_hydra_lambda<T1>::value ) &&(detail::is_hydra_functor<T2>::value || detail::is_hydra_lambda<T2>::value ),Sum<T1, T2> >::type hydra::operator+ ( T1 const &  F1, T2 const &  F2  )

inline

operator+ for two functors.

operator+() [3/10]

template<typename ... T>

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

inline

operator+() [4/10]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Sum< Constant<U>, T> >::type hydra::operator+ ( U const  cte, T const &  F  )

inline

operator+ for a value and a functor.

operator+() [5/10]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Sum< Constant<U>, T> >::type hydra::operator+ ( T const &  F, U  cte  )

inline

operator+ for a value and a functor.

operator+() [6/10]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Sum< Constant<hydra::complex<U> >, T> >::type hydra::operator+ ( hydra::complex< U > const &  cte, T const &  F  )

inline

operator+ for a complex value and a functor.

operator+() [7/10]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Sum< Constant<U>, T> >::type hydra::operator+ ( T const &  F, hydra::complex< U > const &  cte  )

inline

operator+ for a complex value and a functor.

operator+() [8/10]

__hydra_host__ __hydra_device__ Vector4R hydra::operator+ ( const Vector4R &  v1, const Vector4R &  v2  )

inline

operator+() [9/10]

__hydra_host__ __hydra_device__ Parameter hydra::operator+ ( Parameter  par1, Parameter const &  par2  )

inline

operator+() [10/10]

__hydra_host__ __hydra_device__ GReal_t hydra::operator+ ( Parameter  par1, GReal_t  par2  )

inline

operator-() [1/11]

template<typename T1 , typename T2 >

std::enable_if<(detail::is_hydra_functor<T1>::value || detail::is_hydra_lambda<T1>::value ) &&(detail::is_hydra_functor<T2>::value || detail::is_hydra_lambda<T2>::value ),Minus<T1, T2> >::type hydra::operator- ( T1 const &  F1, T2 const &  F2  )

inline

operator-() [2/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Minus< Constant<U>, T> >::type hydra::operator- ( U const  cte, T const &  F  )

inline

operator-() [3/11]

__hydra_host__ __hydra_device__ Vector3R hydra::operator- ( const Vector3R &  v1, const Vector3R &  v2  )

inline

operator-() [4/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Minus< Constant<U>, T> >::type hydra::operator- ( T const &  F, U  cte  )

inline

operator-() [5/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Minus< Constant<hydra::complex<U> >, T> >::type hydra::operator- ( hydra::complex< U > const &  cte, T const &  F  )

inline

operator-() [6/11]

template<typename ... T>

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

inline

operator-() [7/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Minus< Constant<U>, T> >::type hydra::operator- ( T const &  F, hydra::complex< U > const &  cte  )

inline

operator-() [8/11]

__hydra_host__ __hydra_device__ Vector4R hydra::operator- ( const Vector4R &  v1, const Vector4R &  v2  )

inline

operator-() [9/11]

__hydra_host__ __hydra_device__ Parameter hydra::operator- ( Parameter  par1, Parameter const &  par2  )

inline

operator-() [10/11]

__hydra_host__ __hydra_device__ GReal_t hydra::operator- ( Parameter  par1, GReal_t  par2  )

inline

operator-() [11/11]

__hydra_host__ __hydra_device__ GReal_t hydra::operator- ( GReal_t  par1, Parameter  par2  )

inline

operator/() [1/11]

template<typename T1 , typename T2 >

std::enable_if<(detail::is_hydra_functor<T1>::value || detail::is_hydra_lambda<T1>::value) &&(detail::is_hydra_functor<T2>::value || detail::is_hydra_lambda<T2>::value),Divide<T1, T2> >::type hydra::operator/ ( T1 const &  F1, T2 const &  F2  )

inline

operator/() [2/11]

__hydra_host__ __hydra_device__ Vector3R hydra::operator/ ( const Vector3R &  v1, GReal_t  c  )

inline

operator/() [3/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Divide< Constant<U>, T> >::type hydra::operator/ ( U const  cte, T const &  F  )

inline

operator/() [4/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Divide< Constant<U>, T> >::type hydra::operator/ ( T const &  F, U  cte  )

inline

operator/() [5/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Divide< Constant<hydra::complex<U> >, T> >::type hydra::operator/ ( hydra::complex< U > const &  cte, T const &  F  )

inline

operator/() [6/11]

template<typename T , typename U >

std::enable_if<(detail::is_hydra_functor<T>::value || detail::is_hydra_lambda<T>::value ) &&(std::is_arithmetic<U>::value),Divide< Constant<hydra::complex<U> >, T> >::type hydra::operator/ ( T const &  F, hydra::complex< U > const &  cte  )

inline

operator/() [7/11]

__hydra_host__ __hydra_device__ Vector4R hydra::operator/ ( const Vector4R &  v2, GReal_t  c  )

inline

operator/() [8/11]

template<typename ... T>

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

inline

operator/() [9/11]

__hydra_host__ __hydra_device__ Parameter hydra::operator/ ( Parameter  par1, Parameter const  par2  )

inline

operator/() [10/11]

__hydra_host__ __hydra_device__ GReal_t hydra::operator/ ( Parameter  par1, GReal_t  par2  )

inline

operator/() [11/11]

__hydra_host__ __hydra_device__ GReal_t hydra::operator/ ( GReal_t  par1, Parameter  par2  )

inline

operator<<() [1/8]

template<size_t N, typename T >

std::ostream& hydra::operator<< ( std::ostream &  os, std::array< T, N > const &  obj  )

inline

operator<<() [2/8]

template<typename ... T>

std::ostream& hydra::operator<< ( std::ostream &  os, std::tuple< T... > const &  obj  )

inline

operator<<() [3/8]

template<typename T1 , typename T2 >

std::ostream& hydra::operator<< ( std::ostream &  os, std::pair< T1, T2 > const &  obj  )

inline

operator<<() [4/8]

ostream& hydra::operator<< ( ostream &  s, const Vector3R &  v  )

inline

operator<<() [5/8]

ostream& hydra::operator<< ( ostream &  s, const Vector4R &  v  )

inline

operator<<() [6/8]

std::ostream& hydra::operator<<	(	std::ostream &	os,
		UserParameters const &	par
	)

Print the ROOT::Minuit2 state to stream.

Parameters

os	std::ostream
par	hydra::UserParameters

Returns

operator<<() [7/8]

template<typename ValueType , class charT , class traits >

std::basic_ostream< charT,traits >& hydra::operator<<	(	std::basic_ostream< charT, traits > &	os,
		const complex< ValueType > &	z
	)

operator<<() [8/8]

std::ostream& hydra::operator<< ( std::ostream &  os, Parameter const &  var  )

inline

operator==() [1/5]

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::operator==	(	const complex< T > &	lhs,
		const complex< T > &	rhs
	)

operator==() [2/5]

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::operator==	(	const T &	lhs,
		const complex< T > &	rhs
	)

operator==() [3/5]

template<typename T >

__hydra_host__ __hydra_device__ bool hydra::operator==	(	const complex< T > &	lhs,
		const T &	rhs
	)

operator==() [4/5]

template<typename T , size_t N, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>

bool hydra::operator==	(	const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND1 >> &	lhs,
		const multiarray< T, N, hydra::detail::BackendPolicy< BACKEND2 >> &	rhs
	)

operator==() [5/5]

template<typename ... T, hydra::detail::Backend BACKEND1, hydra::detail::Backend BACKEND2>

bool hydra::operator==	(	const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND1 >> &	lhs,
		const multivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND2 >> &	rhs
	)

operator>>()

template<typename ValueType , typename charT , class traits >

std::basic_istream< charT,traits >& hydra::operator>>	(	std::basic_istream< charT, traits > &	is,
		complex< ValueType > &	z
	)

operator|() [1/2]

template<typename Iterable , typename Functor >

hydra::thrust::detail::enable_if< detail::is_iterable<Iterable>::value && ( detail::is_hydra_functor<Functor>::value || detail::is_hydra_lambda<Functor>::value ) , Range<decltype(std::declval< const Iterable>).begin()), Functor> >::type hydra::operator|	(	Iterable const &	iterable,
		Functor const &	functor
	)

operator|() [2/2]

template<typename Iterable , typename Functor >

hydra::thrust::detail::enable_if< detail::is_iterable<Iterable>::value && (detail::is_hydra_functor<Functor>::value || detail::is_hydra_lambda<Functor>::value ), Range<decltype(std::declval<Iterable>).begin()), Functor> >::type hydra::operator|	(	Iterable &&	iterable,
		Functor const &	functor
	)

phase_space_range()

template<size_t N>

Range<hydra::thrust::transform_iterator< detail::GenerateDecay<N,hydra::thrust::random::default_random_engine>, hydra::thrust::counting_iterator<size_t>, typename hydra::detail::tuple_cat_type< hydra::thrust::tuple<double>, typename hydra::detail::tuple_type<N,Vector4R>::type>::type> > hydra::phase_space_range	(	Vector4R const &	mother,
		std::array< double, N >	masses,
		size_t	seed,
		size_t	length = 0
	)

Examples:

range_semantics.inl.

pmf()

__hydra_host__ __hydra_device__ double hydra::pmf ( const double  mother_mass, const double  daughter1_mass, const double  daughter2_mass  )

inline

Momentum in mother frame of daughter particle in two-body-decay.

Parameters

mother_mass
daughter1_mass
daughter2_mass

Returns

polar()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::polar	(	const T &	m,
		const T &	theta = 0
	)

pow() [1/7]

template<typename T , unsigned int N>

__hydra_host__ __hydra_device__ T hydra::pow ( T  x )

inline

Power with integer exponent.

Parameters

x

Returns

pow() [2/7]

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::pow	(	const complex< T > &	x,
		const complex< T > &	y
	)

Examples:

dalitz_plot.C, dalitz_plot.inl, gaussian_plus_argus.inl, phsp_basic.inl, phsp_chain.inl, phsp_reweighting.inl, phsp_unweighting.inl, and phsp_unweighting_functor.inl.

pow() [3/7]

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::pow	(	const complex< T > &	x,
		const T &	y
	)

pow() [4/7]

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::pow	(	const T &	x,
		const complex< T > &	y
	)

pow() [5/7]

template<typename T , typename U >

__hydra_host__ __hydra_device__ complex< typename hydra::thrust::detail::promoted_numerical_type< T, U >::type > hydra::pow	(	const complex< T > &	x,
		const complex< U > &	y
	)

pow() [6/7]

template<typename T , typename U >

__hydra_host__ __hydra_device__ complex< typename hydra::thrust::detail::promoted_numerical_type< T, U >::type > hydra::pow	(	const complex< T > &	x,
		const U &	y
	)

pow() [7/7]

template<typename T , typename U >

__hydra_host__ __hydra_device__ complex< typename hydra::thrust::detail::promoted_numerical_type< T, U >::type > hydra::pow	(	const T &	x,
		const complex< U > &	y
	)

PrintToStream()

template<typename... Args>

void hydra::PrintToStream	(	std::ostream &	ostream,
		const char *	format,
		Args...	args
	)

proj()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::proj

(

const T &

z

)

random_range()

template<typename Engine = hydra::default_random_engine, typename Functor >

Range< hydra::thrust::transform_iterator< detail::Sampler<Functor,Engine >, hydra::thrust::counting_iterator<size_t>, typename detail::Sampler<Functor,Engine>::value_type > > hydra::random_range	(	Functor const &	functor,
		size_t	seed = 0x8ec74d321e6b5a27,
		size_t	length = 0,
		size_t	rng_jump = 0
	)

Examples:

basic_fit.inl, fit_gaussian.C, fit_johnson.C, range_semantics.inl, and simultaneous_fit.inl.

range() [1/2]

Range<hydra::thrust::counting_iterator<long int> > hydra::range	(	long int	first,
		long int	last
	)

Examples:

booststrapping.inl, dense_histogram.inl, and fit_convoluted_pdfs.inl.

range() [2/2]

template<typename T >

std::enable_if< std::is_floating_point<T>::value, Range<hydra::thrust::counting_iterator<unsigned>, detail::range::Shift<T> > >::type hydra::range ( T  min, T  max, unsigned  nbins  )

inline

Range< iterator_type >() [1/2]

return hydra::Range< iterator_type >	(	other.	begincls...,
		other.	endcls...
	)

Initial value:

{

    typedef decltype( other.begin(cls...)) iterator_type

Range< iterator_type >() [2/2]

return hydra::Range< iterator_type >	(	other.	beginplaceholders::placeholder< I >{},
		other.	endplaceholders::placeholder< I >{}
	)

rbegin() [1/7]

template<class C >

auto hydra::rbegin

(

C &&

c

)

-> decltype(std::forward< C >(c).rbegin())

rbegin() [2/7]

template<class C >

auto hydra::rbegin

(

const C &

c

)

-> decltype(c.rbegin())

rbegin() [3/7]

template<class T , size_t N>

T * hydra::rbegin

(

T(&)

array[N]

)

rbegin() [4/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::rbegin ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> const &  other  ) -> decltype(other.rbegin(placeholders::placeholder<I>

inline

rbegin() [5/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::rbegin ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> &  other  ) -> decltype(other.rbegin(placeholders::placeholder<I>

inline

rbegin() [6/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::rbegin ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &  other ) -> decltype(other.rbegin(placeholders::placeholder<I>

inline

rbegin() [7/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::rbegin ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &  other ) -> decltype(other.rbegin(placeholders::placeholder<I>

inline

reduce() [1/2]

template<typename Iterable >

std::enable_if<hydra::detail::is_iterable<Iterable>::value,typename hydra::thrust::iterator_traits<decltype(std::declval<Iterable>).begin())>::value_type >::type hydra::reduce

(

Iterable &&

iterable

)

reduce() [2/2]

template<typename Iterable , typename Functor , typename T = typename hydra::thrust::iterator_traits< decltype(std::declval<Iterable>().begin())>::value_type>

std::enable_if<hydra::detail::is_iterable<Iterable>::value, T >::type hydra::reduce	(	Iterable &&	iterable,
		T const &	init,
		Functor const &	binary_functor
	)

rend() [1/7]

template<class C >

auto hydra::rend

(

C &&

c

)

-> decltype(std::forward< C >(c).rend())

rend() [2/7]

template<class C >

auto hydra::rend

(

const C &

c

)

-> decltype(c.rend())

rend() [3/7]

template<class T , size_t N>

T * hydra::rend

(

T(&)

array[N]

)

rend() [4/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::rend ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> const &  other  ) -> decltype(other.rend(placeholders::placeholder<I>

inline

rend() [5/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename T , size_t N>

auto hydra::rend ( placeholders::placeholder< I >  , multiarray< T, N, detail::BackendPolicy< BACKEND >> &  other  ) -> decltype(other.rend(placeholders::placeholder<I>

inline

rend() [6/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::rend ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> const &  other ) -> decltype(other.rend(placeholders::placeholder<I>

inline

rend() [7/7]

template<unsigned int I, hydra::detail::Backend BACKEND, typename ... T>

auto hydra::rend ( multivector< hydra::thrust::tuple< T... >, detail::BackendPolicy< BACKEND >> &  other ) -> decltype(other.rend(placeholders::placeholder<I>

inline

reverse()

template<typename Iterable >

hydra::thrust::detail::enable_if< detail::is_iterable<Iterable>::value , Range< hydra::thrust::reverse_iterator< decltype(std::declval<Iterable>).begin()) > > >::type hydra::reverse

(

Iterable &&

iterable

)

rint()

template<typename T >

__hydra_host__ __hydra_device__ double hydra::rint ( T  x )

inline

rotateEuler() [1/2]

__hydra_host__ __hydra_device__ Vector4R hydra::rotateEuler ( const Vector4R &  rs, GReal_t  alpha, GReal_t  beta, GReal_t  gamma  )

inline

rotateEuler() [2/2]

__hydra_host__ __hydra_device__ Vector3R hydra::rotateEuler ( const Vector3R &  v, GReal_t  phi, GReal_t  theta, GReal_t  ksi  )

inline

sample() [1/13]

template<typename RNG , typename DerivedPolicy , typename Functor , typename Iterator >

std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type hydra::sample	(	hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &	policy,
		Iterator	begin,
		Iterator	end,
		double	min,
		double	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

policy	backend to perform the calculation.
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	lower limit of sampling region
max	upper limit of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

range with the generated values

sample() [2/13]

template<typename RNG , typename Functor , typename Iterator , hydra::detail::Backend BACKEND>

std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type hydra::sample	(	hydra::detail::BackendPolicy< BACKEND > const &	policy,
		Iterator	begin,
		Iterator	end,
		double	min,
		double	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

policy	backend to perform the calculation.
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	lower limit of sampling region
max	upper limit of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

range with the generated values

sample() [3/13]

template<typename RNG , typename Functor , typename Iterator >

std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type hydra::sample	(	Iterator	begin,
		Iterator	end,
		double	min,
		double	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	lower limit of sampling region
max	upper limit of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

range with the generated values

sample() [4/13]

template<typename RNG , typename Functor , typename Iterable >

std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value,Range< decltype(std::declval< Iterable >).begin())> >::type hydra::sample	(	Iterable &&	output,
		double	min,
		double	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

output	range storing the generated values
min	lower limit of sampling region
max	upper limit of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

range with the generated values

sample() [5/13]

template<typename RNG , typename DerivedPolicy , typename Functor , typename Iterator , size_t N>

std::enable_if< detail::random::is_callable<Functor>::value && detail::random::is_iterator<Iterator>::value, Range<Iterator>>::type hydra::sample	(	hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &	policy,
		Iterator	begin,
		Iterator	end,
		std::array< double, N >const &	min,
		std::array< double, N >const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

policy	backend to perform the calculation.
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	array of lower limits of sampling region
max	array of upper limits of sampling region.
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator
functor	distribution to be sampled

sample() [6/13]

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

std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterator< Iterator >::value, Range< Iterator > >::type hydra::sample	(	hydra::detail::BackendPolicy< BACKEND > const &	policy,
		Iterator	begin,
		Iterator	end,
		std::array< double, N >const &	min,
		std::array< double, N >const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

policy	backend to perform the calculation.
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	array of lower limits of sampling region
max	array of upper limits of sampling region.
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator
functor	distribution to be sampled

sample() [7/13]

template<typename RNG , typename Functor , typename Iterator , size_t N>

std::enable_if< detail::random::is_callable<Functor>::value && detail::random::is_iterator<Iterator>::value, Range<Iterator>>::type hydra::sample	(	Iterator	begin,
		Iterator	end,
		std::array< double, N >const &	min,
		std::array< double, N >const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	array of lower limits of sampling region
max	array of upper limits of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

range with the generated values

sample() [8/13]

template<typename RNG , typename Functor , typename Iterator >

std::enable_if<detail::random::is_callable<Functor>::value &&detail::random::is_iterator<Iterator>::value &&detail::is_tuple_type< decltype(*std::declval<Iterator>))>::value,Range<Iterator> >::type hydra::sample	(	Iterator	begin,
		Iterator	end,
		typename Functor::argument_type const &	min,
		typename Functor::argument_type const &	max,
		Functor const &	functor,
		size_t	seed,
		size_t	rng_jump
	)

sample() [9/13]

template<typename RNG , typename Functor , typename Iterable , size_t N>

std::enable_if< detail::random::is_callable<Functor>::value && detail::random::is_iterable<Iterable>::value , Range< decltype(std::declval<Iterable>).begin())>>::type hydra::sample	(	Iterable &&	output,
		std::array< double, N >const &	min,
		std::array< double, N >const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

output	range storing the generated values
min	array of lower limits of sampling region
max	array of upper limits of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

output range with the generated values

sample() [10/13]

template<typename RNG , typename Functor , typename Iterable >

std::enable_if< detail::random::is_callable< Functor >::value &&detail::random::is_iterable< Iterable >::value &&detail::is_tuple_type< decltype(*std::declval< Iterable >).begin())>::value,Range< decltype(std::declval< Iterable >).begin())> >::type hydra::sample	(	Iterable &&	output,
		typename Functor::argument_type const &	min,
		typename Functor::argument_type const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

output	range storing the generated values
min	tuple of lower limits of sampling region
max	tuple of upper limits of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

output range with the generated values

sample() [11/13]

template<typename RNG = default_random_engine, typename Functor , typename Iterator , size_t N>

std::enable_if<detail::random::is_callable<Functor>::value && detail::random::is_iterator<Iterator>::value,Range<Iterator> >::type hydra::sample	(	Iterator	begin,
		Iterator	end,
		std::array< double, N >const &	min,
		std::array< double, N >const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	array of lower limits of sampling region
max	array of upper limits of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

range with the generated values

sample() [12/13]

template<typename RNG = default_random_engine, typename DerivedPolicy , typename Functor , typename Iterator , size_t N>

std::enable_if<detail::random::is_callable<Functor>::value && detail::random::is_iterator<Iterator>::value,Range<Iterator> >::type hydra::sample	(	hydra::thrust::detail::execution_policy_base< DerivedPolicy > const &	policy,
		Iterator	begin,
		Iterator	end,
		std::array< double, N >const &	min,
		std::array< double, N >const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

policy	backend to perform the calculation.
begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	array of lower limits of sampling region
max	array of upper limits of sampling region.
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator
functor	distribution to be sampled

sample() [13/13]

template<typename RNG = default_random_engine, typename Functor , typename Iterable , size_t N>

std::enable_if<detail::random::is_callable<Functor>::value && detail::random::is_iterable<Iterable>::value ,Range< decltype(std::declval<Iterable>).begin())> >::type hydra::sample	(	Iterable &&	output,
		std::array< double, N >const &	min,
		std::array< double, N >const &	max,
		Functor const &	functor,
		size_t	seed = 0xb56c4feeef1b,
		size_t	rng_jump = 0
	)

Fill a range with numbers distributed according a user defined distribution.

Parameters

output	range storing the generated values
min	array of lower limits of sampling region
max	array of upper limits of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

output range with the generated values

scatter()

template<typename Iterable_Source , typename Iterable_Target , typename Iterable_Map >

std::enable_if<hydra::detail::is_iterable<Iterable_Source>::value && hydra::detail::is_iterable<Iterable_Target>::value && hydra::detail::is_iterable<Iterable_Map>::value,Range<decltype(std::declval<Iterable_Target&>).begin())> >::type hydra::scatter	(	Iterable_Source &&	source,
		Iterable_Map &&	map,
		Iterable_Target &&	target
	)

segregate() [1/2]

template<typename Iterable , typename Functor >

std::enable_if< hydra::detail::is_iterable<Iterable>::value,std::pair<hydra::Range<decltype(std::declval<Iterable>).begin())>, hydra::Range<decltype(std::declval<Iterable>).begin())> > >::type hydra::segregate ( Iterable &&  container, Functor &&  filter  )

inline

segregate() [2/2]

template<typename Iterable , typename Functor >

std::enable_if< hydra::detail::is_iterable<Iterable>::value, std::pair<hydra::Range<decltype(std::declval<Iterable>).begin())>, hydra::Range<decltype(std::declval<Iterable>).begin())> > >::type hydra::segregate ( Iterable &&  container, Functor const &  filter  )

inline

sin()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::sin

(

const complex< T > &

z

)

Examples:

dalitz_plot.C, and dalitz_plot.inl.

sinh()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::sinh

(

const complex< T > &

z

)

sort() [1/2]

template<typename Iterable , typename Iterator = decltype(std::declval<Iterable>().begin())>

std::enable_if<hydra::detail::is_iterable<Iterable>::value,Range<decltype(std::declval<Iterable&>).begin())> >::type hydra::sort

(

Iterable &

iterable

)

sort() [2/2]

template<typename Iterable , typename Functor , typename Iterator = decltype(std::declval<Iterable>().begin())>

std::enable_if<hydra::detail::is_iterable<Iterable>::value,Range<decltype(std::declval<Iterable&>).begin())> >::type hydra::sort	(	Iterable &	iterable,
		Functor const &	comparator
	)

sort_by_key() [1/2]

template<typename Iterable , typename Iterable_Key , typename Iterator = decltype(std::declval<Iterable>().begin()), typename Iterator_Key = decltype(std::declval<Iterable_Key>().begin()), typename Value_Key = decltype(*std::declval<Iterator_Key>().begin())>

std::enable_if<hydra::detail::is_iterable<Iterable>::value,Range<decltype(std::declval<Iterable&>).begin())> >::type hydra::sort_by_key	(	Iterable &	iterable,
		Iterable_Key &	keys
	)

Examples:

range_semantics.inl.

sort_by_key() [2/2]

template<typename Iterable , typename Iterator_Key , typename Functor , typename Iterator = decltype(std::declval<Iterable>().begin()), typename Value_Key = decltype(*std::declval<Range<Iterator_Key,Functor>>().begin())>

std::enable_if<hydra::detail::is_iterable<Iterable>::value,Range<decltype(std::declval<Iterable&>).begin())> >::type hydra::sort_by_key	(	Iterable &	iterable,
		Range< Iterator_Key, Functor >	keys
	)

spline() [1/3]

template<typename IterableX , typename IterableY , typename IterableM , typename TypeX , typename TypeY >

__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable<IterableX>::value && hydra::detail::is_iterable<IterableY>::value && hydra::detail::is_iterable<IterableM>::value && std::is_convertible<typename IterableX::value_type, double >::value && std::is_convertible<typename IterableY::value_type, double >::value && std::is_convertible<typename IterableM::value_type, double >::value && std::is_convertible<TypeX, double >::value && std::is_convertible<TypeY, double >::value , double >::type hydra::spline ( IterableX &&  abcissa_x, IterableY &&  abcissa_y, IterableM  measurements, TypeX  x, TypeX  y  )

inline

spline() [2/3]

template<typename Iterator1 , typename Iterator2 , typename Type >

__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< Iterator1 >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< Iterator2 >::value_type, double >::value &&std::is_convertible< Type, double >::value, Type >::type hydra::spline ( Iterator1  first, Iterator1  last, Iterator2  measurements, Type  value  )

inline

Cubic monotone spline interpolation.

Template Parameters

Iterator1	Iterator type of the abcissae. Convertible to double
Iterator2	Iterator type of data to interpolate. Convertible to double
Type	interpolation point data. Convertible to double

Parameters

first	iterator pointing to the first element of the abcissae range
last	iterator pointing to the last element of the abcissae range
measurements	iterator pointing to the first element of the data range with at least (last - first) elements
value	point where to calculate the interpolation

Returns

Interpolated value

spline() [3/3]

template<typename Iterable1 , typename Iterable2 , typename Type >

__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< Iterable1 >::value &&hydra::detail::is_iterable< Iterable2 >::value &&std::is_convertible< typename Iterable1::value_type, double >::value &&std::is_convertible< typename Iterable2::value_type, double >::value &&std::is_convertible< Type, double >::value, Type >::type hydra::spline ( Iterable1 &&  abscissae, Iterable2 &&  ordinate, Type  value  )

inline

Precondition

Postcondition

Template Parameters

Iterable1	Iterable range of the abcissae. Convertible to double
Iterable2	Iterable range of data to interpolate. Convertible to double
Type	Interpolation point data. Convertible to double

Parameters

abiscissae	range of the abcissae
measurements	range of data to interpolate. Same size of abcissae
value	point where to calculate the interpolation

Returns

Interpolated value

spline2D() [1/2]

template<typename IteratorX , typename IteratorY , typename IteratorM , typename TypeX , typename TypeY >

__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< IteratorX >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorY >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorM >::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value, double >::type hydra::spline2D ( IteratorX  firstx, IteratorX  lastx, IteratorY  firsty, IteratorY  lasty, IteratorM  measurements, TypeX  x, TypeY  y  )

inline

spline2D() [2/2]

template<typename IterableX , typename IterableY , typename IterableM , typename TypeX , typename TypeY >

__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable<IterableX>::value && hydra::detail::is_iterable<IterableY>::value && hydra::detail::is_iterable<IterableM>::value && std::is_convertible<typename IterableX::value_type, double >::value && std::is_convertible<typename IterableY::value_type, double >::value && std::is_convertible<typename IterableM::value_type, double >::value && std::is_convertible<TypeX, double >::value && std::is_convertible<TypeY, double >::value , double >::type hydra::spline2D ( IterableX &&  abscissa_x, IterableY &&  abscissa_y, IterableM  measurements, TypeX  x, TypeX  y  )

inline

spline3D() [1/4]

template<typename IteratorX , typename IteratorY , typename IteratorZ , typename IteratorM , typename TypeX , typename TypeY , typename TypeZ >

__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible<typename hydra::thrust::iterator_traits<IteratorX>::value_type, double >::value && std::is_convertible<typename hydra::thrust::iterator_traits<IteratorY>::value_type, double >::value && std::is_convertible<typename hydra::thrust::iterator_traits<IteratorZ>::value_type, double >::value && std::is_convertible<typename hydra::thrust::iterator_traits<IteratorM>::value_type, double >::value && std::is_convertible<TypeX, double >::value && std::is_convertible<TypeY, double >::value && std::is_convertible<TypeZ, double >::value, double>::type hydra::spline3D ( IteratorX  firstx, IteratorX  lastx, IteratorY  firsty, IteratorY  lasty, IteratorZ  firstz, IteratorZ  lastz, IteratorM  measurements, TypeX  x, TypeY  y, TypeZ  z  )

inline

spline3D() [2/4]

template<typename IterableX , typename IterableY , typename IterableZ , typename IterableM , typename TypeX , typename TypeY , typename TypeZ >

__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableZ >::value &&hydra::detail::is_iterable< IterableM >::value &&std::is_convertible< typename IterableX::value_type, double >::value &&std::is_convertible< typename IterableY::value_type, double >::value &&std::is_convertible< typename IterableZ::value_type, double >::value &&std::is_convertible< typename IterableM::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type hydra::spline3D ( IterableX &&  abscissa_x, IterableY &&  abscissa_y, IterableZ &&  abscissa_z, IterableM  measurements, TypeX  x, TypeX  y, TypeZ  z  )

inline

spline3D() [3/4]

template<typename IteratorX , typename IteratorY , typename IteratorZ , typename IteratorM , typename TypeX , typename TypeY , typename TypeZ >

__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible<typename hydra::thrust::iterator_traits<IteratorX>::value_type, double >::value && std::is_convertible<typename hydra::thrust::iterator_traits<IteratorY>::value_type, double >::value && std::is_convertible<typename hydra::thrust::iterator_traits<IteratorZ>::value_type, double >::value && std::is_convertible<typename hydra::thrust::iterator_traits<IteratorM>::value_type, double >::value && std::is_convertible<TypeX, double >::value && std::is_convertible<TypeY, double >::value && std::is_convertible<TypeZ, double >::value, double>::type hydra::spline3D ( IteratorX  firstx, IteratorX  lastx, IteratorY  firsty, IteratorY  lasty, IteratorY  firstz, IteratorY  lastz, IteratorM  measurements, TypeX  x, TypeY  y, TypeZ  z  )

inline

spline3D() [4/4]

template<typename IterableX , typename IterableY , typename IterableW , typename IterableZ , typename IterableM , typename TypeX , typename TypeY , typename TypeW , typename TypeZ >

__hydra_host__ __hydra_device__ std::enable_if< hydra::detail::is_iterable< IterableX >::value &&hydra::detail::is_iterable< IterableY >::value &&hydra::detail::is_iterable< IterableW >::value &&hydra::detail::is_iterable< IterableZ >::value &&hydra::detail::is_iterable< IterableM >::value &&std::is_convertible< typename IterableX::value_type, double >::value &&std::is_convertible< typename IterableY::value_type, double >::value &&std::is_convertible< typename IterableW::value_type, double >::value &&std::is_convertible< typename IterableZ::value_type, double >::value &&std::is_convertible< typename IterableM::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeW, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type hydra::spline3D ( IterableX &&  abscissa_x, IterableY &&  abscissa_y, IterableW &&  abscissa_w, IterableZ &&  abscissa_z, IterableM  measurements, TypeX  x, TypeX  y, TypeW  w, TypeZ  z  )

inline

spline4D()

template<typename IteratorX , typename IteratorY , typename IteratorW , typename IteratorZ , typename IteratorM , typename TypeX , typename TypeY , typename TypeW , typename TypeZ >

__hydra_host__ __hydra_device__ std::enable_if< std::is_convertible< typename hydra::thrust::iterator_traits< IteratorX >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorY >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorW >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorZ >::value_type, double >::value &&std::is_convertible< typename hydra::thrust::iterator_traits< IteratorM >::value_type, double >::value &&std::is_convertible< TypeX, double >::value &&std::is_convertible< TypeY, double >::value &&std::is_convertible< TypeW, double >::value &&std::is_convertible< TypeZ, double >::value, double >::type hydra::spline4D ( IteratorX  firstx, IteratorX  lastx, IteratorY  firsty, IteratorY  lasty, IteratorW  firstw, IteratorW  lastw, IteratorZ  firstz, IteratorZ  lastz, IteratorM  measurements, TypeX  x, TypeY  y, TypeW  w, TypeZ  z  )

inline

sqrt()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::sqrt

(

const complex< T > &

z

)

Examples:

adaptive_gauss_kronrod.inl, binned_extended_logLL_fit.inl, dense_histogram.inl, extended_logLL_fit.inl, fit_convoluted_pdfs.inl, gauss_kronrod.inl, multidimensional_fit.inl, phsp_chain.inl, plain_mc.inl, range_semantics.inl, splot.inl, and vegas.inl.

stream_array_helper() [1/2]

template<size_t N, typename T , size_t I>

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

inline

array streamer helper

stream_array_helper() [2/2]

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

std::enable_if< (I < N), void>::type hydra::stream_array_helper ( std::ostream &  os, std::array< T, N > const &  obj  )

inline

stream_tuple_helper() [1/2]

template<size_t I, typename ... T>

std::enable_if<(I==sizeof ...(T)), void>::type hydra::stream_tuple_helper ( std::ostream &  , std::tuple< T... > const &    )

inline

tuple streamer helper

stream_tuple_helper() [2/2]

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

std::enable_if< (I < sizeof ...(T)), void>::type hydra::stream_tuple_helper ( std::ostream &  os, std::tuple< T... > const &  obj  )

inline

sum()

template<typename F1 , typename F2 , typename ... Fs>

std::enable_if<(detail::is_hydra_functor<F1>::value || detail::is_hydra_lambda<F1>::value ) &&(detail::is_hydra_functor<F2>::value || detail::is_hydra_lambda<F2>::value ) &&detail::all_true<(detail::is_hydra_functor<Fs>::value || detail::is_hydra_lambda<Fs>::value )...>::value,Sum<F1, F2,Fs...> >::type hydra::sum ( F1 const &  f1, F2 const &  f2, Fs const &...  functors  )

inline

swap() [1/2]

__hydra_host__ __hydra_device__ void hydra::swap ( Vector3R &  v1, Vector3R &  v2  )

inline

swap() [2/2]

__hydra_host__ __hydra_device__ void hydra::swap ( Vector4R &  v1, Vector4R &  v2  )

inline

tan()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::tan

(

const complex< T > &

z

)

Examples:

pseudo_experiment.inl.

tanh()

template<typename T >

__hydra_host__ __hydra_device__ complex<T> hydra::tanh

(

const complex< T > &

z

)

tie()

template<class ... T>

__hydra_host__ __hydra_device__ auto hydra::tie ( T &...  t ) -> decltype(hydra::thrust::tie(t...))

inline

This version of tie creates a new tuple whose elements are references which refers to this function's arguments.

Parameters

t	The objects to reference.

Returns

A tuple object with members which are references to t.

transform()

template<typename Iterable_Input , typename Iterable_Output , typename Functor , typename Iterator = decltype(std::declval<Iterable_Output>().begin())>

std::enable_if<hydra::detail::is_iterable<Iterable_Output>::value,Range<decltype(std::declval<Iterable_Output&>).begin())> >::type hydra::transform	(	Iterable_Input &&	iterable_input,
		Iterable_Output &&	iterable_output,
		Functor const &	unary_functor
	)

unweight() [1/2]

template<typename RNG , typename IteratorData , typename IteratorWeight >

std::enable_if<detail::random::is_iterator<IteratorData>::value && detail::random::is_iterator<IteratorWeight>::value,Range<IteratorData> >::type hydra::unweight	(	IteratorData	data_begin,
		IteratorData	data_end,
		IteratorWeight	weights_begin,
		double	max_pdf,
		size_t	rng_seed,
		size_t	rng_jump
	)

unweight() [2/2]

template<typename RNG , typename IterableData , typename IterableWeight >

std::enable_if<detail::random::is_iterable<IterableData>::value && detail::random::is_iterable<IterableWeight>::value,Range< decltype(std::declval<IterableData>).begin())> >::type hydra::unweight	(	IterableData &&	data,
		IterableWeight &&	weights,
		double	max_pdf,
		size_t	rng_seed,
		size_t	rng_jump
	)

wigner_d_matrix() [1/2]

template<typename T >

__hydra_host__ __hydra_device__ T hydra::wigner_d_matrix ( double  j, double  m, double  n, const T  theta  )

inline

wigner_d_matrix() [2/2]

__hydra_host__ __hydra_device__ double hydra::wigner_d_matrix ( unsigned  j, unsigned  m, unsigned  n, const double  theta  )

inline

wrap_lambda() [1/2]

template<typename LambdaType >

hydra::Lambda<LambdaType, 0> hydra::wrap_lambda

(

LambdaType const &

lambda

)

Examples:

adaptive_gauss_kronrod.inl, basic_fit_range_semantics.inl, dalitz_plot.C, dalitz_plot.inl, dense_histogram.inl, extended_logLL_fit.inl, fit_johnson.C, fractional_logLL_fit.inl, gauss_kronrod.inl, multidimensional_fit.inl, phsp_averaging_functor.inl, phsp_basic.inl, phsp_chain.inl, phsp_reweighting.inl, phsp_unweighting.inl, phsp_unweighting_functor.inl, plain_mc.inl, range_semantics.inl, sample_distribution.inl, splot.inl, and vegas.inl.

wrap_lambda() [2/2]

template<typename LambdaType , typename ... T>

std::enable_if<detail::all_true<std::is_same<T, hydra::Parameter>::value...>::value,hydra::Lambda<LambdaType, sizeof...(T)> >::type hydra::wrap_lambda	(	LambdaType const &	lambda,
		T const &...	parameters
	)

zip()

template<typename ... Iterables>

std::enable_if< detail::all_true< detail::is_iterable<Iterables>::value...>::value,Range< hydra::thrust::zip_iterator< decltype(hydra::thrust::make_tuple(std::declval<Iterables&>).begin()...))> > >::type hydra::zip

(

Iterables &&...

iterables

)

Examples:

booststrapping.inl, cufft.inl, fft.inl, and range_semantics.inl.

Variable Documentation

iterator_type

decltype( other.begin( placeholders::placeholder<I>{} )) typedef hydra::iterator_type

Initial value:

{

    constexpr size_t I = detail::index_in_tuple<Type, hydra::thrust::tuple<T...> >::value

kFalse

const GBool_t hydra::kFalse = false

kTrue

const GBool_t hydra::kTrue = true

PrintLevel

int hydra::PrintLevel = WARNING

sample

template<typename RNG = default_random_engine, typename Functor , typename Iterator >

std::enable_if<detail::random::is_callable<Functor>::value &&detail::random::is_iterable<Iterable>::value &&detail::is_tuple_type< decltype(*std::declval<Iterable>).begin())>::value ,Range< decltype(std::declval<Iterable>).begin())> >::type hydra::sample(Iterable &&output, typename Functor::argument_type const &min, typename Functor::argument_type const &max, Functor const &functor, size_t seed=0xb56c4feeef1b, size_t rng_jump=0)

Fill a range with numbers distributed according a user defined distribution.

Parameters

begin	beginning of the range storing the generated values
end	ending of the range storing the generated values
min	tuple of lower limits of sampling region
max	tuple of upper limits of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

range with the generated values

Parameters

output	range storing the generated values
min	tuple of lower limits of sampling region
max	tuple of upper limits of sampling region.
functor	distribution to be sampled
max_pdf	maximum pdf value for accept-reject method. If no value is set, the maximum value in the sample is used.
rng_seed	seed for the underlying pseudo-random number generator
rng_jump	sequence offset for the underlying pseudo-random number generator

Returns

output range with the generated values

Examples:

breit_wigner_plus_polynomial.inl, crystal_ball_plus_exponential.inl, dalitz_plot.C, dalitz_plot.inl, dense_histogram.inl, double_gaussian_plus_exponential.inl, fit_convoluted_pdfs.inl, gaussian_plus_argus.inl, and sample_distribution.inl.