| ►Nhydra | Generic policies definition |
| ►Ndetail | |
| ►Nconvolution | |
| C_delta | |
| C_traits | |
| C_traits< hydra::thrust::tuple< Functor, Kernel >, ArgType > | |
| CFunctorSampler | |
| CKernelSampler | |
| CMultiplyFFT | |
| CNormalizeFFT | |
| ►Ncufft | |
| C_Deleter | |
| C_PlanDestroyer | |
| C_PlanExecutor | |
| C_Planner | |
| ►Nfa_impl | |
| C_is_function_argument | |
| C_is_function_argument< hydra::thrust::device_reference< T >, hydra::thrust::void_t< typename T::function_argument_type > > | |
| C_is_function_argument< T, hydra::thrust::void_t< typename T::function_argument_type > > | |
| ►Nfftw | |
| C_Deleter | |
| C_PlanDestroyer | |
| C_PlanExecutor | |
| C_Planner | |
| ►Nimpl | |
| Cexact_signed_base_helper | |
| Cexact_signed_base_helper< sizeof(signed char) *CHAR_BIT > | |
| Cexact_unsigned_base_helper | |
| Cexact_unsigned_base_helper< sizeof(unsigned char) *CHAR_BIT > | |
| Cint_least_helper | |
| Cint_least_helper< 1 > | |
| Cint_least_helper< 2 > | |
| Cint_least_helper< 3 > | |
| Cint_least_helper< 4 > | |
| Cint_least_helper< 5 > | |
| Cuint_least_helper | |
| Cuint_least_helper< 1 > | |
| Cuint_least_helper< 2 > | |
| Cuint_least_helper< 3 > | |
| Cuint_least_helper< 4 > | |
| Cuint_least_helper< 5 > | |
| ►Nrandom | |
| Cis_callable | |
| Cis_iterable | |
| Cis_iterator | |
| Cis_matching_iterable | |
| ►Nrange | |
| CShift | |
| ►Nstuple_impl | |
| Cstripped_tuple_impl | |
| Cstripped_tuple_impl< hydra::tuple< T... >, hydra::tuple< > > | |
| Cstripped_tuple_impl< Tuple, hydra::tuple< Head, Tail... > > | |
| ►Ntuple_utility | |
| Cdo_tuple | |
| Cflat_tuple | |
| C_merge_and_renumber | |
| C_merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > > | |
| CAddPdfBase | |
| CAddPdfChecker | |
| CAddPdfFunctor | |
| CAddResultGenzMalikBoxes | |
| CAddStatsPHSP | |
| Call_true | |
| Call_true<> | |
| Cappend_to_type_seq | |
| Cappend_to_type_seq< T, TT< Ts... > > | |
| Care_base_of | |
| Care_base_of< Base, T > | |
| Care_iterables | |
| Care_iterators | |
| CAverageMother | |
| CAverageMothers | |
| CBackendPolicy | |
| CBackendPolicy< Backend::Cpp > | |
| CBackendPolicy< Backend::Cuda > | |
| CBackendPolicy< Backend::Device > | |
| CBackendPolicy< Backend::Host > | |
| CBackendPolicy< Backend::Omp > | |
| CBackendPolicy< Backend::Tbb > | |
| Cbool_pack | |
| ►CCanConvert | |
| CTo | |
| CCaster | |
| CCheckEnergy | |
| CCompareGenzMalikBoxes | |
| CCompareTuples | |
| CCompositeBase | |
| Cconditions_and | |
| Cconditions_and< Cond, Conds... > | |
| CCovMatrixBinary | |
| ►CCovMatrixUnary | |
| Cindex | |
| CDecayMother | |
| CDecayMothers | |
| Cdimensionality | |
| Cdivide_result | |
| CEvalMother | |
| CEvalMothers | |
| CEvalOnDaughters | |
| CEvalOnDaughtersBinary | |
| CFCNWeightsReducerUnary | |
| CFFTPolicy | |
| CFFTPolicy< T, detail::CuFFT > | |
| CFFTPolicy< T, detail::FFTW > | |
| Cfind_unique_type | |
| Cfind_unique_type_impl | |
| Cfind_unique_type_impl< I, T > | |
| Cfind_unique_type_impl< I, T, T, Types... > | |
| Cfind_unique_type_impl< I, T, U, Types... > | |
| CFlagAcceptReject | Flags generated events as accepted (1) or rejected (0) |
| CFlagDaugthers | |
| Cfunction_traits | |
| ►Cfunction_traits< ReturnType(ClassType::*)(Args &...)> | |
| Carg | |
| ►Cfunction_traits< ReturnType(ClassType::*)(Args...) const > | |
| Carg | |
| CFunctionArgument | |
| Cfunctor_traits | |
| Cfunctor_traits< ReturnType(ClassType::*)(Args...) > | |
| Cfunctor_traits< ReturnType(ClassType::*)(Args...) const > | |
| CGenerateDecay | |
| CGenzMalikBox | |
| CGenzMalikBoxResult | |
| CGetAxisBinCenter | |
| CGetBinCenter | |
| CGetBinCenter< T, 1 > | |
| CGetGlobalBin | |
| CGetGlobalBin< 1, T > | |
| CGetSWeight | |
| Cgray_code | |
| Chas_rng_formula | |
| Chas_rng_formula< Functor, hydra::thrust::void_t< typename hydra::RngFormula< Functor >::value_type > > | |
| Chigh_bit_mask_t | |
| Cif_then_else | |
| Cif_then_else< false, T1, T2 > | |
| Cif_then_else< true, T1, T2 > | |
| Cif_then_else_tt | |
| Cif_then_else_tt< false, T1, T2 > | |
| Cif_then_else_tt< true, T1, T2 > | |
| Cindex_in_tuple | |
| Cindex_in_tuple< Type, hydra::thrust::tuple< Head, Tail... > > | |
| Cindex_sequence | |
| Cint_fast_t | |
| Cint_t | |
| Cis_device_reference | |
| Cis_device_reference< hydra::thrust::device_reference< T > > | |
| Cis_function_argument | |
| Cis_function_argument< Arg, false > | |
| Cis_function_argument< Arg, true > | |
| Cis_function_argument< hydra::thrust::device_reference< Arg >, true > | |
| Cis_function_argument_pack | |
| Cis_homogeneous | |
| Cis_homogeneous_base | |
| Cis_homogeneous_base< A, Tp, 0 > | |
| Cis_hydra_composite_functor | |
| Cis_hydra_composite_functor< T, hydra::thrust::void_t< typename T::hydra_composed_functor_type > > | |
| Cis_hydra_convertible_to_tuple | |
| Cis_hydra_convertible_to_tuple< T, typename tag_type< typename T::hydra_convertible_to_tuple_tag >::type > | |
| Cis_hydra_dense_histogram | |
| Cis_hydra_dense_histogram< hydra::DenseHistogram< T, N, detail::BackendPolicy< BACKEND >, D > > | |
| Cis_hydra_estimator | |
| Cis_hydra_estimator< T, hydra::thrust::void_t< typename T::likelihood_estimator_type > > | |
| Cis_hydra_functor | |
| Cis_hydra_functor< Functor, hydra::thrust::void_t< typename Functor::hydra_functor_type, typename Functor::argument_type, typename Functor::return_type > > | |
| Cis_hydra_integrator | |
| Cis_hydra_integrator< T, hydra::thrust::void_t< typename T::hydra_integrator_type > > | |
| Cis_hydra_lambda | |
| Cis_hydra_lambda< Functor, hydra::thrust::void_t< typename Functor::hydra_lambda_type, typename Functor::argument_type, typename Functor::return_type > > | |
| Cis_hydra_pdf | |
| Cis_hydra_pdf< T, hydra::thrust::void_t< typename T::hydra_pdf_type > > | |
| Cis_hydra_sparse_histogram | |
| Cis_hydra_sparse_histogram< hydra::SparseHistogram< T, N, detail::BackendPolicy< BACKEND >, D > > | |
| Cis_hydra_sum_pdf | |
| Cis_hydra_sum_pdf< T, typename tag_type< typename T::hydra_sum_pdf_tag >::type > | |
| Cis_instantiation_of | |
| Cis_instantiation_of< Template, Template< Args... > > | |
| Cis_intuple | |
| Cis_intuple< T, hydra::tuple< Head, Tail... > > | |
| Cis_intuple< T, hydra::tuple<> > | |
| Cis_iterable | |
| Cis_iterable< T, hydra::thrust::void_t< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end()), decltype(++std::declval< decltype(hydra::begin(std::declval< T >()))& >()), decltype(*hydra::begin(std::declval< T >())) > > | |
| Cis_iterator | |
| Cis_iterator< T, hydra::thrust::void_t< typename std::enable_if< std::is_default_constructible< T >::value, void >::type, typename std::enable_if< std::is_copy_constructible< T >::value, void >::type, typename std::enable_if< std::is_destructible< T >::value, void >::type, decltype(std::declval< T & >()[0]), decltype(std::declval< T & >() -std::declval< T & >()), decltype(++std::declval< T & >()), decltype(*std::declval< T & >()), decltype(std::declval< T & >()==std::declval< T & >()), decltype(std::declval< T & >() !=std::declval< T & >())> > | |
| Cis_reverse_iterable | |
| Cis_reverse_iterable< T, hydra::thrust::void_t< decltype(std::declval< T >().rbegin()), decltype(std::declval< T >().rend()), decltype(++std::declval< decltype(hydra::rbegin(std::declval< T >()))& >()), decltype(*hydra::rbegin(std::declval< T >())) > > | |
| Cis_rng_formula | |
| Cis_rng_formula< hydra::RngFormula< Formula > > | |
| Cis_specialization | |
| Cis_specialization< REF< Args... >, REF > | |
| Cis_tuple | |
| Cis_tuple< hydra::tuple< T... > > | |
| Cis_tuple_of_function_arguments | |
| Cis_tuple_of_function_arguments< hydra::thrust::detail::tuple_of_iterator_references< ArgTypes &... > > | |
| Cis_tuple_of_function_arguments< hydra::thrust::detail::tuple_of_iterator_references< hydra::thrust::device_reference< ArgTypes >... > > | |
| Cis_tuple_of_function_arguments< hydra::thrust::tuple< ArgTypes... > > | |
| Cis_tuple_type | |
| Cis_tuple_type< hydra::thrust::detail::tuple_of_iterator_references< ArgTypes... > > | |
| Cis_tuple_type< hydra::thrust::tuple< ArgTypes... > > | |
| Cis_valid_type_pack | |
| Cis_valid_type_pack< hydra::thrust::tuple< RefT... >, T... > | |
| Cis_zip_iterator | |
| Cis_zip_iterator< hydra::thrust::zip_iterator< T... > > | |
| CisAccepted | |
| CIteratorTraits | |
| Clambda_traits | |
| CLogLikelihood1 | |
| CLogLikelihood2 | |
| Clow_bits_mask_t | |
| Clow_bits_mask_t< std::numeric_limits< unsigned char >::digits > | |
| Cmake_index_sequence | |
| Cmake_index_sequence< 0 > | |
| Cmake_index_sequence< 1 > | |
| Cmerged_tuple | |
| Cmerged_tuple< hydra::tuple< T... > > | |
| Cmerged_tuple< hydra::tuple< T... >, hydra::tuple< U... > > | |
| Cmerged_tuple< hydra::tuple< T... >, hydra::tuple< U... >, Z... > | |
| Cmerged_zip_iterator | |
| Cmerged_zip_iterator< hydra::thrust::zip_iterator< T... > > | |
| Cmerged_zip_iterator< hydra::thrust::zip_iterator< T... >, hydra::thrust::zip_iterator< U... > > | |
| Cmerged_zip_iterator< hydra::thrust::zip_iterator< T... >, hydra::thrust::zip_iterator< U... >, Z... > | |
| Cminus_result | |
| Cmultidimensional | |
| Cmultiply_result | |
| Cnearest_int | Round to nearest integer at compile time |
| CObjSelector | |
| CObjSelector< false > | |
| CObjSelector< true > | |
| CParameters | |
| CParameters< 0 > | Specialization for no-parametrized functor |
| CParametersCompositeFunctor | |
| Cpower | |
| Cpower< B, 0 > | |
| CProcessBoxesVegas | |
| CProcessCallsPlainBinary | |
| CProcessCallsPlainUnary | |
| CProcessCallsVegas | |
| CProcessCallsVegas< FUNCTOR, NDimensions, hydra::detail::BackendPolicy< BACKEND >, IteratorBackendReal, IteratorBackendUInt, GRND > | |
| CProcessGenzMalikBinaryCall | |
| CProcessGenzMalikBox | |
| CProcessGenzMalikUnaryCall | |
| Cquasi_random_base | |
| Crandom_traits | |
| Crandom_traits< hydra_r123::Philox2x64 > | |
| Crandom_traits< hydra_r123::Philox4x64 > | |
| Crandom_traits< hydra_r123::Threefry2x64 > | |
| Crandom_traits< hydra_r123::Threefry4x64 > | |
| Creferences_tuple_type | |
| Cremove_device_reference | |
| Cremove_device_reference< hydra::thrust::device_reference< T > > | |
| Cremove_device_reference< T & > | |
| Crepeat | |
| Crepeat< T, 0, TT > | |
| CResultPHSP | |
| CResultVegas | |
| CRndBreitWigner | |
| CRndCDF | |
| CRndExp | |
| CRndFlag | |
| CRndGauss | |
| CRndTrial | |
| CRndTrial< T, GRND, FUNCTOR, 1 > | |
| CRndUniform | |
| CSampler | |
| Cselected_tuple | |
| Cselected_tuple< Selector, hydra::tuple< Head, Tail... > > | |
| Cselected_tuple< Selector, hydra::tuple< Type > > | |
| Csignature_traits | |
| Csignature_traits< hydra::thrust::tuple< R, Args... > > | |
| Csignature_traits< R(Args...)> | |
| Csignature_type | |
| Csignature_type_impl | |
| Csobol_lattice | |
| CSobolTable | |
| CStatsPHSP | |
| Cstripped_tuple | |
| Cstripped_tuple< hydra::tuple< T... > > | |
| Cstripped_type | |
| Cstripped_type< Arg, false > | |
| Cstripped_type< Arg, true > | |
| Csum_result | |
| CSWeights | |
| Ctag_type | |
| Ctrimmed_lambda_signature | |
| Ctrimmed_lambda_signature< hydra::thrust::tuple< Head, Neck, Tail... > > | |
| Ctuple_cat_type | |
| Ctuple_cat_type< hydra::thrust::detail::tuple_of_iterator_references< T1... >, hydra::thrust::detail::tuple_of_iterator_references< T2... > > | |
| Ctuple_cat_type< hydra::thrust::tuple< T1... >, hydra::thrust::tuple< T2... > > | |
| Ctuple_type | |
| CTypeTraits | |
| CTypeTraits< hydra::thrust::complex< T > > | |
| Cuint_t | |
| Cunidimensional | |
| ►Nplaceholders | |
| Cis_placeholder | |
| Cis_placeholder< placeholder< I > > | |
| Cplaceholder | |
| ►Nrandom | |
| CEngineR123 | |
| Csquares3 | |
| Csquares4 | |
| CAnalyticalIntegral | |
| CAnalyticalIntegral< Functor, 1 > | |
| CArgument | |
| CArgusShape | Implementation describing the ARGUS background shape |
| CBaseCompositeFunctor | |
| CBaseCompositeFunctor< Composite, hydra::thrust::tuple< F1, F2, Fs... >, Signature > | |
| CBaseCuFFT | |
| CBaseFFTW | |
| CBaseFunctor | Base class for all functors in hydra |
| CBifurcatedGaussian | |
| CBreitWignerLineShape | 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 |
| CBreitWignerNR | |
| CChebychev | 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 |
| CChiSquare | 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 |
| CComplexToComplexCuFFT | |
| CComplexToComplexFFTW | |
| CComplexToRealCuFFT | |
| CComplexToRealFFTW | |
| CCompose | |
| CConstant | |
| CConvolutionFunctor | |
| CConvolutionFunctor< Functor, Kernel, detail::BackendPolicy< BACKEND >, detail::FFTPolicy< typename std::common_type< typename Functor::return_type, typename Kernel::return_type >::type, FFT >, ArgType > | |
| CCosHelicityAngle | |
| CCrystalBallShape | Implementation the Crystal Ball line shape |
| CCubicSpiline |
A simple method for a one—dimensional interpolation on a given set of data points (xi, yi) |
| CDecays | |
| CDecays< hydra::tuple< Particles... >, hydra::detail::BackendPolicy< Backend > > | This class provides storage for N-particle states |
| CDeltaDMassBackground | |
| CDenseHistogram | |
| CDenseHistogram< T, 1, hydra::detail::BackendPolicy< BACKEND >, detail::unidimensional > | Class representing one-dimensional dense histogram |
| CDenseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > | Class representing multidimensional dense histograms |
| CDistribution | |
| CDistribution< Class, false > | |
| CDistribution< Functor, true > | |
| CDivide | |
| CDoubleExponential | Distribution https://en.wikipedia.org/wiki/Laplace_distribution |
| CExponential | Https://en.wikipedia.org/wiki/Exponential_function |
| CFCN | FCN base class |
| CFCN< Estimator< PDF, Iterator >, true > | |
| CFCN< Estimator< PDF, Iterator, Iterators... >, true > | |
| CFCN< hydra::thrust::tuple< FCN< ESTIMATORS >... >, false > | |
| CGaussian |
Gaussian functions are often used to represent the probability density function of a normally distributed random variable with expected value \( \mu \) and variance \( \sigma \) |
| ►CGaussianKDE | |
| CKernel | |
| CGaussKronrodAdaptiveQuadrature | |
| CGaussKronrodAdaptiveQuadrature< NRULE, NBIN, hydra::detail::BackendPolicy< BACKEND > > | |
| CGaussKronrodBinary | |
| CGaussKronrodCall | |
| CGaussKronrodQuadrature | |
| CGaussKronrodQuadrature< NRULE, NBIN, hydra::detail::BackendPolicy< BACKEND > > | |
| CGaussKronrodRule | Rules for Gauss-Kronrod quadrature |
| CGaussKronrodRuleSelector | |
| CGaussKronrodRuleSelector< 15 > | Rules for Gauss-Kronrod quadrature |
| CGaussKronrodRuleSelector< 21 > | Rules for Gauss-Kronrod quadrature |
| CGaussKronrodRuleSelector< 31 > | Rules for Gauss-Kronrod quadrature |
| CGaussKronrodRuleSelector< 41 > | Rules for Gauss-Kronrod quadrature |
| CGaussKronrodRuleSelector< 51 > | Rules for Gauss-Kronrod quadrature |
| CGaussKronrodRuleSelector< 61 > | Rules for Gauss-Kronrod quadrature |
| CGaussKronrodUnary | |
| CGenzMalikQuadrature | |
| CGenzMalikQuadrature< N, hydra::detail::BackendPolicy< BACKEND > > | Non-adaptive Genz-Malik multidimensional quadrature |
| CGenzMalikRule | |
| CGenzMalikRule< DIM, hydra::detail::BackendPolicy< BACKEND > > | Class representing Genz-Malik rule |
| CGenzMalikRuleBase | |
| CIntegral | |
| CIntegral< Algorithm, 1 > | |
| CIntegrationFormula | |
| CIntegrationFormula< ArgusShape< ArgType >, 1 > | |
| CIntegrationFormula< BifurcatedGaussian< ArgType >, 1 > | |
| CIntegrationFormula< BreitWignerNR< ArgType >, 1 > | |
| CIntegrationFormula< Chebychev< Order, ArgType >, 1 > | |
| CIntegrationFormula< ChiSquare< ArgType >, 1 > | |
| CIntegrationFormula< CrystalBallShape< ArgType >, 1 > | |
| CIntegrationFormula< DeltaDMassBackground< ArgType >, 1 > | |
| CIntegrationFormula< DoubleExponential< ArgType >, 2 > | |
| CIntegrationFormula< Exponential< ArgType >, 1 > | |
| CIntegrationFormula< Gaussian< ArgType >, 1 > | |
| CIntegrationFormula< Ipatia< ArgType >, 1 > | |
| CIntegrationFormula< JohnsonSU< ArgType >, 1 > | |
| CIntegrationFormula< LogNormal< ArgType >, 1 > | |
| CIntegrationFormula< Polynomial< Order, ArgType >, 1 > | |
| CIntegrationFormula< TrapezoidalShape< ArgType >, 1 > | |
| CIntegrationFormula< TriangularShape< ArgType >, 1 > | |
| CIntegrationFormula< UniformShape< ArgType >, 1 > | |
| CIpatia | Version of the Ipatia distribution as described in the reference https://doi.org/10.1016/j.nima.2014.06.081 |
| CJohnsonSU | |
| CLambda | |
| CLambda< LambdaType, 0 > | |
| CLogLikelihoodFCN | |
| CLogLikelihoodFCN< Pdf< Functor, Integrator >, IteratorD, IteratorW... > | |
| CLogLikelihoodFCN< PDFSumExtendable< Pdfs... >, IteratorD, IteratorW... > | |
| CLogLikelihoodFCN< PDFSumNonExtendable< Pdfs... >, IteratorD, IteratorW... > | |
| CLogNormal | In probability theory, a log-normal (or lognormal) distribution is a continuous probability distribution of a random variable whose logarithm is normally distributed |
| CM12PhaseSpaceLineShape | Two-body phase-space distribution for \( m_{12}\):
\[ \frac{dN}{dm_{m_12}} \propto q.p \]
|
| CM12SqPhaseSpaceLineShape | Two-body phase-space distribution for \( m_{12}^2\):
\[ \frac{dN}{dm^2_{12}} \propto q.p/m^2_{12} \]
|
| CMinus | |
| Cmultiarray | |
| Cmultiarray< T, N, hydra::detail::BackendPolicy< BACKEND > > | |
| CMultiply | |
| Cmultivector | |
| Cmultivector< hydra::thrust::tuple< T... >, hydra::detail::BackendPolicy< BACKEND > > | This class implements storage in SoA layouts for table where all elements have the same type |
| Cnull_type | |
| CNumericalIntegral | |
| CParameter |
, |
| CPdf | Class representing probability density functions |
| CPDFSumExtendable | Class representing a pdf object built summing up other pdfs |
| CPDFSumNonExtendable | Class representing a pdf object built summing a pdf adding other pdfs |
| CPhaseSpace | This class implements phase-space Monte Carlo generation in hydra |
| CPhaseSpaceIntegrator | |
| CPhaseSpaceIntegrator< N, hydra::detail::BackendPolicy< BACKEND >, GRND > | |
| CPhaseSpaceReweight | |
| CPhaseSpaceWeight | |
| CPlain | |
| CPlain< N, hydra::detail::BackendPolicy< BACKEND >, GRND > | This class implements the Plain MC numerical integration algorithm in Hydra |
| CPlainState | Simple structure to hold the results of the Plain MC numerical integration |
| CPlanesDeltaAngle | This functor calculates the delta angle between decay plane of the particle with four-vector d2 and d3 (same plane) and h1 (other plane) |
| CPolynomial |
From : https://en.wikipedia.org/wiki/Polynomial |
| CPrint | |
| CProcessGaussKronrodAdaptiveQuadrature | |
| CRange | |
| CRange< Iterator > | |
| CRange< Iterator, Functor > | |
| CRealToComplexCuFFT | |
| CRealToComplexFFTW | |
| CRngBase | |
| CRngFormula | |
| CRngFormula< BifurcatedGaussian< ArgType > > | |
| CRngFormula< BreitWignerNR< ArgType > > | |
| CRngFormula< ChiSquare< ArgType > > | |
| CRngFormula< Exponential< ArgType > > | |
| CRngFormula< Gaussian< ArgType > > | |
| CRngFormula< JohnsonSU< ArgType > > | |
| CRngFormula< LogNormal< ArgType > > | |
| CRngFormula< TrapezoidalShape< ArgType > > | |
| CRngFormula< TriangularShape< ArgType > > | |
| CRngFormula< UniformShape< ArgType > > | |
| CScopedBuffer | |
| CScopedBuffer< T, detail::BackendPolicy< BACKEND > > | |
| CSeedRNG | |
| Csobol_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)] |
| CSparseHistogram | |
| CSparseHistogram< T, 1, detail::BackendPolicy< BACKEND >, detail::unidimensional > | Class representing one-dimensional sparse histogram |
| CSparseHistogram< T, N, detail::BackendPolicy< BACKEND >, detail::multidimensional > | Class representing multidimensional sparse histogram |
| CSpline2DFunctor | |
| CSpline3DFunctor | |
| CSpline4DFunctor | |
| CSplineFunctor | |
| CSPlot | Implementation of {s}_{Plot} technique for statistical unfolding of sample containing events from different sources |
| CSum | |
| CThreeBodyMassThresholdBackground | |
| CTrapezoidalShape | In probability theory and statistics, the trapezoidal distribution is a continuous probability distribution the graph of whose probability density function resembles a trapezoid |
| CTriangularShape | From: https://en.wikipedia.org/wiki/Triangular_distribution |
| CUniformShape | From: https://en.wikipedia.org/wiki/Uniform_distribution_(continuous) |
| CUserParameters | Class implementing a interface to ROOT::Minuit2::MnUserParameters |
| CVegas | |
| CVegas< N, hydra::detail::BackendPolicy< BACKEND >, GRND > | Class to perform numerical integration using Vegas algorithm |
| CVegasState | Class to hold resources and state of hydra::Vegas integration algorithm |
| CVegasState< N, hydra::detail::BackendPolicy< BACKEND > > | Class to hold resources and state of hydra::Vegas integration algorithm |
| CWignerDMatrix | 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 |
| CZemachFunction | Zemach's angular probability distribution for 3-body decays of spinless particle into spinless final states as a function of \(\theta\), the helicity angle: |
| ►Nstd | STL namespace |
| Ccommon_type< hydra::thrust::complex< T >, hydra::thrust::complex< U > > | |
| Ccommon_type< hydra::thrust::complex< U >, T > | |
| Ccommon_type< T, hydra::thrust::complex< U > > | |
| CArgusShapeAnalyticalIntegral | Implementation of analytical integral for the ARGUS background shape with power = 0.5 |
| CBreitWignerNR | Non-relativistic Breit-Wigner shape |
| CCosTheta | This functor calculates the cosine of the helicity angle of the particle with four-vector D, which is daughter of the particle with four-vector Q and grand daughter of particle four-vector P |
| Cbinary_function | |
| Cdevice_execution_policy | |
| Cexecution_policy | |
| Chost_execution_policy | |
| Cunary_function | |
| CJohnsonSUShape | Implementation the JohnsonSU line shape |
| CLogLikelihoodFCN< PDFSumExtendable< Pdfs::::::> | ...> |
| CNonResonant | |
| CNorm | |
| Cparity | |
| Cparity< L, false > | |
| Cparity< L, true > | |
| CResonance | |
| CSpilineFunctor |
A simple method for a one—dimensional interpolation on a given set of data points (xi, yi) |
1.8.14 
