Processing math: 100%
Logo ROOT  
masterv6.34v6.32v6.30v6.28v6.26v6.22v6.20v6.18v6.16v6.14v6.12v6.10v6.08v6.06

Reference Guide
 
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345678910]
 CROOT::Detail::__integer_sequence< _IdxType, _Values >
 CROOT::Detail::__make< 0 >
 CROOT::Detail::__make< 1 >
 CROOT::Detail::__make< 2 >
 CROOT::Detail::__make< 3 >
 CROOT::Detail::__make< 4 >
 CROOT::Detail::__make< 5 >
 CROOT::Detail::__make< 6 >
 CROOT::Detail::__make< 7 >
 CROOT::Detail::__parity< _Np >
 CROOT::Detail::__parity< 0 >
 CROOT::Detail::__parity< 1 >
 CROOT::Detail::__parity< 2 >
 CROOT::Detail::__parity< 3 >
 CROOT::Detail::__parity< 4 >
 CROOT::Detail::__parity< 5 >
 CROOT::Detail::__parity< 6 >
 CROOT::Detail::__parity< 7 >
 CROOT::Detail::__repeat< _Tp, _Extra >
 CROOT::Detail::__repeat< __integer_sequence< _Tp, _Np... >, _Extra... >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 1 >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 2, _Np - 1 >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 3, _Np - 2, _Np - 1 >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
 ►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, N, M >Struct to do a Cholesky decomposition
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 0, M >Struct to do a Cholesky decomposition (specialized, N = 0)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 1, M >Struct to do a Cholesky decomposition (specialized, N = 1)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 2, M >Struct to do a Cholesky decomposition (specialized, N = 2)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 3, M >Struct to do a Cholesky decomposition (specialized, N = 3)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 4, M >Struct to do a Cholesky decomposition (specialized, N = 4)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 5, M >Struct to do a Cholesky decomposition (specialized, N = 5)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 6, M >Struct to do a Cholesky decomposition (specialized, N = 6)
 CROOT::Math::CholeskyDecompHelpers::_decomposerGenDim< F, M >Struct to do a Cholesky decomposition (general dimensionality)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, N, M >Struct to obtain the inverse from a Cholesky decomposition
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 0, M >Struct to obtain the inverse from a Cholesky decomposition (N = 0)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 1, M >Struct to obtain the inverse from a Cholesky decomposition (N = 1)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 2, M >Struct to obtain the inverse from a Cholesky decomposition (N = 2)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 3, M >Struct to obtain the inverse from a Cholesky decomposition (N = 3)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 4, M >Struct to obtain the inverse from a Cholesky decomposition (N = 4)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 5, M >Struct to obtain the inverse from a Cholesky decomposition (N = 5)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 6, M >Struct to obtain the inverse from a Cholesky decomposition (N = 6)
 CROOT::Math::CholeskyDecompHelpers::_inverterGenDim< F, M >Struct to obtain the inverse from a Cholesky decomposition (general dimensionality)
 C_root_std_complex< T >
 CROOT::Math::CholeskyDecompHelpers::_solver< F, N, V >Struct to solve a linear system using its Cholesky decomposition
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 0, V >Struct to solve a linear system using its Cholesky decomposition (N=0)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 1, V >Struct to solve a linear system using its Cholesky decomposition (N=1)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 2, V >Struct to solve a linear system using its Cholesky decomposition (N=2)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 3, V >Struct to solve a linear system using its Cholesky decomposition (N=3)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 4, V >Struct to solve a linear system using its Cholesky decomposition (N=4)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 5, V >Struct to solve a linear system using its Cholesky decomposition (N=5)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 6, V >Struct to solve a linear system using its Cholesky decomposition (N=6)
 CROOT::Math::CholeskyDecompHelpers::_solverGenDim< F, V >Struct to solve a linear system using its Cholesky decomposition (generalised dimensionality)
 C_x3d_data_
 C_x3d_sizeof_
 CROOT::Minuit2::ABObj< mtype, M, T >
 CROOT::Minuit2::ABObj< sym, LASymMatrix, double >
 CROOT::Minuit2::ABObj< vec, LAVector, double >
 CROOT::Minuit2::ABProd< M1, M2 >
 CROOT::Minuit2::ABSum< M1, M2 >
 CTMVA::AbsValue
 ►CROOT::option::Parser::Action
 CActiveRegion
 CROOT::Math::AddOp< T >Addition Operation Class
 CROOT::Math::AddPolicy< T, D1, D2, R1, R2 >Matrix addition policy
 CROOT::Math::AddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > >
 CROOT::Detail::TCollectionProxyInfo::Address< T >
 ►CROOT::Detail::TCollectionProxyInfo::Address< const Bool_t & >
 ►CROOT::Detail::TCollectionProxyInfo::Address< TYPENAME T::const_reference >
 CROOT::Minuit2::AlgebraicProdType< A, B >
 CROOT::Minuit2::AlgebraicProdType< gen, gen >
 CROOT::Minuit2::AlgebraicProdType< gen, sym >
 CROOT::Minuit2::AlgebraicProdType< gen, vec >
 CROOT::Minuit2::AlgebraicProdType< sym, gen >
 CROOT::Minuit2::AlgebraicProdType< sym, sym >
 CROOT::Minuit2::AlgebraicProdType< sym, vec >
 CROOT::Minuit2::AlgebraicProdType< T, T >
 CROOT::Minuit2::AlgebraicProdType< vec, gen >
 CROOT::Minuit2::AlgebraicProdType< vec, sym >
 CROOT::Minuit2::AlgebraicSumType< A, B >
 CROOT::Minuit2::AlgebraicSumType< gen, vec >
 CROOT::Minuit2::AlgebraicSumType< sym, vec >
 CROOT::Minuit2::AlgebraicSumType< T, T >
 CROOT::Minuit2::AlgebraicSumType< vec, gen >
 CROOT::Minuit2::AlgebraicSumType< vec, sym >
 CRooAbsCachedPdf::AnaIntConfigRegistry for analytical integration codes
 CRooMultiVarGaussian::AnaIntData
 CRScanner::AnnotatedNamespaceDecl
 CROOT::TMetaUtils::AnnotatedRecordDecl
 CMemPoolForRooSets< RooSet_t, POOLSIZE >::Arena
 ►CROOT::option::ArgFunctions for checking the validity of option arguments
 ►Cstd::array< double, DIMENSIONS >
 CRooStats::HistFactory::AsimovTODO Here, we are missing some documentation
 CROOT::Math::Assign< T, D1, D2, A, R1, R2 >Structure to assign from an expression based to general matrix to general matrix
 CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Dummy Structure which flags an error to avoid assigment from expression based on a general matrix to a symmetric matrix
 CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >Structure to assign from an expression based to symmetric matrix to symmetric matrix
 CROOT::Math::AssignItr< T, D1, D2, R >Structure for assignment to a general matrix from iterator
 CROOT::Math::AssignItr< T, D1, D2, MatRepSym< T, D1 > >Specialized structure for assignment to a symmetrix matrix from iterator
 CROOT::Math::AssignSymForce Expression evaluation from general to symmetric
 CTExMap::Assoc_t
 CXMLReader::Attributes
 CROOT::MacOSX::Util::AutoreleasePool
 CROOT::Math::AxisAngleAxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis
 CROOT::Experimental::Internal::AxisConfigToType< EKind >Converts a RAxisConfig of whatever kind to the corresponding RAxisBase-derived object
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kEquidistant >
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kGrow >
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kIrregular >
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kLabels >
 CBalancerInfo
 CRooStats::HistFactory::RooBarlowBeestonLL::BarlowCache
 ►CBaseCounterT
 ►CROOT::Math::BaseIntegratorOptionsBase class for Numerical integration options common in 1D and multi-dimension This is an internal class and is not supposed to be instantiated by the user
 ►CROOT::Math::KDTree< _DataPoint >::BaseNode
 ►CBaseSelectionRule
 Cbasic_string_view< _CharT, _Traits >
 CROOT::Minuit2::BasicFunctionGradient
 CROOT::Minuit2::BasicFunctionMinimumResult of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum
 CBasicGRULayerGeneric implementation
 CBasicLSTMLayerGeneric implementation
 CROOT::Minuit2::BasicMinimumErrorInternal Class containing the error information on the estimated minimum : Error matrix + dcovar + additional flags for quality and validity checks
 CROOT::Minuit2::BasicMinimumParameters
 CROOT::Minuit2::BasicMinimumSeed
 CROOT::Minuit2::BasicMinimumState
 CBasicRNNLayerGeneric implementation
 CTTreePerfStats::BasketInfo
 CTMVA::DNN::BatchEncapsulates one mini-batch
 CBatchInterfaceAccessorHelper class to access a batch-related part of RooAbsReal's interface, which should not leak to the outside world
 CTMVA::BDTEventWrapper
 CRooStats::BernsteinCorrectionBernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term
 CROOT::Minuit2::BFGSMinimizerType
 CROOT::Minuit2::VariableMetricMinimizer::BFGSType
 CBidirMMapPipeBidirMMapPipe creates a bidirectional channel between the current process and a child it forks
 ►Cstd::binary_function
 CROOT::Math::BinaryOp< Operator, LHS, RHS, T >BinaryOperation class A class representing binary operators in the parse tree
 CROOT::Math::BinaryOpCopyL< Operator, LHS, RHS, T >Binary Operation class with value storage for the left argument
 CROOT::Math::BinaryOpCopyR< Operator, LHS, RHS, T >Binary Operation class with value storage for the right argument
 CBinaryOpPolicy
 ►CTMVA::BinaryTreeBase class for BinarySearch and Decision Trees
 CROOT::R::TRDataFrame::Binding
 CROOT::R::TRInterface::Binding
 CTMVA::OptionMap::Binding
 CBinomialNeymanInterval< Sorter >
 ►CBinomialNeymanInterval< FeldmanCousinsSorter >
 CBinomialProbHelper
 CRooMultiVarGaussian::BitBlock
 CROOT::Math::GenVector_detail::BitReproducible
 CROOT::Experimental::RStyle::Block_t
 CTEveParamList::BoolConfig_t
 CROOT::Math::BoostLorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix
 CROOT::Math::BoostXClass representing a Lorentz Boost along the X axis, by beta
 CROOT::Math::BoostYClass representing a Lorentz Boost along the Y axis, by beta
 CROOT::Math::BoostZClass representing a Lorentz Boost along the Z axis, by beta
 CRgl::Pad::BoundingRect< ValueType >
 CROOT::Experimental::RPadBase::BoundKindAndValueSimple struct representing an axis bound
 CRooNDKeysPdf::BoxInfo
 CRooBatchCompute::BracketAdapter< T >Little adapter that gives a bracket operator to types that don't have one
 CRooBatchCompute::BracketAdapterWithMask
 CTMVA::Experimental::BranchlessTree< T >Branchless representation of a decision tree using topological ordering
 CTGeoBatemanSol::BtCoef_t
 ►CRooSimWSTool::BuildConfig
 CCachedVertex
 CROOT::Detail::CallableTraitsImpl< T, HasCallOp >Extract types from the signature of a callable object. See CallableTraits
 CROOT::Detail::CallableTraitsImpl< R(*)(Args...), false >
 CROOT::Detail::CallableTraitsImpl< R(Args...), false >
 CROOT::Detail::CallableTraitsImpl< R(T::*)(Args...) const, false >
 CROOT::Detail::CallableTraitsImpl< R(T::*)(Args...), false >
 CROOT::Detail::CallableTraitsImpl< T, true >
 CCPyCppyy::CallContext
 CTInterpreter::CallFuncIFacePtr_t
 CROOT::Math::Cartesian2D< T >Class describing a 2D cartesian coordinate system (x, y coordinates)
 CROOT::Math::Cartesian3D< T >Class describing a 3D cartesian coordinate system (x, y, z coordinates)
 CROOT::Math::Cartesian3D< double >
 CROOT::Math::Cartesian3D< Scalar >
 CRooVectorDataStore::CatVector
 CTMVA::CCPrunerA helper class to prune a decision tree using the Cost Complexity method (see Classification and Regression Trees by Leo Breiman et al)
 CTMVA::CCTreeWrapper
 CTFITSHDU::Cell
 CTEveCaloLegoGL::Cell2D_t
 ►CROOT::Experimental::REveCaloData::CellGeom_t
 ►CTEveCaloData::CellGeom_tCell geometry inner structure
 CROOT::Experimental::REveCaloData::CellId_t
 CTEveCaloData::CellId_t
 CROOT::MacOSX::Util::CFScopeGuard< RefType >
 CROOT::MacOSX::Util::CFScopeGuard< CGContextRef >
 CROOT::MacOSX::Util::CFScopeGuard< CGImageRef >
 CROOT::MacOSX::Util::CFStrongReference< RefType >
 CROOT::Quartz::CGAAStateGuard
 CROOT::Quartz::CGStateGuard
 CRooStats::HistFactory::ChannelThis class encapsulates all information for the statistical interpretation of one experiment
 CTCling::CharPtrCmp_t
 CROOT::Math::ChebyshevApproxClass describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials
 CROOT::Math::ChebyshevPol
 CROOT::Math::CholeskyDecomp< F, N >Class to compute the Cholesky decomposition of a matrix
 CROOT::Math::CholeskyDecompGenDim< F >Class to compute the Cholesky decomposition of a matrix
 CROOT::Math::CholInverter< idim >
 ►CRcpp::class_
 CROOT::Meta::Selection::ClassAttributes< classAttributes >Used to specify attributes of classes in the "DictSelection" syntax
 CRooWorkspace::CodeRepo::ClassFiles
 CClassificationClass to perform two class classification
 CClassificationResultClass to save the results of the classifier
 CTMVA::ClassifierFactoryThis is the MVA factory
 CRooWorkspace::CodeRepo::ClassRelInfo
 CROOT::Internal::TThreadedObjectUtils::Cloner< T, isCopyConstructible >Return a copy of the object or a "Clone" if the copy constructor is not implemented
 CROOT::Internal::TThreadedObjectUtils::Cloner< T, false >
 CXrdClientConnectionMgr::CndVarInfo
 CROOT::MacOSX::Details::CocoaPrivate
 CROOT::MacOSX::X11::ColorParser
 CColorStruct_t
 CTFITSHDU::Column
 ►CROOT::MacOSX::X11::Command
 CROOT::MacOSX::X11::CommandBuffer
 CCompareAsc< T >
 CcompareBAasc
 CcompareBAdesc
 CROOT::TMetaUtils::AnnotatedRecordDecl::CompareByName
 CCompareDesc< T >
 CTTreeCloner::CompareEntry
 CROOT::Math::KDTree< _DataPoint >::ComparePoints
 CTTreeCloner::CompareSeek
 CROOT::Math::CompileTimeChecker< bool >
 CROOT::Math::CompileTimeChecker< false >
 CTMVA::Experimental::Internal::ComputeHelper< I, T, F >Compute helper
 CTMVA::ConfigSingleton class for global configuration settings used by TMVA
 CRooStats::HistFactory::ConfigParserTODO Add documentation
 CROOT::Experimental::REveManager::Conn
 CROOT::Math::Constant< T >Constant expression class A class representing constant expressions (literals) in the parse tree
 CContDistFree functions adapter needed by UNURAN for onedimensional continuous distributions
 CROOT::Minuit2::ContoursError
 ►CTMVA::ConvergenceTestCheck for convergence
 ►CCPyCppyy::Converter
 CROOT::Experimental::RPadLength::CoordSysBase< DERIVED >
 ►CROOT::Experimental::RPadLength::CoordSysBase< Normal >
 ►CROOT::Experimental::RPadLength::CoordSysBase< Pixel >
 ►CROOT::Experimental::RPadLength::CoordSysBase< User >
 CCPyCppyy::CPPDataMember
 CCPyCppyy::CPPExcInstance
 CCPyCppyy::CPPInstance
 CCPyCppyy::CPPOverload
 ►CCPyCppyy::CPPScope
 CCPPYY_G__p2p
 CCPPYY_G__value
 CCpuInfo_t
 ►CROOT::Experimental::RWebDisplayHandle::Creator!< page content
 CROOT::Minuit2::MnCross::CrossFcnLimit
 CROOT::Minuit2::MnCross::CrossNewMin
 CROOT::Minuit2::MnCross::CrossParLimit
 CTMVA::CrossValidationFoldResult
 CTMVA::CrossValidationResultClass to save the results of cross validation, the metric for the classification ins ROC and you can ROC curves ROC integrals, ROC average and ROC standard deviation
 CTMVA::DNN::CudaActivationDescriptor
 CTMVA::DNN::CudaConvolutionBwdDataAlgo
 CTMVA::DNN::CudaConvolutionBwdFilterAlgo
 CTMVA::DNN::CudaConvolutionDescriptor
 CTMVA::DNN::CudaConvolutionFwdAlgo
 CTMVA::DNN::CudaDataType
 CTMVA::DNN::CudaDropoutDescriptor
 CTMVA::DNN::CudaEmptyDescriptor
 CTMVA::DNN::CudaFilterDescriptor
 CTMVA::DNN::CudaPoolingDescriptor
 CROOT::Math::KDTree< _DataPoint >::Cut
 CTMVA::CvSplitKFoldsExpr
 CROOT::Math::Cylindrical3D< T >Class describing a cylindrical coordinate system based on rho, z and phi
 CROOT::Math::CylindricalEta3D< T >Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z
 CRooStats::HistFactory::Data
 CROOT::Fit::DataOptionsDataOptions : simple structure holding the options on how the data are filled
 CROOT::Fit::DataRangeClass describing the range in the coordinates it supports multiple range in a coordinate
 CROOT::Math::GenVector_detail::BitReproducible::DB8
 CClingMemberIterInternal::DCIterIteration over collected DeclContexts
 CDebuggingSamplerDebuggingSampler is a simple implementation of the DistributionCreator interface used for debugging
 CDebuggingTestStatDebuggingTestStat is a simple implementation of the DistributionCreator interface used for debugging
 CROOT::Math::DefaultCoordinateSystemTagDefaultCoordinateSystemTag Default tag for identifying any coordinate system
 CROOT::Math::Delaunay2DClass to generate a Delaunay triangulation of a 2D set of points
 CRScanner::DelayedAnnotatedRecordDeclInfo
 CTMVA::DeleteFunctor_t< T >
 CROOT::Math::DerivatorClass for computing numerical derivative of a function
 ►CDerivFunType
 CROOT::option::DescriptorDescribes an option, its help text (usage) and how it should be parsed
 CROOT::Internal::TThreadedObjectUtils::Detacher< T, ISHISTO >
 CROOT::Internal::TThreadedObjectUtils::Detacher< T, true >
 CRooStats::DetailedOutputAggregatorThis class is designed to aid in the construction of RooDataSets and RooArgSets, particularly those naturally arising in fitting operations
 CROOT::Math::Determinant< n, idim >Detrminant for a general squared matrix Function to compute the determinant from a square matrix ( \det(A)) of dimension idim and order n
 CDict
 CDictNode
 ►CROOT::Experimental::REveDigitSet::DigitBase_t
 ►CTEveDigitSet::DigitBase_t
 CRooMomentMorphFuncND::Digits< T >
 CROOT::Internal::TThreadedObjectUtils::DirCreator< T, ISHISTO >
 CROOT::Internal::TThreadedObjectUtils::DirCreator< T, true >
 CRooHelpers::DisableCachingRAIIDisable all caches for sub-branches in an expression tree
 CDiscrDistFree functions adapter needed by UNURAN for one-dimensional discrete distribution
 CROOT::Experimental::RPalette::Discrete_tTag type used to signal that the palette's colors should not be interpolated
 CCPyCppyy::DispatchPtr
 CROOT::Math::DisplacementVector2D< CoordSystem, Tag >Class describing a generic displacement vector in 2 dimensions
 CROOT::Math::DisplacementVector3D< CoordSystem, Tag >Class describing a generic displacement vector in 3 dimensions
 CROOT::Math::DisplacementVector3D< Cartesian3D< double >, DefaultCoordinateSystemTag >
 CROOT::Math::DisplacementVector3D< Cartesian3D< Scalar > >
 CROOT::Internal::RDF::DisplayHelper< T >
 ►CROOT::Math::DistSamplerInterface class for generic sampling of a distribution, i.e
 CROOT::Math::DistSamplerOptionsDistSampler options class
 CROOT::Math::DivOp< T >Division (element-wise) Operation Class
 CTHtml::DocEntityInfo_t
 CTHtml::DocSyntax_t
 CDoWork
 CTGLScene::DrawElement_t
 CRooPlot::DrawOpt
 CROOT::Internal::RootCling::DriverConfig
 CTMVA::DTNodeTrainingInfo
 CTMVA::DNN::DummyConvolutionBwdDataAlgo
 CTMVA::DNN::DummyConvolutionBwdFilterAlgo
 CTMVA::DNN::DummyConvolutionDescriptor
 CTMVA::DNN::DummyConvolutionFwdAlgo
 CTMVA::DNN::DummyCudaDataType
 CTMVA::DNN::DummyDataType
 CROOT::Fit::DummyDeleter< T >
 CTMVA::DNN::DummyDescriptor
 CTMVA::DNN::DummyDropoutDescriptor
 CTMVA::DNN::DummyEmptyDescriptor
 CTMVA::DNN::DummyFilterDescriptor
 CTMVA::DNN::DummyPoolingDescriptor
 CROOT::RCompressionSetting::EAlgorithm
 CEColumnTypeThe available trivial, native content types of a column
 CROOT::RCompressionSetting::EDefaults
 CROOT::Experimental::REveGeoPolyShape::Edge_t
 CTEveGeoPolyShape::Edge_t
 CTEvePolygonSetProjectedGL::Edge_t
 CEdgePair
 CTBranchSTL::ElementBranchHelper_t
 CROOT::RCompressionSetting::ELevel
 CEmptyCall
 ►Cstd::enable_shared_from_this
 CRooMappedCategory::Entry
 CTTreeCache::MissCache::Entry
 CENTupleContainerFormatDescribes the options for wrapping RNTuple data in files
 ►CROOT::Detail::TCollectionProxyInfo::EnvironBase
 CROOT::Math::gv_detail::ERROR_This_Rotation_Conversion_is_NOT_Supported
 CROOT::Math::EulerAnglesEulerAngles class describing rotation as three angles (Euler Angles)
 CRooAbsReal::EvalError
 CROOT::Fit::FitUtil::Evaluate< T >
 CROOT::Math::EvaluatorOneDim< MultiFuncType >
 CROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
 CTMVA::kNN::Event
 CEvent_tEvent structure
 CTMVA::QuickMVAProbEstimator::EventInfo
 CTMVA::DataSetFactory::EventStats
 CROOT::MacOSX::X11::EventTranslator
 ►CUi::ExampleWidget
 ►Cstd::exceptionSTL class
 CExceptionContext_t
 ►CCPyCppyy::Executor
 CTMVA::ExecutorBase Excutor class
 CRooExpensiveObjectCache::ExpensiveObject
 CROOT::Math::Expr< ExprType, T, D, D2, R1 >
 CRooWorkspace::CodeRepo::ExtraHeader
 CROOT::Math::Fabs< T >Unary abs Operation Class
 CROOT::Math::FactoryFactory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager
 CTMVA::DNN::TCpuBuffer< AFloat >::FakeIteratorBegin
 CROOT::Math::FastInverter< idim, n >Fast Matrix Inverter class Class to specialize calls to Dinv
 CROOT::Math::FastInverter< 3 >3x3 direct matrix inversion using Cramer Rule use only for FastInverter
 CROOT::Math::FastInverter< 4 >4x4 matrix inversion using Cramers rule
 CROOT::Math::FastInverter< 5 >5x5 Matrix inversion using Cramers rule
 CFeldmanCousinsSorter
 CFileStat_t
 CRgl::Pad::FillAttribSet
 CROOT::Fit::FitConfigClass describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class
 ►CROOT::Fit::FitDataBase class for all the fit data types: Stores the coordinates and the DataOptions
 ►CROOT::Fit::FitResultClass containg the result of the fit and all the related information (fitted parameter values, error, covariance matrix and minimizer result information) Contains a pointer also to the fitted (model) function, modified with the fit parameter values
 CROOT::Fit::FitterFitter class, entry point for performing all type of fits
 CTEveParamList::FloatConfig_t
 CFontAttributes_t
 CROOT::MacOSX::Details::FontCache
 CROOT::MacOSX::Details::FontCache::FontList
 CFontMetrics_t
 CTGFontDialog::FontProp_t
 CFoption_t
 CTMVA::Experimental::ForestBase< T, ForestType >Forest base class
 ►CTMVA::Experimental::ForestBase< T, std::function< void(const T *, const int, bool, T *)> >
 ►CTMVA::Experimental::ForestBase< T, std::vector< BranchlessTree< T > > >
 CFormatPdfTree
 CTLatex::FormSize_tTLatex helper struct holding the dimensions of a piece of text
 CROOT::Internal::FriendInfo
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F, T >
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *, T >
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *const, T >
 CTFitEditor::FuncParamData_tTF1Convolution object
 Cfuncptr_and_voidptr_t
 CROOT::Minuit2::FunctionGradient
 ►CROOT::Minuit2::FunctionMinimizerBase class for function minimizers; user may give FCN or FCN with Gradient, Parameter starting values and initial Error guess (sigma) (or "step size"), or Parameter starting values and initial covariance matrix; covariance matrix is stored in Upper triangular packed storage format, e.g
 CROOT::Minuit2::FunctionMinimumClass holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum
 CTClassEdit::FunctionSplitInfoResult of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
 ►CFunctionType
 CRooRandomizeParamMCSModule::GausParam
 CRooRandomizeParamMCSModule::GausParamSet
 CGcCache_t
 CGCValues_tGraphics context structure
 CROOT::Minuit2::gen
 CRooMultiVarGaussian::GenData
 CROOT::Math::GeneralLinearFunctionDerivation< T >Auxiliar class to bypass the (provisional) lack of vectorization in TFormula::EvalPar
 CROOT::Math::GeneralLinearFunctionDerivation< double >
 CROOT::Experimental::Internal::RVirtualCanvasPainter::Generator
 ►CROOT::Minuit2::GenericFunctionClass from which all the other classes, representing functions, inherit
 ►CGenericRooFIterInterface for RooFIter-compatible iterators
 CTMVA::GeneticAlgorithmBase definition for genetic algorithm
 CTMVA::GeneticGenesCut optimisation interface class for genetic algorithm
 CROOT::Math::GeneticMinimizerParameters
 CTMVA::GeneticPopulationPopulation definition for genetic algorithm
 CTMVA::GeneticRangeRange definition for genetic algorithm
 CRooAbsPdf::GenSpec
 CROOT::Internal::GetFunctorType< T >
 CROOT::Internal::GetFunctorType< T(F::*)(const T *, const double *) const >
 CROOT::Internal::GetFunctorType< T(F::*)(const T *, const double *)>
 CROOT::Internal::GetFunctorType< T(F::*)(T *, double *) const >
 CROOT::Internal::GetFunctorType< T(F::*)(T *, double *)>
 CTFormLeafInfo::GetValueHelper< T >
 CTLeaf::GetValueHelper< T >
 CTFormLeafInfo::GetValueHelper< Long64_t >
 CTLeaf::GetValueHelper< Long64_t >
 CTFormLeafInfo::GetValueHelper< LongDouble_t >
 CTLeaf::GetValueHelper< LongDouble_t >
 CTFormLeafInfo::GetValueHelper< ULong64_t >
 CTLeaf::GetValueHelper< ULong64_t >
 CRgl::Pad::GLLimits
 CROOT::Math::GlobalCoordinateSystemTagTag for identifying vectors based on a global coordinate system
 CRooAbsReal::GlobalSelectComponentRAII
 CGLUface
 CGLUhalfEdge
 CGLUmesh
 CGLUtesselator
 CGLUvertex
 CROOT::Math::GoFTest
 ►CROOT::Minuit2::GradientCalculatorInterface class for gradient calculators
 CGraphCreatorHelperHelper class that provides the operation graph nodes
 CROOT::Internal::RDF::GraphDrawing::GraphCreatorHelper
 CROOT::Internal::RDF::GraphDrawing::GraphNode
 CGraphNodeClass used to create the operation graph to be printed in the dot representation
 CRooMomentMorphND::Grid
 CRooMomentMorphFuncND::Grid2
 Cgroup
 CROOT::Experimental::RAxisConfig::Grow_tTag type signalling that an axis should be able to grow; used for calling the appropriate constructor
 CROOT::Math::GSL1DMinimizerWrapperWrapper class for gsl_min_fminimizer structure
 CROOT::Math::GSLChebSeriesWrapper class for C struct gsl_cheb_series
 CROOT::Math::GSLDerivatorClass for computing numerical derivative of a function based on the GSL numerical algorithm This class is implemented using the numerical derivatives algorithms provided by GSL (see GSL Online Manual )
 CROOT::Math::GSLFunctionAdapter< UserFunc >Class for adapting any C++ functor class to C function pointers used by GSL
 CROOT::Math::GSLFunctionDerivWrapperClass to wrap a gsl_function_fdf (with derivatives)
 CROOT::Math::GSLFunctionWrapperWrapper class to the gsl_function C structure
 CROOT::Math::GSLIntegrationWorkspace
 CROOT::Math::GSLInterpolatorInterpolation class based on GSL interpolation functions
 ►CROOT::Math::GSLMCIntegrationWorkspace
 CROOT::Math::GSLMonteFunctionAdapter< UserFunc >
 CROOT::Math::GSLMonteFunctionWrapperWrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm
 CROOT::Math::GSLMultiFitGSLMultiFit, internal class for implementing GSL non linear least square GSL fitting
 CROOT::Math::GSLMultiFitFunctionAdapter< FuncVector >Class for adapting a C++ functor class to C function pointers used by GSL MultiFit Algorithm The templated C++ function class must implement:
 CROOT::Math::GSLMultiFitFunctionWrapperWrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
 CROOT::Math::GSLMultiMinDerivFunctionWrapperWrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm
 CROOT::Math::GSLMultiMinFunctionAdapter< UserFunc >Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms
 CROOT::Math::GSLMultiMinFunctionWrapperWrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
 CROOT::Math::GSLMultiMinimizerGSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives
 ►CROOT::Math::GSLMultiRootBaseSolverGSLMultiRootBaseSolver, internal class for implementing GSL multi-root finders This is the base class for GSLMultiRootSolver (solver not using derivatives) and GSLMUltiRootDerivSolver (solver using derivatives)
 CROOT::Math::GSLMultiRootDerivFunctionWrapperWrapper to a multi-dim function with derivatives for multi roots algorithm
 CROOT::Math::GSLMultiRootFinderClass for Multidimensional root finding algorithms bassed on GSL
 CROOT::Math::GSLMultiRootFunctionAdapter< FuncVector >Class for adapting a C++ functor class to C function pointers used by GSL MultiRoot Algorithm The templated C++ function class must implement:
 CROOT::Math::GSLMultiRootFunctionWrapperWrapper to a multi-dim function without derivatives for multi roots algorithm
 CROOT::Math::GSLQRngWrapperGSLQRngWrapper class to wrap gsl_qrng structure
 ►CROOT::Math::GSLQuasiRandomEngineGSLQuasiRandomEngine Base class for all GSL quasi random engines, normally user instantiate the derived classes which creates internally the generator and uses the class ROOT::Math::QuasiRandom
 ►CROOT::Math::GSLRandomEngineGSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator
 CROOT::Math::GSLRngROOTWrapper< Engine >Class for wrapping ROOT Engines in gsl_rng types which can be used as extra GSL random number generators For this we need to implment functions which will be called by gsl_rng
 CROOT::Math::GSLRngWrapperGSLRngWrapper class to wrap gsl_rng structure
 CROOT::Math::GSLRootFdFSolverRoot-Finder with derivatives implementation class using GSL
 CROOT::Math::GSLRootFSolverRoot-Finder implementation class using GSL
 CROOT::Math::GSLSimAnFuncGSLSimAnFunc class description
 CROOT::Math::GSLSimAnnealingGSLSimAnnealing class for performing a simulated annealing search of a multidimensional function
 CROOT::Math::GSLSimAnParamsStructure holding the simulated annealing parameters
 CRooRandom::Guard
 CROOT::TypeTraits::HasBeginAndEnd< T >
 CROOT::Internal::RConcurrentHashColl::HashValue
 CTClingValue::HasTheSameSizeAsClingValue
 CTFITSHDU::HDURecord
 CROOT::Experimental::REveTrackPropagator::Helix_t
 CTEveTrackPropagator::Helix_t
 CHelperOps
 CHEPEVT_DEFHEPEVT common block
 CRooHelpers::HijackMessageStreamHijacks all messages with given level and topic (and optionally object name) while alive
 CRooStats::HistFactory::HistFactoryNavigation
 ►CRooStats::HistFactory::HistogramUncertaintyBase////////////////////////////////////////////////////////////////////////////////////////////Base class to store the up and down variations for histogram uncertainties
 CRooStats::HistFactory::HistRefInternal class wrapping an histogram and managing its content
 CHoption_tHistogram option structure
 CHparam_tHistogram parameters structure
 CTMVA::HyperParameterOptimisationResult
 ►CRooStats::HypoTestCalculatorHypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults
 ►CIBaseFunc
 ►CROOT::Math::IBaseFunctionMultiDimTempl< T >Documentation for the abstract class IBaseFunctionMultiDim
 ►CROOT::Math::IBaseFunctionMultiDimTempl< double >
 ►CROOT::Math::IBaseFunctionOneDimInterface (abstract class) for generic functions objects of one-dimension Provides a method to evaluate the function given a value (simple double) by implementing operator() (const double )
 ►CROOT::Math::IBaseParamDocumentation for the abstract class IBaseParam
 ►CRooFactoryWSTool::IFace
 ►CTMVA::IFitterTargetInterface for a fitter 'target'
 ►CROOT::Math::IGradientMultiDimTempl< T >Gradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function
 ►CROOT::Math::IGradientOneDimSpecialized Gradient interface(abstract class) for one dimensional functions It provides a method to evaluate the derivative of the function, Derivative and a method to evaluate at the same time the function and the derivative FdF
 ►CTMVA::IMethodInterface for all concrete MVA method implementations
 ►CROOT::Math::IMinimizer1DInterface class for numerical methods for one-dimensional minimization
 CBidirMMapPipe_impl::Pages::implImplementation
 ►CParentFunctor::Impl
 CTMVA::Increment< T >
 ►CCPyCppyy::indexiterobject
 CROOT::Detail::indices< Indices >
 CROOT::Math::rowOffsetsUtils::indices<... >
 CTFile::InfoListRetSimple struct of the return value of GetStreamerInfoListImpl
 COuter::Inner
 CTClass::InsertTClassInRegistryRAII
 CTEveParamList::IntConfig_t
 ►Cstd::integral_constant
 CROOT::Fit::FitUtil::IntegralEvaluator< ParamFunc >
 CROOT::Math::IntegratorMultiDimUser class for performing multidimensional integration
 CROOT::Math::IntegratorOneDimUser Class for performing numerical integration of a function in one dimension
 CROOT::Math::InterpolatorClass for performing function interpolation of points
 ►Ccling::InterpreterCallbacks
 CROOT::Internal::InterpreterMutexRegistrationRAII
 ►CTMVA::IntervalThe TMVA::Interval Class
 ►CRooStats::IntervalCalculatorIntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals
 CTMVA::RuleFitAPI::IntParms
 CROOT::Math::Inverter< idim, n >Matrix Inverter class Class to specialize calls to Dinv
 CROOT::Math::Inverter< 0 >Inverter<0>
 CROOT::Math::Inverter< 1 >1x1 matrix inversion a_{11} \to 1/a_{11}
 CROOT::Math::Inverter< 2 >2x2 matrix inversion using Cramers rule
 CTMVA::Config::IONames
 CTTreeCache::IOPos
 ►CROOT::Math::IOptionsGeneric interface for defining configuration options of a numerical algorithm
 ►Cstd::ios_baseSTL class
 ►CIPFType
 ►CTMVA::IPruneToolIPruneTool - a helper interface class to prune a decision tree
 CTMVA::IPythonInteractiveThis class is needed by JsMVA, and it's a helper class for tracking errors during the training in Jupyter notebook
 ►CROOT::Math::IRootFinderMethodInterface for finding function roots of one-dimensional functions
 CROOT::Detail::is_array_class< Array >
 CROOT::Experimental::Internal::IsMappable< FieldT >
 ►CROOT::option::PrintUsageImplementation::IStringWriter
 CROOT::Experimental::REveChunkManager::iterator
 CROOT::Math::KDTree< _DataPoint >::iterator
 ►Cstd::iterator
 CTEveChunkManager::iterator
 CTTreeReaderArray< T >::Iterator_t< ReaderArrayType >Random access iterator to the elements of a TTreeReaderArray
 ►Cstd::iterator_traits
 CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, large >Small helper to implement the function to create,access and destroy iterators
 CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators
 CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, true >
 CROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value >Small helper to encapsulate whether to return the value pointed to by the iterator or its address
 CROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value_ptr * >
 CROOT::Math::KahanSum< T, N >The Kahan summation is a compensated summation algorithm, which significantly reduces numerical errors when adding a sequence of finite-precision floating point numbers
 CTMVA::KDEKernelKDE Kernel for "smoothing" the PDFs
 CROOT::Math::KDTree< _DataPoint >
 CROOT::Meta::Selection::KeepFirstTemplateArguments< I >Used to specify the number of arguments to be kept
 CROOT::Math::KelvinFunctionsThis class calculates the Kelvin functions Ber(x), Bei(x), Ker(x), Kei(x), and their first derivatives
 CROOT::Experimental::Detail::ROnDiskPage::KeyOn-disk pages within a page source are identified by the column and page number
 CROOT::Minuit2::LASymMatrixClass describing a symmetric matrix of size n
 CROOT::Minuit2::LAVector
 CTMVA::DNN::LayerLayer defines the layout of a layer
 CTMVA::DNN::LayerDataLayerData holds the data of one layer
 CTGFSComboBox::Lbc_t
 CTMVA::LDA
 CTLeaf::LeafCountValues
 CROOT::Fit::FitUtil::LikelihoodAux< T >
 CROOT::Fit::FitUtil::LikelihoodAux< double >
 CTMath::Limits< T >
 CROOT::Experimental::REveStraightLineSet::Line_t
 CTEveStraightLineSet::Line_t
 CRgl::Pad::LineAttribSet
 CROOT::option::PrintUsageImplementation::LinePartIterator
 CROOT::option::PrintUsageImplementation::LineWrapper
 CLinkdefReader
 CTHtml::LinkInfo_t
 CRooHelpers::LocalChangeMsgLevelSwitches the message service to a different level while the instance is alive
 CROOT::Math::LocalCoordinateSystemTagTag for identifying vectors based on a local coordinate system
 CROOT::Internal::UniqueLockRecurseCount::LocalCounts
 CTAtomicCount::LockGuard
 CTString::LongStr_t
 CROOT::Math::LorentzRotationLorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix
 CROOT::Math::LorentzVector< CoordSystem >Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part
 ►CTMVA::LossFunction
 CTMVA::LossFunctionEventInfo
 CCPyCppyy::LowLevelView
 ►CROOT::Detail::make_indices_impl< First, Step, N, class >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< I, IndexTuple, N >
 ►CROOT::Math::rowOffsetsUtils::make_indices_impl< 0, indices<>, N >
 CROOT::Detail::make_indices_impl< First, 1,((Last - First)+(1 - 1))/1 >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< I, indices< Indices... >, N >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< N, indices< Indices... >, N >
 CROOT::Detail::make_indices_next< IndicesType, Next >
 CROOT::Detail::make_indices_next2< IndicesType, Next, Tail >
 CROOT::Detail::make_indices_next2< indices< Indices... >, Next, Tail >
 CROOT::Detail::make_indices_next2< ROOT::Detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step, First+(N - 1) *Step >
 CROOT::Detail::make_indices_next< indices< Indices... >, Next >
 CROOT::Detail::make_indices_next< ROOT::Detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step >
 CROOT::Math::detail::manipulator< char_t >
 ►Cstd::map< std::string, const void * >
 CROOT::Internal::TExecutor::MapRetType< F, CONTAINER >Helper class to get the correct return type from the Map function, necessary to infer the ResolveExecutorAndMap function type
 CROOT::Internal::TExecutor::MapRetType< F, unsigned >
 CROOT::Experimental::REveStraightLineSet::Marker_t
 CTEveStraightLineSet::Marker_t
 CRgl::Pad::MarkerPainter
 CROOT::Math::MathMoreLib
 CROOT::Math::MatRepStd< T, D1, D2 >Expression wrapper class for Matrix objects
 CROOT::Math::MatRepStd< T, D1, D1 >
 CROOT::Math::MatRepSym< T, D >MatRepSym Matrix storage representation for a symmetric matrix of dimension NxN This class is a template on the contained type and on the symmetric matrix size, N
 CROOT::Minuit2::MatrixInverse< mtype, M, T >
 CROOT::Minuit2::MatrixInverse< vec, M, T >
 CROOT::Math::MatrixMulOp< MatrixA, MatrixB, T, D >Class for Matrix-Matrix multiplication
 CTProof::MD5Mod_t
 CTMVA::DNN::MeanVariance
 CROOT::Meta::Selection::MemberAttributes< memberAttributes >Used to specify attributes of data members in the "DictSelection" syntax
 CROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >::MemFuncEvaluator< PObj, F, T >
 CMemInfo_t
 CCPyCppyy::MemoryRegulator
 CMemPoolForRooSets< RooSet_t, POOLSIZE >Memory pool for RooArgSet and RooDataSet
 CRgl::Pad::MeshPatch_t
 CROOT::Math::meta_col_dot< I >
 CROOT::Math::meta_col_dot< 0 >
 CROOT::Math::meta_dot< I >
 CROOT::Math::meta_dot< 0 >
 CROOT::Math::meta_mag< I >
 CROOT::Math::meta_mag< 0 >
 CROOT::Math::meta_matrix_dot< I >
 CROOT::Math::meta_matrix_dot< 0 >
 CROOT::Math::meta_row_dot< I >
 CROOT::Math::meta_row_dot< 0 >
 CTGenCollectionProxy::MethodSmall helper to execute (compiler) generated function for the access to STL or other containers
 CTGenCollectionProxy::Method0
 ►CTMVA::MethodCFMlpANN_UtilsImplementation of Clermond-Ferrand artificial neural network
 CCPyCppyy::CPPOverload::MethodInfo_t
 Cmg_callbacks
 Cmg_client_cert
 Cmg_client_options
 Cmg_form_data_handler
 Cmg_header
 Cmg_option
 Cmg_request_info
 Cmg_response_info
 Cmg_server_ports
 Cmg_websocket_subprotocols
 ►CROOT::Math::MinimizerAbstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc..) Plug-in's exist in ROOT to be able to instantiate the derived classes like ROOT::Math::GSLMinimizer or ROOT::Math::Minuit2Minimizer via the plug-in manager
 CROOT::Math::MinimizerOptionsMinimizer options
 ►CROOT::Math::MinimizerVariableTransformationBase class for MinimizerVariable transformations defining the functions to deal with bounded parameters
 CROOT::Math::MinimTransformVariableMinimTransformVariable class Contains meta information of the variables such as bounds, fix flags and deals with transformation of the variable The class does not contain the values and the step size (error) of the variable This is an internal class used by the MinimTransformFunction class
 ►CROOT::Minuit2::MinimumBuilder
 CROOT::Minuit2::MinimumErrorMinimumError keeps the inv
 ►CROOT::Minuit2::MinimumErrorUpdator
 CROOT::Minuit2::MinimumParameters
 CROOT::Minuit2::MinimumSeedMinimumSeed contains the starting values for the minimization produced by the SeedGenerator
 ►CROOT::Minuit2::MinimumSeedGeneratorBase class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization;
 CROOT::Minuit2::MinimumStateMinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder)
 CROOT::Math::MinOp< T >Subtraction Operation Class
 CROOT::Minuit2::MinosErrorClass holding the result of Minos (lower and upper values) for a specific parameter
 CROOT::Minuit2::MinuitParameterClass for the individual Minuit Parameter with Name and number; contains the input numbers for the minimization or the output result from minimization; possible interactions: Fix/release, set/remove limits, set Value/error;
 CROOT::Math::Minus< T >Unary Minus Operation Class
 CROOT::Math::MinusEquals< T, D1, D2, A, R1, R2 >Evaluate the expression performing a -= operation Need to check whether creating a temporary object with the expression result (like in op: A -= A * B )
 CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Specialization for symmetrix -= general : NOT Allowed operation
 CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >Specialization for symmetric matrices
 CROOT::Math::MiserParametersStructures collecting parameters for MISER multidimensional integration
 CTTreeCache::MissCache
 CROOT::Math::MixMaxEngineImpl< N >
 CROOT::Math::MixMaxEngineImpl< ROOT_MM_N >
 CROOT::Minuit2::BasicFunctionMinimum::MnAboveMaxEdm
 ►CROOT::Minuit2::MnApplicationApplication interface class for minimizers (migrad, simplex, Minimize, Scan) User normally instantiates the derived class like ROOT::Minuit2::MnMigrad for using Migrad for minimization
 CROOT::Minuit2::MnContoursAPI class for Contours Error analysis (2-dim errors); minimization has to be done before and Minimum must be valid; possibility to ask only for the points or the points and associated Minos errors;
 CROOT::Minuit2::MnCovarianceSqueezeClass to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index
 CROOT::Minuit2::MnCross
 CROOT::Minuit2::MnEigenAPI class for calculating the eigenvalues of symmetric matrix
 ►CROOT::Minuit2::MnFcnWrapper class to FCNBase interface used internally by Minuit
 CROOT::Minuit2::MnFunctionCrossMnFunctionCross
 CROOT::Minuit2::MnGlobalCorrelationCoeffClass for global correlation coefficient
 CROOT::Minuit2::MnHesseAPI class for calculating the numerical covariance matrix (== 2x Inverse Hessian == 2x Inverse 2nd derivative); can be used by the user or Minuit itself
 CROOT::Minuit2::BasicMinimumError::MnHesseFailed
 CROOT::Minuit2::BasicMinimumError::MnInvertFailed
 CROOT::Minuit2::MnLineSearchImplements a 1-dimensional minimization along a given direction (i.e
 CROOT::Minuit2::MnMachinePrecisionSets the relative floating point (double) arithmetic precision
 CROOT::Minuit2::BasicMinimumError::MnMadePosDef
 CROOT::Minuit2::MnMinosAPI class for Minos Error analysis (asymmetric errors); minimization has to be done before and Minimum must be valid; possibility to ask only for one side of the Minos Error;
 CROOT::Minuit2::BasicMinimumError::MnNotPosDef
 CROOT::Minuit2::MnParabolaThis class defines a parabola of the form a*x*x + b*x + c
 CROOT::Minuit2::MnParabolaFactory
 CROOT::Minuit2::MnParabolaPointA point of a parabola
 CROOT::Minuit2::MnParameterScanScans the values of FCN as a function of one Parameter and retains the best function and Parameter values found
 CROOT::Minuit2::MnPlotMnPlot produces a text-screen graphical output of (x,y) points, e.g
 CROOT::Minuit2::MnPosDefForce the covariance matrix to be positive defined by adding extra terms in the diagonal
 CROOT::Minuit2::MnPrint
 CROOT::Minuit2::BasicFunctionMinimum::MnReachedCallLimit
 CROOT::Minuit2::MnRefCountedPointer< T >
 CROOT::Minuit2::MnReferenceCounter
 CROOT::Minuit2::MnStrategyAPI class for defining three levels of strategies: low (0), medium (1), high (>=2); acts on: Migrad (behavioural), Minos (lowers strategy by 1 for Minos-own minimization), Hesse (iterations), Numerical2PDerivative (iterations)
 CROOT::Minuit2::MnTiny
 ►CROOT::Minuit2::MnTraceObject
 CROOT::Minuit2::MnUserCovarianceClass containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide internal matrix representation to user
 CROOT::Minuit2::MnUserParametersAPI class for the user interaction with the parameters; serves as input to the minimizer as well as output from it; users can interact: Fix/release parameters, set values and errors, etc.; parameters can be accessed via their Parameter number (determined internally by Minuit and followed the order how the parameters are created) or via their user-specified Name (10 character string)
 CROOT::Minuit2::MnUserParameterStateClass which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand;
 CROOT::Minuit2::MnUserTransformationClass dealing with the transformation between user specified parameters (external) and internal parameters used for minimization
 CROOT::Minuit2::MnVectorTransform
 ►Ctorch.nn.Module
 ►Cclang::ModuleFileExtension
 ►Cclang::ModuleFileExtensionReader
 ►Cclang::ModuleFileExtensionWriter
 CTMVA::kNN::ModulekNN
 CTMVA::Monitoring
 CROOT::Minuit2::MPIProcess
 CROOT::Minuit2::MPITerminate
 CROOT::Math::MulOp< T >Multiplication (element-wise) Operation Class
 CMultiDistFree functions adapter needed by UNURAN for multidimensional cont distribution
 CROOT::Math::MultPolicy< T, R1, R2 >Matrix-matrix multiplication policy
 CTCling::MutexStateAndRecurseCount
 CTCling::MutexStateAndRecurseCountDelta
 CXrdClientVector< T >::myindex
 CMYSQL_BIND
 CMYSQL_STMT
 CTGDMLWrite::NameLst
 CROOT::Minuit2::NegativeG2LineSearchIn case that one of the components of the second derivative g2 calculated by the numerical Gradient calculator is negative, a 1dim line search in the direction of that component is done in order to find a better position where g2 is again positive
 CTMVA::DNN::NetNeural net
 CTMVA::kNN::Node< T >This file contains binary tree and global function template that searches tree for k-nearest neigbors
 ►CTMVA::NodeNode for the BinarySearch or Decision Trees
 CTMVA::kNN::Node< TMVA::kNN::Event >
 CROOT::Detail::RDF::CustomColExtraArgs::None
 CRooStats::HistFactory::EstimateSummary::NormFactor
 CRooStats::HistFactory::NormFactorConfiguration for an un- constrained overall systematic to scale sample normalisations
 ►C<NSApplicationDelegate>
 ►CNSObject
 CROOT::MacOSX::Util::NSScopeGuard< DerivedType >
 CROOT::MacOSX::Util::NSScopeGuard< ROOTApplicationDelegate >
 CROOT::MacOSX::Util::NSStrongReference< DerivedType >
 CROOT::MacOSX::Util::NSStrongReference< QuartzWindow >
 ►CNSView
 ►CNSWindow
 ►C<NSWindowDelegate>
 CRooStats::NuisanceParametersSamplerHelper class for ToyMCSampler
 CTMVA::null_t< F >
 CROOT::Math::NullTypeFunc1D
 CRooStats::NumberCountingPdfFactoryA factory for building PDFs and data for a number counting combination
 CRooSimWSTool::ObjBuildConfig
 ►Cobject
 CTClass::ObjectPtr
 CRooSimWSTool::ObjSplitRule
 CTODBCStatement::ODBCBufferRec_t
 CRgl::Pad::OffScreenDevice
 CROOT::Minuit2::MnPrint::Oneline
 CROOT::option::OptionA parsed option from the command line together with its argument if it has one
 CTMVA::OptionMapClass to storage options for the differents methods
 CROOT::Experimental::RFile::Options_tOptions for RFile construction
 CROOT::Experimental::RPalette::OrdinalAndColorAn ordinal value and its associated color
 CTHtml::OutputStyle_t
 CRooStats::HistFactory::OverallSysConfiguration for a constrained overall systematic to scale sample normalisations
 COverloadedCall
 CROOT::Math::CholeskyDecompHelpers::PackedArrayAdapter< G >Adapter for packed arrays (to SMatrix indexing conventions)
 CBidirMMapPipe_impl::PageChunkClass representing a chunk of pages
 CBidirMMapPipe_impl::PagesHandle class for a number of Pages
 CRooNormSetCache::PairCmp
 CROOT::Detail::TCollectionProxyInfo::PairHolder< T, Q >
 CCPyCppyy::Parameter
 CROOT::Fit::ParameterSettingsClass, describing value, limits and step size of the parameters Provides functionality also to set/retrieve values, step sizes, limits and fix the parameters
 CROOT::Math::ParamFunctionBase< T >Class defining the signature for multi-dim parametric functions
 CROOT::Math::ParamFunctorTempl< T >Param Functor class for Multidimensional functions
 CROOT::option::ParserChecks argument vectors for validity and parses them into data structures that are easier to work with
 CROOT::Internal::ParsingStateRAIIRAII used to store Parser, Sema, Preprocessor state for recursive parsing
 CROOT::Internal::RDF::PassAsVecHelper< I, T, F >
 Cpasswd
 CTHtml::PathInfo_t
 CPattern
 CPgSQL_Stmt_t
 CPictureAttributes_t
 CXrdPoll::PipeData
 CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, R1, R2 >
 CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
 CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
 CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, R1, R2 >Structure to deal when a submatrix is placed in a matrix
 CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
 CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
 CROOT::Math::PlainParameters
 CROOT::Math::Impl::Plane3D< T >Class describing a geometrical plane in 3 dimensions
 CRooAbsData::PlotOpt
 CRooAbsReal::PlotOpt
 CRgl::PlotTranslation
 CROOT::Math::PlusEquals< T, D1, D2, A, R1, R2 >Evaluate the expression performing a += operation Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
 CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Specialization for symmetrix += general : NOT Allowed operation
 CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >Specialization for symmetric matrices Evaluate the expression performing a += operation for symmetric matrices Need to have a separate functions to avoid to modify two times the off-diagonal elements (i.e applying two times the expression) Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
 CROOT::MacOSX::X11::Point
 CTColorGradient::Point
 CTProofDrawListOfGraphs::Point3D_t
 CTProofDrawListOfPolyMarkers3D::Point4D_t
 CPoint_tPoint structure (maps to the X11 XPoint structure)
 CROOT::Math::Polar2D< T >Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI)
 CROOT::Math::Polar3D< T >Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI)
 CBidirMMapPipe::PollEntryFor poll() interface
 CROOT::Experimental::REvePolygonSetProjected::Polygon_t
 CTEvePolygonSetProjected::Polygon_t
 CRgl::Pad::PolygonStippleSet
 CROOT::Experimental::Detail::RFieldBase::RSchemaIterator::Position
 CROOT::Math::PositionVector2D< CoordSystem, Tag >Class describing a generic position vector (point) in 2 dimensions
 CROOT::Math::PositionVector3D< CoordSystem, Tag >Class describing a generic position vector (point) in 3 dimensions
 CPQhandleElem
 CPQnode
 CRooStats::HistFactory::PreprocessFunction
 CROOT::Experimental::REveProjection::PreScaleEntry_t
 CTEveProjection::PreScaleEntry_t
 CROOT::option::PrintUsageImplementation
 CPriorityQ
 CProcInfo_t
 CROOT::Experimental::REveDataProxyBuilderBase::Product
 CRooStats::ProfileInspectorUtility class to plot conditional MLE of nuisance parameters vs
 CTGLSurfacePainter::Projection_t
 CRooStats::ProofConfigHolds configuration options for proof and proof-lite
 CProofServEnv_t
 CTMVA::PruningInfo
 CROOT::Math::PtEtaPhiE4D< ScalarType >Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+)
 CROOT::Math::PtEtaPhiM4D< ScalarType >Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+)
 Cpthread_cond_t
 CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators::PtrSize_t
 CROOT::Math::PxPyPzE4D< ScalarType >Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E)
 CROOT::Math::PxPyPzM4D< ScalarType >Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M)
 CPybins_tPythia6 common block Pybins
 ►CCPyCppyy::PyCallable
 CPydat1_tPythia6 common block Pydat1
 CPydat2_tPythia6 common block Pydat2
 CPydat3_tPythia6 common block Pydat3
 CPydat4_tPythia6 common block Pydat4
 CPydatr_tPythia6 common block Pydatr
 CCPyCppyy::Utility::PyError_t
 CPyint1_tPythia6 common block Pyint1
 CPyint2_tPythia6 common block Pyint2
 CPyint3_tPythia6 common block Pyint3
 CPyint4_tPythia6 common block Pyint4
 CPyint5_tPythia6 common block Pyint5
 CPyint6_tPythia6 common block Pyint6
 CPyint7_tPythia6 common block Pyint7
 CPyint8_tPythia6 common block Pyint8
 CPyint9_tPythia6 common block Pyint9
 CPyints_tPythia6 common block Pyints
 CPyjets_tPythia6 common block Pyjets
 CPymssm_tPythia6 common block Pymssm
 CCPyCppyy::Utility::PyOperators
 CPypars_tPythia6 common block Pypars
 CCPyCppyy::PyResult
 CPyssmt_tPythia6 common block Pyssmt
 CPysubs_tPythia6 common block Pysubs
 CQuad
 CROOT::Math::QuasiRandom< Engine >User class for MathMore random numbers template on the Engine type
 CROOT::Math::QuaternionRotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k)
 CROOT::Experimental::RWebWindow::QueueEntry
 CROOT::Experimental::RWebWindow::QueueItem
 CTMVA::QuickMVAProbEstimator
 ►CQWidget
 ►CROOT::Internal::RDF::RActionBase
 CROOT::Detail::VecOps::RAdoptAllocator< T >RAdoptAllocator can provide a view on already allocated memory
 CROOT::Detail::VecOps::RAdoptAllocator< bool >
 CROOT::Math::Random< Engine >Documentation for the Random class
 CROOT::Math::RandomFunctions< Engine, EngineBaseType >
 ►CROOT::Math::RandomFunctions< EngineType, DefaultEngineType >
 CROOT::Math::RandomFunctionsImpl< EngineBaseType >Definition of the generic impelmentation class for the RandomFunctions
 CROOT::Math::RandomFunctionsImpl< DefaultEngineType >
 CROOT::Math::RandomFunctionsImpl< TRandomEngine >Implementation class for the RandomFunction for all the engined that derives from TRandomEngine class, which defines an interface which has TRandomEngine::Rndm() In this way we can have a common implementation for the RandomFunctions
 CTMVA::RandomGenerator< TRandomLike, UIntType, max_val >
 CTMVA::Rank
 CTMVA::RankingRanking for variables in method (implementation)
 CROOT::Math::RanluxppEngineImpl< w, p >
 ►CROOT::Experimental::RAttrBaseBase class for all attributes, used with RDrawable
 CROOT::Experimental::RAttrMap
 CTString::RawStr_t
 ►CROOT::Experimental::RAxisBaseHistogram axis base class
 CROOT::Experimental::RAxisConfigObjects used to configure the different axis types
 CTMVA::Experimental::RBDT< Backend >Fast boosted decision tree inference
 CROOT::Experimental::RHistDataMomentUncert< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >::RBinStatModifying view on a RHistStatContent for a given bin
 CROOT::Experimental::RHistStatRuntime< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatTotalSumOfWeights< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >::RBinStatModifying view on a RHistStatUncertainty for a given bin
 CROOT::Internal::RRawFile::RBlockBuffer
 CROOT::Internal::RDF::RBookedDefinesEncapsulates the columns defined by the user
 CROOT::Experimental::Detail::RClusterAn in-memory subset of the packed and compressed pages of a cluster
 CROOT::Experimental::RClusterDescriptorMeta-data for a set of ntuple clusters
 CROOT::Experimental::RClusterIndexAddresses a column element or field item relative to a particular cluster, instead of a global NTupleSize_t index
 CROOT::Experimental::Detail::RPage::RClusterInfoStores information about the cluster in which this page resides
 CROOT::Experimental::Detail::RClusterPoolManaged a set of clusters containing compressed and packed pages
 CROOT::Experimental::RClusterSizeWrap the 32bit integer in a struct in order to avoid template specialization clash with std::uint32_t
 CROOT::Experimental::RCollectionNTupleA virtual ntuple for collections that can be used to some extent like a real ntuple
 CROOT::Experimental::RColorThe color class
 CROOT::Experimental::Detail::RColumn
 CRColumnA column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into memory
 CROOT::Experimental::RColumnDescriptorMeta-data stored for every column of an ntuple
 CROOT::Experimental::RNTupleDescriptor::RColumnDescriptorRangeUsed to loop over a field's associated columns
 ►CROOT::Experimental::Detail::RColumnElementBase
 CROOT::Experimental::Detail::RPageStorage::RColumnHandle
 CROOT::Experimental::RColumnModelHolds the static meta-data of a column in a tree
 CROOT::Experimental::RClusterDescriptor::RColumnRangeThe window of element indexes of a particular column in a particular cluster
 ►CROOT::Detail::RDF::RColumnReaderBase
 CRColumnReaderBasePure virtual base class for all column reader types
 CROOT::Internal::RDF::RColumnReadersInfoThis type aggregates some of the arguments passed to InitColumnReaders
 CROOT::Experimental::RColumnSwitchHolds the index and the tag of a kSwitch column
 CROOT::RCompressionSettingThe global settings depend on a global variable named R__ZipMode which can be modified by a global function named R__SetZipMode
 CROOT::Experimental::Internal::RComputeGlobalBin< I, NDIMS, BINS, AXES >Recursively gets the total number of regular bins before the current dimension, when computing a global bin that is in under- or overflow in at least one dimension
 CROOT::Experimental::Internal::RComputeGlobalBin<-1, NDIMS, BINS, AXES >
 CROOT::Experimental::Internal::RComputeGlobalBinRaw< I, NDIMS, BINS, AXES, BINTYPE >Recursively computes a zero-based global bin index, given..
 CROOT::Experimental::Internal::RComputeGlobalBinRaw<-1, NDIMS, BINS, AXES, BINTYPE >
 CROOT::Experimental::Internal::RComputeLocalBins< I, NDIMS, AXES >Recursively computes the number of regular bins before the current dimension, as well as the number of under- and overflow bins left to account for, after the current dimension
 CROOT::Experimental::Internal::RComputeLocalBins< 0, NDIMS, AXES >
 CROOT::Experimental::Internal::RComputeLocalBinsInitialisation< I, NDIMS, AXES >Recursively compute some quantities needed for ComputeLocalBins, namely the total number of bins per hyperplane (overflow and regular) and the number of regular bins per hyperplane on the hyperplanes that have them
 CROOT::Experimental::Internal::RComputeLocalBinsInitialisation< 0, NDIMS, AXES >
 CROOT::Experimental::Internal::RComputeLocalBinsRaw< I, NDIMS, BINS, AXES, BINTYPE >Recursively computes zero-based local bin indices, given..
 CROOT::Experimental::Internal::RComputeLocalBinsRaw<-1, NDIMS, BINS, AXES, BINTYPE >
 CROOT::Internal::RConcurrentHashCollThis class is a TS set of unsigned set
 CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >::RConstBinStatConst view on a RHistStatContent for a given bin
 CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >::RConstBinStatConst view on a RHistStatUncertainty for a given bin
 CROOT::TMetaUtils::RConstructorType
 CROOT::Experimental::Detail::RPageSourceFile::RCountersI/O performance counters that get registered in fMetrics
 CROOT::RDF::RCutFlowReport
 CROOT::Experimental::RDanglingFieldDescriptorA helper class for piece-wise construction of an RFieldDescriptor
 CROOT::Internal::RDF::RDataBlockFlag
 CROOT::Internal::RDF::RDataBlockNotifier
 ►CROOT::RDF::RDataSourceRDataSource defines an API that RDataFrame can use to read arbitrary data formats
 ►CROOT::Detail::RDF::RDefineBase
 ►CROOT::Experimental::RDirectoryKey/value store of objects
 CROOT::Experimental::Internal::RDirectoryEntry
 CROOT::RDF::RDisplayThis class is the textual representation of the content of a columnar dataset
 CROOT::Experimental::RDrawable::RDisplayContext
 CROOT::Internal::RDF::RDisplayElementHelper class to let Display print compact tabular representations of the events
 ►CROOT::Experimental::RDisplayItemBase class for painting data for JS
 ►CROOT::Experimental::RDrawableBase class for drawable entities: objects that can be painted on a RPad
 ►CROOT::Experimental::RDrawableReplyBase class for replies on RDrawableRequest
 ►CROOT::Experimental::RDrawableRequestBase class for requests which can be submitted from the clients
 CTFormLeafInfo::ReadValueHelper< T >
 CTFormLeafInfo::ReadValueHelper< Long64_t >
 CTFormLeafInfo::ReadValueHelper< LongDouble_t >
 CTFormLeafInfo::ReadValueHelper< ULong64_t >
 CTTreeFormula::RealInstanceCache
 CTMVA::RuleFitAPI::RealParms
 ►CRooVectorDataStore::RealVector
 CROOT::Detail::VecOps::RAdoptAllocator< T >::rebind< U >
 CROOT::Detail::VecOps::RAdoptAllocator< bool >::rebind
 CROOT::Experimental::REveCaloData::RebinData_t
 CTEveCaloData::RebinData_t
 CROOT::Experimental::RAttrBase::Rec_t
 CROOT::Experimental::REveSelection::Record
 CROOT::MacOSX::X11::Rectangle
 CRectangle_tRectangle structure (maps to the X11 XRectangle structure)
 CROOT::Internal::RecurseCounts
 ►Cclang::RecursiveASTVisitor
 CRedirectHandle_t
 CROOT::ExecutorUtils::ReduceObjects< T >Merge collection of TObjects
 CROOT::Detail::TStatusBitsChecker::Registry
 CTMVA::RegressionVarianceCalculate the "SeparationGain" for Regression analysis separation criteria used in various training algorithms
 CROOT::TypeTraits::RemoveFirst< T, Rest >
 CROOT::TypeTraits::RemoveFirstParameter< typename >Remove first of possibly many template parameters
 CROOT::TypeTraits::RemoveFirstParameter< U< T, Rest... > >
 CROOT::Experimental::REntryThe REntry is a collection of values in an ntuple corresponding to a complete row in the data set
 CTString::Rep_t
 CROOT::Experimental::RErrorCaptures diagnostics related to a ROOT runtime error
 CROOT::Internal::ExecutorUtils::ResultCaster< O, F >
 CROOT::Internal::ExecutorUtils::ResultCaster< TObject *, F >
 CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, R1, R2 >Structure for getting sub matrices We have different cases according to the matrix representations
 CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
 CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
 ►CROOT::Experimental::REveAunt
 CROOT::Experimental::REveCaloDataSelector
 CROOT::Experimental::REveCaloDataSliceSelector
 ►CROOT::Experimental::REveChunkManager
 CROOT::Experimental::REveClient
 CROOT::Experimental::REveClusterREveCluster Reconstructed cluster (also used in VSD)
 CROOT::Experimental::REveDataItem
 ►CROOT::Experimental::REveDataProxyBuilderBase
 ►CROOT::Experimental::REveElement
 CROOT::Experimental::REveGeoManagerHolderREveGeoManagerHolder Exception-safe global variable holders
 CROOT::Experimental::REveGeomConfigConfiguration parameters which can be configured on the client Send as is to-from client
 CROOT::Experimental::REveGeomDescription
 CROOT::Experimental::REveGeomDrawingObject with full description for drawing geometry It includes list of visible items and list of nodes required to build them
 ►CROOT::Experimental::REveGeomNodeBaseBase description of geometry node, required only to build hierarchy
 CROOT::Experimental::REveGeomNodeInfo
 CROOT::Experimental::REveGeomRequestRequest object send from client for different operations
 CROOT::Experimental::REveGeomViewer
 CROOT::Experimental::REveGeomVisibleREveGeomVisible contains description of visible node It is path to the node plus reference to shape rendering data
 CROOT::Experimental::REveHitREveHit Monte Carlo hit (also used in VSD)
 ►CROOT::Experimental::REveMagFieldREveMagField Abstract interface to magnetic field
 CROOT::Experimental::REveManager
 CROOT::Experimental::REveMCRecCrossRefREveMCRecCrossRef Cross-reference of sim/rec data per particle (also used in VSD)
 CROOT::Experimental::REvePathMarkT< TT >Special-point on track:
 CROOT::Experimental::REvePointSelectorConsumer
 ►CROOT::Experimental::REveProjectable
 ►CROOT::Experimental::REveProjected
 ►CROOT::Experimental::REveProjectionREveProjection Base for specific classes that implement non-linear projections
 CROOT::Experimental::REveRecCascadeREveRecCascade
 CROOT::Experimental::REveRecKinkREveRecKink Reconstructed kink (also used in VSD)
 CROOT::Experimental::REveRecTrackT< TT >REveRecTrack Template for reconstructed track (also used in VSD)
 CROOT::Experimental::REveRecTrackT< Float_t >
 CROOT::Experimental::REveRecV0REveRecV0
 ►CROOT::Experimental::REveRefCntREveRefCnt REveRefCnt base-class (interface)
 CROOT::Experimental::REveRenderData
 ►CROOT::Experimental::REveSecondarySelectable
 CROOT::Experimental::REveTableEntryREveTableEntry
 CROOT::Experimental::REveTableHandleREveTableHandle
 CROOT::Experimental::REveUtilREveUtil Standard utility functions for Reve
 CROOT::Experimental::REveVector2T< TT >REveVector2T A two-vector template without TObject inheritance and virtual functions
 ►CROOT::Experimental::REveVectorT< TT >REveVectorT A three-vector template without TObject inheritance and virtual functions
 CROOT::Experimental::REveVectorT< Double_t >
 CROOT::Experimental::REveVectorT< Float_t >
 CROOT::Experimental::REveViewContext
 CROOT::Experimental::Internal::IsMappable< FieldT >::RFailure
 ►CROOT::Experimental::Detail::RFieldBase
 CRFieldBaseA field translates read and write calls from/to underlying columns to/from tree values
 CROOT::Experimental::RFieldDescriptorMeta-data stored for every field of an ntuple
 CROOT::Experimental::RNTupleDescriptor::RFieldDescriptorRangeUsed to loop over a field's child fields
 CROOT::Experimental::Detail::RFieldFuse
 CRFieldFuseA friend of RFieldBase responsible for connecting a field's columns to the physical page storage
 CROOT::Experimental::RFieldMergerTwo-way merge between NTuple fields
 CROOT::Experimental::Detail::RFieldValue
 CRFieldValueRepresents transient storage of simple or complex C++ values
 ►CROOT::Experimental::Detail::RFieldVisitorAbstract base class for classes implementing the visitor design pattern
 CROOT::Experimental::Internal::RNTupleFileWriter::RFileProper
 CROOT::Experimental::RFilePtrPoints to an object that stores or reads objects in ROOT's binary format
 CROOT::Experimental::Internal::RNTupleFileWriter::RFileSimple
 CROOT::Experimental::Internal::RFillIterRange< I, AXES >Recursively fills the ranges of all axes, excluding under- and overflow
 CROOT::Experimental::Internal::RFillIterRange<-1, AXES >
 CROOT::Experimental::Internal::RFindLocalBins< I, NDIMS, BINS, COORD, AXES >Find the per-axis local bin indices associated with a certain set of coordinates
 CROOT::Experimental::Internal::RFindLocalBins<-1, NDIMS, BINS, COORD, AXES >
 CROOT::Experimental::RFitResult
 CROOT::Experimental::RFunction< DIMENSION >
 CROOT::MacOSX::X11::ColorParser::RGB_t
 ►CROOT::Experimental::RGeomRenderInfoBase class for render info block
 CROOT::Experimental::Internal::RGetNBinsCount< I, AXES >Recursively gets the total number of bins in whole hist, including under- and overflow
 CROOT::Experimental::Internal::RGetNBinsCount< 0, AXES >
 CROOT::Experimental::Internal::RGetNBinsNoOverCount< I, AXES >Recursively gets the total number of bins in whole hist, excluding under- and overflow
 CROOT::Experimental::Internal::RGetNBinsNoOverCount< 0, AXES >
 CROOT::Experimental::Internal::RGetNRegularBinsBefore< I, NDIMS, BINS, AXES >Recursively gets the number of regular bins just before the current dimension
 CROOT::Experimental::Internal::RGetNRegularBinsBefore<-1, NDIMS, BINS, AXES >
 CROOT::Experimental::RHist< DIMENSIONS, PRECISION, STAT >Histogram class for histograms with DIMENSIONS dimensions, where each bin count is stored by a value of type PRECISION
 ►CROOT::Experimental::RHist< DIMENSIONS, PRECISION, RHistStatContent >
 CROOT::Experimental::Detail::RHistBinPtr< HISTIMPL >Points to a histogram bin (or actually a RHistBinRef)
 CROOT::Experimental::Detail::RHistBinRef< HISTIMPL >Represents a bin reference
 ►CROOT::Experimental::Internal::RHistBufferedFillBase< DERIVED, HIST, SIZE >
 CROOT::Experimental::Internal::RHistBufferedFillBase< RHistBufferedFill< HIST, 1024 >, HIST, 1024 >
 ►CROOT::Experimental::Internal::RHistBufferedFillBase< RHistConcurrentFiller< HIST, SIZE >, HIST, SIZE >
 CROOT::Experimental::RHistConcurrentFillManager< HIST, SIZE >Manages the synchronization of calls to FillN()
 CROOT::Experimental::RHistConcurrentFillManager< HIST, SIZE >
 CROOT::Experimental::RHistDataMomentUncert< DIMENSIONS, PRECISION >For now do as RH1: calculate first (xw) and second (x^2w) moment
 CROOT::Experimental::Internal::RHistImplGen< NDIM, IDIM, DATA, PROCESSEDAXISCONFIG >Generate RHist::fImpl from RHist constructor arguments
 CROOT::Experimental::Internal::RHistImplGen< NDIM, NDIM, DATA, PROCESSEDAXISCONFIG... >Generate RHist::fImpl from constructor arguments; recursion end
 CROOT::Experimental::Detail::RHistImplPrecisionAgnosticBase< DIMENSIONS >Base class for RHistImplBase that abstracts out the histogram's PRECISION
 ►CROOT::Experimental::Detail::RHistImplPrecisionAgnosticBase< DATA::GetNDim()>
 CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >Basic histogram statistics, keeping track of the bin content and the total number of calls to Fill()
 CROOT::Experimental::RHistStatRuntime< DIMENSIONS, PRECISION >Interface implementing a pure virtual functions DoFill(), DoFillN()
 CROOT::Experimental::RHistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION >Keeps track of the histogram's total sum of squared weights
 CROOT::Experimental::RHistStatTotalSumOfWeights< DIMENSIONS, PRECISION >Keeps track of the histogram's total sum of weights
 CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >Histogram statistics to keep track of the Poisson uncertainty per bin
 CROOT::Experimental::RHistView< DIMENSIONS, PRECISION, STAT >A view on a histogram, selecting a range on a subset of dimensions
 CROOT::Experimental::RHistViewOutOfRange< HISTVIEW >
 CROOT::Math::RichardsonDerivatorUser class for calculating the derivatives of a function
 CROOT::Experimental::Detail::RClusterPool::RInFlightClusterClusters that are currently being processed by the pipeline
 CROOT::RDF::RInterface< Proxied, DataSource >The public interface to the RDataFrame federation of classes
 ►CROOT::RDF::RInterface< RDFDetail::RLoopManager >
 ►CROOT::Experimental::Internal::RIOSharedBase
 CROOT::Internal::RIoUring
 CROOT::Internal::RRawFile::RIOVecUsed for vector reads from multiple offsets into multiple buffers
 CROOT::Experimental::RNTupleClusterRange::RIterator
 CROOT::Experimental::RNTupleDescriptor::RColumnDescriptorRange::RIterator
 CROOT::Experimental::RNTupleDescriptor::RFieldDescriptorRange::RIterator
 CROOT::Experimental::RNTupleGlobalRange::RIterator
 CROOT::Experimental::RNTupleReader::RIterator
 CROOT::Experimental::Internal::RLocalBinsToCoords< I, NDIMS, BINS, COORD, AXES >Recursively converts local axis bins from the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention, to the corresponding bin coordinates
 CROOT::Experimental::Internal::RLocalBinsToCoords<-1, NDIMS, BINS, COORD, AXES >
 CROOT::Experimental::Internal::RLocalBinsToVirtualBins< I, NDIMS, BINS, AXES >Recursively converts local axis bins from the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention, to a "virtual bin" convention where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins
 CROOT::Experimental::Internal::RLocalBinsToVirtualBins<-1, NDIMS, BINS, AXES >
 CROOT::Experimental::RError::RLocation
 CROOT::Experimental::RClusterDescriptor::RLocatorGeneric information about the physical location of data
 ►CROOT::Experimental::RLogDiagCountKeep track of emitted errors and warnings
 CROOT::Experimental::RLogEntryA diagnostic that can be emitted by the RLogManager
 ►CROOT::Experimental::RLogHandlerAbstract RLogHandler base class
 CROOT::Experimental::RLogLocationA diagnostic location, part of an RLogEntry
 CROOT::Detail::RMakeUniqueResult< T >
 CROOT::Detail::RMakeUniqueResult< T[]>
 CROOT::Detail::RMakeUniqueResult< T[N]>
 CROOT::Experimental::Detail::RMenuArgumentArgument description for menu item which should invoke class method
 ►CROOT::Experimental::Detail::RMenuItemBase class for menu items, shown on JS side
 ►CROOT::Detail::RDF::RMergeableValueBaseBase class of RMergeableValue
 CROOT::Experimental::Internal::RMiniFileReaderRead RNTuple data blocks from a TFile container, provided by a RRawFile
 Crng_state_st
 ►CROOT::Detail::RDF::RNodeBaseBase class for non-leaf nodes of the computational graph
 CROOT::Experimental::RNTupleEntry point for an RNTuple in a ROOT file
 CROOT::Experimental::RNTupleClusterRangeUsed to loop over entries of collections in a single cluster
 CROOT::Experimental::Detail::RNTupleCompressorHelper class to compress data blocks in the ROOT compression frame format
 CROOT::Experimental::Detail::RNTupleDecompressorHelper class to uncompress data blocks in the ROOT compression frame format
 CROOT::Experimental::RNTupleDescriptorThe on-storage meta-data of an ntuple
 CROOT::Experimental::RNTupleDescriptorBuilderA helper class for piece-wise construction of an RNTupleDescriptor
 CROOT::Experimental::Internal::RNTupleFileWriterWrite RNTuple data blocks in a TFile or a bare file container
 CROOT::Experimental::RNTupleFormatterContains helper functions for RNTupleReader::PrintInfo() and RPrintSchemaVisitor::VisitField()
 CROOT::Experimental::RNTupleGlobalRangeUsed to loop over indexes (entries or collections) between start and end
 CROOT::Experimental::Detail::RNTupleMetricsA collection of Counter objects with a name, a unit, and a description
 CROOT::Experimental::RNTupleModelThe RNTupleModel encapulates the schema of an ntuple
 ►CROOT::Experimental::Detail::RNTuplePerfCounterA performance counter with a name and a unit, which can be activated on demand
 CROOT::Experimental::RNTupleReaderAn RNTuple that is used to read data from storage
 CROOT::Experimental::RNTupleReadOptionsCommon user-tunable settings for reading ntuples
 CROOT::Experimental::Detail::RNTupleTimer< WallTimeT, CpuTimeT >Record wall time and CPU time between construction and destruction
 CROOT::Experimental::RNTupleVersionFor forward and backward compatibility, attach version information to the consitituents of the file format (column, field, cluster, ntuple)
 CROOT::Experimental::RNTupleView< T >An RNTupleView provides read-only access to a single field of the ntuple
 ►CROOT::Experimental::RNTupleView< ClusterSize_t >
 CROOT::Experimental::RNTupleWriteOptionsCommon user-tunable settings for storing ntuples
 CROOT::Experimental::RNTupleWriterAn RNTuple that gets filled with entries (data) and writes them to storage
 CTMVA::ROCCalc
 CTMVA::ROCCurve
 CROOT::Experimental::Detail::ROnDiskPageA page as being stored on disk, that is packed and compressed
 ►CROOT::Experimental::Detail::ROnDiskPageMapA memory region that contains packed and compressed pages
 ►CRooAbsCacheRooAbsCache is the abstract base class for data members of RooAbsArgs that cache other (composite) RooAbsArg expressions
 ►CRooAbsCacheElementRooAbsCacheElement is the abstract base class for objects to be stored in RooAbsCache cache manager objects
 ►CRooAbsFuncAbstract interface for evaluating a real-valued function of one real variable and performing numerical algorithms on it
 ►CRooAbsLValueAbstract base class for objects that are lvalues, i.e
 ►CRooAbsProxyRooAbsProxy is the abstact interface for proxy classes
 ►CRooAbsRootFinderRooAbsRootFinder is the abstract interface for finding roots of real-valued 1-dimensional function that implements the RooAbsFunc interface
 CRooAICRegistryRooAICRegistry is a utility class for operator p.d.f classes that keeps track of analytical integration codes and associated normalization and integration sets
 CRooBatchCompute::RooBatchComputeInterfaceThe interface which should be implemented to provide optimised computation functions for implementations of RooAbsReal::evaluateSpan()
 CRooBlindTools
 CRooCFunction1Map< VO, VI >
 CRooCFunction2Map< VO, VI1, VI2 >
 CRooCFunction3Map< VO, VI1, VI2, VI3 >
 CRooCFunction4Map< VO, VI1, VI2, VI3, VI4 >
 ►CRooDirItemRooDirItem is a utility base class for RooFit objects that are to be attached to ROOT directories
 CRooErrorHandler
 CRooFIterA one-time forward iterator working on RooLinkedList or RooAbsCollection
 CRooFitMoreLib
 CRooFunctorLightweight interface adaptor that exports a RooAbsPdf as a functor
 CRooGlobalFunc
 CRooHistErrorRooHistError is a singleton class used to calculate the error bars for each bin of a RooHist object
 CRooLinkedListElemRooLinkedListElem is an link element for the RooLinkedList class
 CRooMath
 CRooMathCoreReg
 CRooMathMoreReg
 CRooMPSentinelRooMPSentinel is a singleton class that keeps track of all parellel execution processes for goodness-of-fit calculations
 CRooNaNPackerLittle struct that can pack a float into the unused bits of the mantissa of a NaN double
 CRooNormSetCacheClass RooNormSet cache manage the bookkeeping of multiple instances of sets of integration and normalization observables that effectively have the same definition
 CRooNumberClass RooNumber implements numeric constants used by RooFit
 ►CRooPrintableRooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods
 CRooQuasiRandomGeneratorThis class generates the quasi-random (aka "low discrepancy") sequence for dimensions up to 12 using the Niederreiter base 2 algorithm described in Bratley, Fox, Niederreiter, ACM Trans
 CRooRandomThis class provides a static interface for generating random numbers
 CRooRealConstantRooRealConstant provides static functions to create and keep track of RooRealVar constants
 CRooSentinelRooSentinel is a special purpose singleton class that terminates all other RooFit singleton services when the process exits
 CRooSpan< T >A simple container to hold a batch of data values
 CRooStats::RooStatsConfig
 CRooSTLRefCountList< T >The RooSTLRefCountList is a simple collection of pointers to the template objects with reference counters
 CRooSTLRefCountList< RooAbsArg >
 CRooStreamParser
 CROOT::Math::RootFinderUser Class to find the Root of one dimensional functions
 CRooTMathReg
 CRooTraceClass RooTrace controls the memory tracing hooks in all RooFit objects
 ►CRooWorkspaceHandleAn interface to set and retrieve a workspace
 CROOT::Internal::RRawFile::ROptionsOn construction, an ROptions parameter can customize the RRawFile behavior
 CROOT::Math::Rotation3DRotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
 CROOT::Math::RotationXRotation class representing a 3D rotation about the X axis by the angle of rotation
 CROOT::Math::RotationYRotation class representing a 3D rotation about the Y axis by the angle of rotation
 CROOT::Math::RotationZRotation class representing a 3D rotation about the Z axis by the angle of rotation
 CROOT::Math::RotationZYXRotation class with the (3D) rotation represented by angles describing first a rotation of an angle phi (yaw) about the Z axis, followed by a rotation of an angle theta (pitch) about the Y axis, followed by a third rotation of an angle psi (roll) about the X axis
 CROOT::Math::RowOffsets< D >Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix
 CROOT::Experimental::RPadExtentAn extent / size (horizontal and vertical) in a RPad
 CROOT::Experimental::RPadLengthA length in RPad
 CROOT::Experimental::RPadPosA position (horizontal and vertical) in a RPad
 ►CROOT::Experimental::RPadUserAxisBaseBase class for user coordinates (e.g
 CROOT::Experimental::Detail::RPageA page is a slice of a column that is mapped into memory
 CROOT::Experimental::Detail::RPageAllocatorFileManages pages read from a the file
 CROOT::Experimental::Detail::RPageAllocatorHeapUses standard C++ memory allocation for the column data pages
 CROOT::Experimental::Detail::RPageDeleterA closure that can free the memory associated with a mapped page
 CROOT::Experimental::RClusterDescriptor::RPageRange::RPageInfoWe do not need to store the element size / uncompressed page size because we know to which column the page belongs
 CROOT::Experimental::Detail::RPagePoolA thread-safe cache of column pages
 CROOT::Experimental::RClusterDescriptor::RPageRangeRecords the parition of data into pages for a particular column in a particular cluster
 ►CROOT::Experimental::Detail::RPageStorageCommon functionality of an ntuple storage for both reading and writing
 CROOT::Experimental::RPaletteA set of colors
 CROOT::Experimental::RPrintValueVisitor::RPrintOptions
 ►CROOT::Internal::RRawFileThe RRawFile provides read-only access to local and remote files
 CTMVA::Experimental::RReaderTMVA::Reader legacy interface
 CROOT::Internal::RIoUring::RReadEventBasic read event composed of IO data and a target file descriptor
 CROOT::Experimental::Detail::RClusterPool::RReadItemRequest to load a subset of the columns of a particular cluster
 CROOT::Experimental::REveManager::RRedrawDisabler
 ►CROOT::Experimental::Internal::RResultBaseCommon handling of the error case for RResult<T> (T != void) and RResult<void>
 CROOT::RDF::RResultHandle
 CROOT::RDF::RResultPtr< T >Smart pointer for the return type of actions
 Crsa_KEY
 Crsa_KEY_export
 Crsa_NUMBER
 CROOT::Experimental::Detail::RFieldBase::RSchemaIteratorIterates over the sub tree of fields in depth-first search order
 CROOT::Internal::RDF::RSlotStackThis is an helper class to allow to pick a slot resorting to a map indexed by thread ids
 CROOT::RDF::RSnapshotOptionsA collection of options to steer the creation of the dataset on file
 CTMVA::Experimental::RStandardScaler< T >
 CROOT::Internal::RStl
 CROOT::Experimental::RStyleA set of defaults for graphics attributes, e.g
 CROOT::Internal::RTaskArenaWrapperWrapper for tbb::task_arena
 ►CROOT::Experimental::Detail::RPageStorage::RTaskSchedulerThe interface of a task scheduler to schedule page (de)compression tasks
 CTMVA::Experimental::RTensor< V, C >RTensor is a container with contiguous memory and shape information
 ►CTMVA::Experimental::RTensor< AFloat, TCpuBuffer< AFloat > >
 CTMVA::Experimental::RTensor< Value_t, Container_t >
 CTMVA::RuleImplementation of a rule
 CTMVA::RuleCutA class describing a 'rule cut'
 CTMVA::RuleEnsemble
 CTMVA::RuleFitA class implementing various fits of rule ensembles
 CTMVA::RuleFitAPIJ Friedman's RuleFit method
 CTMVA::RuleFitParamsA class doing the actual fitting of a linear model using rules as base functions
 CRooBatchCompute::RunContextThis struct enables passing computation data around between elements of a computation graph
 CROOT::Experimental::Detail::RClusterPool::RUnzipItemRequest to decompress and if necessary unpack compressed pages
 CROOT::Experimental::RFrame::RUserRanges
 CROOT::VecOps::RVec< T >A "std::vector"-like collection of values implementing handy operation to analyse them
 CROOT::VecOps::RVec< bool >
 CROOT::VecOps::RVec< double >
 CROOT::VecOps::RVec< float >
 CROOT::VecOps::RVec< int >
 CROOT::VecOps::RVec< Long64_t >
 CROOT::VecOps::RVec< ULong64_t >
 CROOT::VecOps::RVec< unsigned int >
 CROOT::Experimental::Internal::RVirtualBinsToLocalBins< I, NDIMS, BINS, AXES >Recursively converts zero-based virtual bins where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins, to the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention
 CROOT::Experimental::Internal::RVirtualBinsToLocalBins<-1, NDIMS, BINS, AXES >
 CROOT::Experimental::Internal::RVirtualCanvasPainterAbstract interface for painting a canvas
 CROOT::Experimental::RWebDisplayArgsHolds different arguments for starting browser with RWebDisplayHandle::Display() method
 CROOT::Experimental::RWebDisplayHandle
 CROOT::Experimental::RWebWindowRepresents web window, which can be shown in web browser or any other supported environment
 CROOT::Experimental::RWebWindowsManagerCentral instance to create and show web-based windows like Canvas or FitPanel
 CRooStats::HistFactory::Sample
 CTMVA::Experimental::SaveXGBoostSave an XGBoost to a ROOT file to be used with the fast tree inference system of TMVA
 CROOT::Experimental::RPadExtent::ScaleFactorA scale factor (separate factors for horizontal and vertical) for scaling a RPadLength
 CROOT::Experimental::RPadPos::ScaleFactorA scale factor (separate factors for horizontal and vertical) for scaling a RPadLength
 CROOT::Experimental::REveScene::SceneCommand
 CROOT::MacOSX::Util::ScopedArray< T >
 CMemstat::SCustomDigest
 CROOT::Math::SDeterminant< n, idim >Dsfact
 CSegment_tUsed for drawing line segments (maps to the X11 XSegments structure)
 CSelectionRulesThe class representing the collection of selection rules
 CROOT::Meta::Selection::SelectNoInstanceUsed to avoid to select all instances of a template
 CROOT::Internal::ParsingStateRAII::SemaExprCleanupsRAII
 CROOT::Internal::ParsingStateRAII::SemaParsingInitForAutoVarsRAII
 ►CTMVA::SeparationBaseAn interface to calculate the "SeparationGain" for different separation criteria used in various training algorithms
 CTStreamerInfoActions::TActionSequence::SequencePtr
 CXrdClientConn::SessionIDInfo
 ►CTMVA::DNN::SettingsSettings for the training of the neural net
 CSetWindowAttributes_tAttributes that can be used when creating or changing a window
 CROOT::Detail::TCollectionProxyInfo::SfinaeHelper
 CROOT::Internal::SHA256::sha256_t
 CROOT::Experimental::REveGeomDescription::ShapeDescr
 CRooStats::HistFactory::EstimateSummary::ShapeSys
 CTString::ShortStr_t
 CSHtmlExtensions_t
 CSHtmlIndex_t
 CSHtmlMargin_t
 CSHtmlStyle_t
 CSHtmlStyleStack_t
 CSHtmlTokenMap_t
 CROOT::Minuit2::SimplexParametersClass describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process
 CTMVA::SimulatedAnnealingBase implementation of simulated annealing fitting procedure
 CROOT::Minuit2::SinParameterTransformationClass for the transformation for double-limited parameter Using a sin function one goes from a double-limited parameter range to an unlimited one
 CROOT::Math::SInverter< T, n, idim >Dsinv
 CROOT::Math::SkipFunction< SkipNumber >
 CROOT::Math::SkipFunction< 0 >
 CROOT::Experimental::REveCaloData::SliceInfo_t
 CTEveCaloData::SliceInfo_t
 CROOT::Detail::RDF::CustomColExtraArgs::Slot
 CROOT::Detail::RDF::CustomColExtraArgs::SlotAndEntry
 CROOT::Math::SMatrix< T, D1, D2, R >SMatrix: a generic fixed size D1 x D2 Matrix class
 CROOT::Math::SMatrix< T, D1, D2, R >
 CROOT::Math::SMatrixIdentity
 CROOT::Math::SMatrixNoInit
 CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow
 CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const
 CTClingCXXRecMethIter::SpecFuncIter
 CSQLite3_Stmt_t
 CROOT::Math::Sqr< T >Unary Square Operation Class
 CROOT::Math::Sqrt< T >Unary Square Root Operation Class
 CROOT::Minuit2::SqrtLowParameterTransformationTransformation from external to internal Parameter based on sqrt(1 + x**2)
 CROOT::Minuit2::SqrtUpParameterTransformationTransformation from external to internal Parameter based on sqrt(1 + x**2)
 CROOT::Minuit2::StackAllocatorStackAllocator controls the memory allocation/deallocation of Minuit
 CROOT::Minuit2::StackAllocatorHolder
 CROOT::Minuit2::StackError
 CROOT::Minuit2::StackOverflowDefine stack allocator symbol
 ►CSTAT
 CTMVA::StatDialogBDT
 CTMVA::StatDialogBDTReg
 CTMVA::StatDialogMVAEffs
 CROOT::TVirtualRWMutex::StateEarlier lock state as returned by GetState() that can be passed to Restore()
 CROOT::TVirtualRWMutex::StateAndRecurseCount
 CROOT::TVirtualRWMutex::StateDeltaState as returned by GetStateDelta() that can be passed to Restore()
 CRooStats::HistFactory::StatErrorConfigConfiguration to automatically assign nuisance parameters for the statistical error of the Monte Carlo simulations
 CROOT::option::StatsDetermines the minimum lengths of the buffer and options arrays used for Parser
 CROOT::Math::StdEngine< Generator >Class to wrap engines fron the C++ standard random library in the ROOT Random interface
 CROOT::Math::StdEngineType< Generator >
 CROOT::Math::StdRandomEngine
 CTMVA::DNN::SteepestSteepest Gradient Descent algorithm (SGD)
 ►Cstd::streambuf
 CRooMsgService::StreamConfig
 CTGenCollectionProxy::StreamHelperHelper class to facilitate I/O
 CTGDMLWrite::StructLst
 CTGL5DPainter::Surf_t
 CTCling::SuspendAutoLoadingRAII
 CTInterpreter::SuspendAutoLoadingRAII
 CTInterpreter::SuspendAutoParsing
 CROOT::Math::SVector< T, D >SVector: a generic fixed size Vector class
 CTMVA::SVEventEvent class for Support Vector Machine
 CTMVA::SVKernelFunctionKernel for Support Vector Machine
 CTMVA::SVKernelMatrixKernel matrix for Support Vector Machine
 CTMVA::SVWorkingSetWorking class for Support Vector Machine
 CROOT::Minuit2::sym
 CSysInfo_t
 CTGTableLayout::TableData_t
 ►CTMVA::TActivationInterface for TNeuron activation function classes
 CTMVA::TActivationChooserClass for easily choosing activation functions
 CTakeAValue
 CROOT::TypeTraits::TakeFirstParameter< T >Return first of possibly many template parameters
 CROOT::TypeTraits::TakeFirstParameter< Template< T, Rest... > >
 CROOT::TypeTraits::TakeFirstType< T, Rest >
 CTAlienPackage
 ►CTApplicationImpABC describing GUI independent application implementation protocol
 CTArcBallImplements the arc-ball rotation manipulator
 ►CTArrayAbstract array base class
 CROOT::Internal::TArrayType< T, d >
 CROOT::Internal::TArrayType< T, 0 >
 ►Ctbb::task_arena
 CTASLogHandlerGuard
 CTAtomicCount
 CROOT::Internal::TAtomicPointer< T >Helper class to manage atomic pointers
 CROOT::Internal::TAtomicPointer< TObjArray * >
 ►CTAtt3DUse this attribute class when an object should have 3D capabilities
 ►CTAttAxisManages histogram axis attributes
 ►CTAttBBoxHelper for management of bounding-box information
 ►CTAttBBox2DAbstract base class for elements drawn in the editor
 CTAttCanvasManages canvas attributes
 ►CTAttFillFill Area Attributes class
 ►CTAttImageTImage attributes
 ►CTAttLineLine Attributes class
 ►CTAttMarkerMarker Attributes class
 ►CTAttPadManages default Pad attributes
 ►CTAttTextText Attributes class
 CTBase64This code implements the Base64 encoding and decoding
 CTMVA::DNN::TBatch< AArchitecture >TBatch
 CTMVA::DNN::TBatchIterator< Data_t, AArchitecture >TBatchIterator
 CTBinIterator
 CROOT::Internal::TBranchCacheInfo
 CROOT::Internal::TBranchIMTHelperA helper class for managing IMT work during TTree:Fill operations
 ►CROOT::Detail::TBranchProxyBase class for all the proxy object
 CROOT::Internal::TBranchProxyDirector
 CROOT::Internal::TBranchProxyHelper
 ►CTBrowserImpABC describing GUI independent browser implementation protocol
 CTBtItemItem stored in inner nodes of a TBtree
 ►CTBtNodeAbstract base class (ABC) of a TBtree node
 CTBuffer3DTypes
 CROOT::Experimental::TBufferMergerTBufferMerger is a class to facilitate writing data in parallel from multiple threads, while writing to a single output file
 CTOracleStatement::TBufferRec
 CROOT::Experimental::Internal::TBulkBranchReadHelper class for reading many branch entries at once to optimize throughput
 CROOT::Detail::RDF::RLoopManager::TCallback
 ►CTCanvasImpABC describing GUI independent main window (with menubar, scrollbars and a drawing area)
 ►CROOT::Internal::TCDGIILIBase
 CRgl::Mc::TCell< V >
 CTChainIndex::TChainIndexEntryHolds a description of indices of trees in the chain
 CROOT::Internal::TClaObjProxy< T >
 CROOT::Internal::TClassGetClassHelper< T >
 CTClassRefTClassRef is used to implement a permanent reference to a TClass object
 ►CTClassStreamer
 CTProofPlayer::TCleanup
 CTClingBaseClassInfoEmulation of the CINT BaseClassInfo class
 CTClingCallFuncEmulation of the CINT CallFunc class
 ►CTClingDeclInfo
 ►CTClingMemberIterIterate over all DeclT-s (or UsingShadowDecl-s pointing to DeclT-s) of a decl context, skipping those for which DerivedT::ShouldSkip(const Decl*) returns true when invoked with the Decl
 CTTree::TClusterIteratorHelper class to iterate over cluster of baskets
 CTCollectionProxyFactoryTCollectionProxyFactory Interface to collection proxy and streamer generator
 CROOT::Detail::TCollectionProxyInfo
 ►CTCollectionStreamerClass streamer object to implement TClassStreamer functionality for I/O emulation
 CTGLUtil::TColorLocker
 CTStreamerInfo::TCompInfo
 CTComplex
 CTStreamerInfoActions::TConfigurationBase class of the Configurations
 CTDirectory::TContextSmall helper to keep current directory context
 ►CTContextMenuImpThis class provides an interface to GUI independent context sensitive popup menus
 ►CTControlBarImpABC describing GUI independent control bar
 CTMVA::DNN::CNN::TConvParams
 CTMVA::DNN::TCpu< AReal >The TCpu architecture class
 CTMVA::DNN::TCpuBuffer< AFloat >TCpuBuffer
 CTMVA::DNN::TCpuMatrix< AFloat >The TCpuMatrix class
 CTCreatePrimitivesCreates new primitives
 CTMVA::DNN::TCuda< AReal >The TCuda architecture class
 CTMVA::DNN::TCudaDeviceBuffer< AFloat >TCudaDeviceBuffer
 CTMVA::DNN::TCudaDeviceReference< AFloat >TCudaDeviceReference
 CTMVA::DNN::TCudaHostBuffer< AFloat >TCudaHostBuffer
 CTMVA::DNN::TCudaMatrix< AFloat >TCudaMatrix Class
 CTMVA::DNN::TCudaTensor< AFloat >TCudaTensor Class
 CROOT::RDF::TCutInfo
 CTMVA::DNN::TDataLoader< Data_t, AArchitecture >TDataLoader
 CTMVA::DNN::TDataLoader< AData, TReference< AReal > >
 CROOT::Math::TDataPoint< K, _val_type >
 CROOT::Math::TDataPointN< _val_type >
 CTDatimeThis class stores the date and time with a precision of one second in an unsigned 32 bit word (950130 124559)
 CTDavixFileInternal
 CTClass::TDeclNameRegistry
 CTMVA::DNN::TDeepNet< Architecture_t, Layer_t >Generic Deep Neural Network class
 CTMVA::DNN::TDeepNet< Architecture_t, VGeneralLayer< Architecture_t > >
 ►CTMVA::DNN::TDescriptors
 CTMVA::DNN::TCpuBuffer< AFloat >::TDestructor
 CTMVA::DNN::TCudaDeviceBuffer< AFloat >::TDestructor
 CTMVA::DNN::TCudaHostBuffer< AFloat >::TDestructor
 CTMVA::DNN::TDeviceTDevice
 CROOT::Internal::TDirectoryAtomicAdapter
 CTMVA::DNN::TDLGradientDescent< Architecture_t >
 CTGLUtil::TDrawQualityModifier
 CTGLUtil::TDrawQualityScaler
 CTElementActionT< Element >
 CTElementPosActionT< Element >
 COuter::Template< T, U >
 ►C__parity::template __pmake
 COuter::Template< Inner, 1 >Simple specialisation
 COuter::Template< Template< Inner, 2 >, 1 >Complex specialisation
 CCPyCppyy::TemplateInfo
 CROOT::Internal::DictSelectionReader::TemplateInfo
 CCPyCppyy::TemplateProxy
 CCPyCppyy::CallContext::Temporary
 CTMVA::DNN::TCudaTensor< AFloat >::TensorDescriptor
 CROOT::Math::TensorMulOp< Vector1, Vector2 >Class for Tensor Multiplication (outer product) of two vectors giving a matrix
 CRgl::Pad::Tesselator
 ►CRooStats::TestStatisticTestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class
 ►CRooStats::TestStatSamplerTestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions
 ►CTEveChunkManagerVector-like container with chunked memory allocation
 ►CTEveElementBase class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management
 CTEveFrameBoxGLA class encapsulating GL rendering of TEveFrameBox via a static member function
 CTEveGeoManagerHolderException safe wrapper for setting gGeoManager
 CTEveElement::TEveListTreeInfoStructure holding information about TGListTree and TGListTreeItem that represents given TEveElement
 ►CTEveMagFieldAbstract base-class for interfacing to magnetic field needed by the TEveTrackPropagator
 CTEveManagerCentral application manager for Eve
 CTEvePadHolderException safe wrapper for setting gPad
 CTEvePathMarkT< TT >Special-point on track:
 ►CTEvePointSelectorConsumerTEvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the TEvePointSelector class
 ►CTEveProjectableAbstract base-class for non-linear projectable objects
 ►CTEveProjectedAbstract base class for classes that hold results of a non-linear projection transformation
 ►CTEveProjectionBase-class for non-linear projections
 ►CTEveRefCntBase-class for reference-counted objects
 ►CTEveSecondarySelectableSemi-abstract interface for classes supporting secondary-selection
 CTEveUtilStandard utility functions for Eve
 CTEveVector2T< TT >Minimal, templated two-vector
 ►CTEveVectorT< TT >Minimal, templated three-vector
 CTEveVectorT< Double_t >
 CTEveVectorT< Float_t >
 CTExceptionHandler
 CROOT::TExecutorCRTP< SubC >This class defines an interface to execute the same task multiple times, possibly in parallel and with different arguments every time
 ►CROOT::TExecutorCRTP< TExecutor >
 ►CROOT::TExecutorCRTP< TProcessExecutor >
 ►CROOT::TExecutorCRTP< TSequentialExecutor >
 ►CROOT::TExecutorCRTP< TThreadExecutor >
 CTExMapIter
 ►Cclang::TextDiagnosticPrinter
 CROOT::Quartz::TextLine
 CTLatex::TextSpec_tTLatex helper struct holding the attributes of a piece of text
 CROOT::Internal::TF1Builder< Func >Internal class used by TF1 for defining template specialization for different TF1 constructors
 CROOT::Internal::TF1Builder< const char * >TF1 building from a string used to build a TFormula based on a lambda function
 CROOT::Internal::TF1Builder< Func * >
 ►CTF1::TF1FunctorPointer
 CTF1ParametersTF1 Parameters class
 CTFileMergeInfo
 CTFitResultPtrProvides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointer, i.e
 CTFormulaFunctionHelper class for TFormula
 CTFormulaParamOrderFunctor defining the parameter order
 CTFormulaVariableAnother helper class for TFormula
 CTTree::TFriendLockHelper class to prevent infinite recursion in the usage of TTree Friends
 CROOT::Internal::TFriendProxy
 ►CROOT::Detail::TFutureImpl< T >
 CTGDimension
 CTGDMAssignmentHelper< T >
 CROOT::TGenericClassInfo
 ►CTGenericCollectionIterator
 ►CTGeoAttVisualization and tracking attributes for volumes and nodes
 CTGeoElemIterIterator for decay branches
 CTGeoFacet
 CTGeoIteratorA geometry iterator
 CTGeoMCBranchArrayContainerStoring and re-using geometry states of the TGeoManager in use by storing them as TGeoBranchArrays
 CTGeoRCPtr< T >A reference counting-managed pointer for classes derived from TGeoExtension which can be used as C pointer
 CTGeoStateInfoStatefull info for the current geometry level
 CTGFileInfo
 CTGInsets
 ►CTGLAxisPainter
 CTGLBoundingBoxConcrete class describing an orientated (free) or axis aligned box of 8 vertices
 CTGLBoxCutUsed by plot-painters to determine the area of the plot that is cut away
 CTGLCapabilityEnabler
 CTGLCapabilitySwitch
 CTGLColorClass encapsulating color information in preferred GL format - an array of four unsigned bytes
 CTGLColorSetClass encapsulating a set of colors used throughout standard rendering
 CTGLContextThis class encapsulates window-system specific information about a GL-context and alows their proper management in ROOT
 CTGLContextIdentityIdentifier of a shared GL-context
 CTGLContextPrivate
 CTGLDisableGuard
 CTGLEnableGuard
 CTGLFaderHelper
 CTGLFBOFrame-buffer object
 CTGLFloatHolder
 CTGLFontA wrapper class for FTFont
 CTGLFontManagerA FreeType GL font manager
 CTGLFormatEncapsulation of format / contents of an OpenGL buffer
 ►CTGListTreeItem
 CTGLLevelPalette
 CTGLLine33D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'
 ►CTGLLockableSimple locking interface used by viewer and scene
 ►CTGLLogicalShapeAbstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc
 CTGLMatrix16 component (4x4) transform matrix - column MAJOR as per GL
 CTGLongPosition
 CTGLOutputWrapper class for GL capture & output routines
 ►CTGLOverlayElementAn overlay element
 CTGLOverlayListManage a collection of overlay elements
 ►CTGLPaintDevice
 ►CTGLPhysicalShapeConcrete physical shape - a GL drawable
 CTGLPlane3D plane class - of format Ax + By + Cz + D = 0
 CTGLPlotBoxImplementation of a box around a histogram/function for plot-painters
 CTGLPlotCameraCamera for TGLPlotPainter and sub-classes
 CTGLPlotCoordinatesHelper class for plot-painters holding information about axis ranges, numbers of bins and flags if certain axis is logarithmic
 ►CTGLPShapeRefBase class for references to TGLPysicalShape that need to be notified when the shape is destroyed
 CTGLQuadricWrapper class for GLU quadric shape drawing object
 CTGLRectViewport (pixel base) 2D rectangle class
 CTGLRnrCtxAggregates data for a given redering context as needed by various parts of the ROOT's OpenGL infrastructure
 ►CTGLSceneInfoBase class for extended scene context
 CTGLSelectBufferEncapsulates OpenGL select buffer
 CTGLSelectionBuffer
 ►CTGLSelectRecordBaseBase class for select records
 CTGLStopwatchStopwatch object for timing GL work
 CTGLUtilWrapper class for various misc static functions - error checking, draw helpers etc
 ►CTGLVertex33 component (x/y/z) vertex class
 CTGMdiFrameList
 CTGMdiGeometry
 ►CTGNumberFormat
 CTGPasswdDialog
 CTGPosition
 CTMVA::DNN::TGradientDescent< Architecture_t >
 CROOT::TF1Helper::TGradientParFunctionFunction class representing the derivative with respect a parameter of a given TF1
 CTGRectangle
 CTGRedirectOutputGuard
 ►CRgl::Mc::TGridGeometry< V >
 ►CRgl::Mc::TGridGeometry< Double_t >
 ►CRgl::Mc::TGridGeometry< Float_t >
 CTGSearchType
 CTGText
 CTGTextBuffer
 CTGTextLine
 ►CRgl::TGuardBase
 ►CTGuiBuilder
 ►CTGWidget
 ►CTGWin32ProxyBaseProxy classes provide thread-safe interface to global objects
 CROOT::RDF::TH1DModelA struct which stores the parameters of a TH1D
 CTH1Merger
 CROOT::RDF::TH2DModelA struct which stores the parameters of a TH2D
 CRgl::Mc::TH3Adapter< H, E >
 CROOT::RDF::TH3DModelA struct which stores the parameters of a TH3D
 CROOT::Internal::THashConsistencyHolder< T >
 CTHistRange
 CTHistRenderingRegion
 CROOT::Internal::THnBaseBinIterIterator over THnBase bins (internal implementation)
 CTGeoBoolNode::ThreadData_t
 CTGeoPatternFinder::ThreadData_t
 CTGeoPgon::ThreadData_t
 CTGeoVolumeAssembly::ThreadData_t
 CTGeoXtru::ThreadData_t
 ►CTHttpWSEngine
 CTIdleTOTimerGuard
 CTStreamerInfoActions::TIDNode
 CTIndArray
 ►CROOT::Internal::TInitBehavior
 CTInspectorImpABC describing GUI independent object inspector (abstraction mainly needed for Win32
 CTVirtualCollectionPtrIterators::TInternalIterator
 ►CTClassEdit::TInterpreterLookupHelper
 ►CTInterpreterValue
 CROOT::TIOFeaturesTIOFeatures provides the end-user with the ability to change the IO behavior of data written via a TTree
 CRgl::Mc::TIsoMesh< V >
 CRgl::Mc::TIsoMesh< Double_t >
 CRgl::Mc::TIsoMesh< Float_t >
 ►CTIter
 ►CTIteratorIterator abstract base class
 CTKDEFGT
 CTKDE::TKernel
 CTLatex::TLatexFormSizeTLatex helper class used to compute the size of a portion of a formula
 CTMVA::DNN::TLayer< Architecture_t >Generic layer class
 CTLimitAlgorithm to compute 95% C.L
 CTLockGuard
 CTLockPathGuard
 CTStreamerInfoActions::TLoopConfigurationBase class of the Configurations for the member wise looping routines
 CTLorentzRotation::TLorentzRotationRow
 CTMakeProject
 CTMapRecKeep track of an object in the mapped file
 CTMatrixDEigenTMatrixDEigen
 CTMatrixDSymEigenTMatrixDSymEigen
 ►CTMatrixTColumn_const< Element >
 ►CTMatrixTDiag_const< Element >
 ►CTMatrixTFlat_const< Element >
 ►CTMatrixTRow_const< Element >
 ►CTMatrixTSparseDiag_const< Element >
 ►CTMatrixTSparseRow_const< Element >
 ►CTMatrixTSub_const< Element >
 CTMCManagerSingleton manager class for handling and steering a run with multiple TVirtualMC engines sharing events
 CTMCParticleStatus
 CTMCTemplateAutoLock< M, L, U >Template classe which provides a mechanism to create a mutex and locks/unlocks it
 ►CTMCTemplateAutoLock< TMCMutex, TMCthread_lock, TMCthread_unlock >
 CTMD5This code implements the MD5 message-digest algorithm
 CTMemberInspectorAbstract base class for accessing the data-members of a class
 ►CTMemberStreamer
 CTMemFile::TMemBlock
 CMemstat::TMemStatFAddrContainer
 CTMemStatHook
 CROOT::TModuleGenerator
 ►CTMPClientBase class for multiprocess applications' clients
 ►CTMPWorkerThis class works in conjuction with TMPClient, reacting to messages received from it as specified by the Notify and HandleInput methods
 CROOT::Internal::TMultiArrayType< T, d >
 CTMVA::TMVAGaussPair
 CTMVA::TMVAGUI
 CROOT::Internal::TNamedBranchProxy
 CTNDArrayRef< T >
 CTStreamerInfoActions::TNestedIDs
 CTMVA::DNN::TNet< Architecture_t, Layer_t >Generic neural network class
 ►CTMVA::TNeuronInputInterface for TNeuron input calculation classes
 CTMVA::TNeuronInputChooserClass for easily choosing neuron input functions
 ►CTNonCopyable
 CROOT::TMetaUtils::TNormalizedCtxt
 CROOT::TNumSlotsDefines the number of threads in some of ROOT's interfaces
 ►CTObjectMother of all ROOT objects
 ►CROOT::Internal::TObjProxy< T >
 CROOT::Experimental::RDirectory::ToContentType< T >
 CMemstat::ToLower_t
 CROOT::Detail::RDF::RLoopManager::TOneTimeCallback
 CToolBarData_t
 CTMVA::ToolsGlobal auxiliary applications and data treatment routines
 CROOT::Internal::TOperatorNewHelper
 CROOT::v5::TOperOffset
 ►CTPaletteEditorEdit the palette via a GUI
 CTMySQLStatement::TParamData
 CROOT::Internal::TParBranchProcessingRAII
 CTPickerStackGuard
 CTPoint
 CTStreamerInfo::TPointerCollectionAdapter
 ►CROOT::Internal::TDS::TPointerHolderMother class of TTypedPointerHolder
 CTPoints2-D graphics point (world coordinates)
 CTPosixThreadCleanUp
 ►CTPRegexp
 CROOT::RDF::TProfile1DModelA struct which stores the parameters of a TProfile
 CROOT::RDF::TProfile2DModelA struct which stores the parameters of a TProfile2D
 CTProfileHelper
 CTProofDebug
 CTProofLockPathGuard
 CTProofMergePrg
 CTProofProgressDialog
 CTProofServLogHandlerGuard
 CTProtoClass::TProtoRealData
 CTVirtualCollectionProxy::TPushPop
 CTPwdCtx
 CTPyArg
 CTPyReturn
 CTPythia6::TPythia6CleanerUtility class to manage the TPythia6 instance
 CTPythonAccessing the Python interpreter from C++
 ►CTQObjectThis is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html)
 CTMVA::TrainingHistoryTracking data from training
 ►CROOT::Math::TRandomEngine
 CTRandomEngine
 CTRangeDynCast< T >TRangeDynCast is an adaptater class that allows the typed iteration through a TCollection
 CROOT::Detail::TRangeStaticCast< T >TRangeStaticCast is an adaptater class that allows the typed iteration through a TCollection
 CROOT::Math::Impl::Transform3D< T >Basic 3D Transformation class describing a rotation and then a translation The internal data are a 3D rotation data (represented as a 3x3 matrix) and a 3D vector data
 CTMVA::TransformationHandlerClass that contains all the data information
 CROOT::Math::Impl::Translation3D< T >Class describing a 3 dimensional translation
 CROOT::Math::TransposeOp< Matrix, T, D1, D2 >Class for Transpose Operations
 CROOT::Math::TranspPolicy< T, D1, D2, R >Matrix transpose policy
 CROOT::Math::TranspPolicy< T, D1, D2, MatRepSym< T, D1 > >
 CROOT::TReadLockGuard
 ►CTRecorderState
 CTRedirectOutputGuard
 CTEveManager::TRedrawDisabler
 CROOT::TReentrantRWLock< MutexT, RecurseCountsT >
 CROOT::TReentrantRWLock< MutexT, ROOT::Internal::RecurseCounts >
 ►CTRefCntDefinitions for TRefCnt, base class for reference counted objects
 CTBits::TReference
 CTMVA::DNN::TReference< AReal >The reference architecture class
 CTRegexpRegular expression class
 CROOT::Math::Delaunay2D::Triangle
 CROOT::Experimental::EveGlu::TriangleCollector
 Ctriangulateio
 CTRootIOCtor
 CTRootSnifferScanRec
 CROOT::Internal::RootCling::TROOTSYSSetter
 CTRotation::TRotationRow
 CTRSA_fun
 ►Cstd::true_type
 CROOT::TRWSpinLock
 CROOT::TRWSpinLockReadGuard
 CROOT::TRWSpinLockWriteGuard
 CROOT::Internal::TSchemaHelper
 CROOT::Internal::TSchemaRuleProcessor
 CROOT::Internal::TSchemaType
 CROOT::TSeq< T >A pseudo container class which is a generator of indices
 CTMVA::DNN::TSharedLayer< Architecture_t >Layer class width shared weight and bias layers
 CTSimpleAnalysisA TSimpleAnalysis object creates histograms from a TChain
 CRgl::Mc::TSlice< V >
 CRgl::Mc::TSlice< ElementType_t >
 CRgl::Mc::TSourceAdapterSelector< class >
 CRgl::Mc::TSourceAdapterSelector< TF3 >
 CRgl::Mc::TSourceAdapterSelector< TH3C >
 CRgl::Mc::TSourceAdapterSelector< TH3D >
 CRgl::Mc::TSourceAdapterSelector< TH3F >
 CRgl::Mc::TSourceAdapterSelector< TH3I >
 CRgl::Mc::TSourceAdapterSelector< TH3S >
 CRgl::Mc::TSourceAdapterSelector< TKDEFGT >
 CROOT::Internal::TSpinLockGuardA spin mutex-as-code-guard class
 CROOT::TSpinMutexA spin mutex class which respects the STL interface for mutexes
 CRgl::Mc::TSplitterSelector< class, class >
 CRgl::Mc::TSplitterSelector< TF3, V >
 CRgl::Mc::TSplitterSelector< TH3C, V >
 CRgl::Mc::TSplitterSelector< TH3D, V >
 CRgl::Mc::TSplitterSelector< TH3F, V >
 CRgl::Mc::TSplitterSelector< TH3I, V >
 CRgl::Mc::TSplitterSelector< TH3S, V >
 CRgl::Mc::TSplitterSelector< TKDEFGT, V >
 CTClassEdit::TSplitType
 CTGenCollectionProxy::TStagingSmall helper to stage the content of an associative container when reading and before inserting it in the actual collection
 CROOT::Detail::TStatusBitsChecker
 CROOT::Internal::TStdBitsetHelper< T >
 CROOT::Internal::TStlObjProxy< T >
 CTStorageStorage manager
 ►CTStringBasic string class
 CROOT::Internal::TStringView
 CTSubStringA zero length substring is legal
 CTTabCom
 CTTableRange
 CROOT::Experimental::TTaskGroupA class to manage the asynchronous execution of work items
 CTMVA::DNN::TTensorBatch< Architecture_t >TTensorBatch
 CTMVA::DNN::TTensorBatchIterator< Data_t, Architecture_t >TTensorBatchIterator
 CTMVA::DNN::TTensorDataLoader< Data_t, Architecture_t >TTensorDataLoader
 CTMVA::DNN::TTensorDataLoader< AData, TReference< AReal > >
 CTTFInterface to the freetype 2 library
 CTTF::TTGlyphTTF helper class containing glyphs description
 CTThreadCleaner
 CROOT::TThreadedObject< T >A wrapper to make object instances thread private, lazily
 CROOT::TThreadedObject< ROOT::Internal::TTreeView >
 CTThreadPoolTask< aTask, aParam >
 CTThreadPoolTaskImp< aTask, aParam >
 CTTimeBasic time type with millisecond precision
 CTTimeStampThe TTimeStamp encapsulates seconds and ns since EPOCH
 CROOT::Experimental::REveDataItemList::TTip
 CTMVA::MethodDNN::TTrainingSettings
 CTMVA::TTrainingSettingsAll of the options that can be specified in the training string
 CTTreeClonerClass implementing or helping the various TTree cloning method
 ►CROOT::Internal::TTreeGeneratorBase
 CROOT::TTreeProcessorMTA class to process the entries of a TTree in parallel
 ►CROOT::Internal::TTreeReaderValueBaseBase class of TTreeReaderValue
 ►CROOT::Experimental::Internal::TTreeReaderValueFastBase
 CROOT::Internal::TTreeView
 CTTreeViewA helper class that encapsulates a file and a tree
 CTCling::TUniqueString
 CTGLLockable::TUnlocker
 CTUnuranTUnuran class
 ►CTUnuranBaseDistTUnuranBaseDist, base class for Unuran distribution classees such as TUnuranContDist (for one-dimension) or TUnuranMultiContDist (multi-dimension)
 CTUUIDThis class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier)
 CTVersionCheckUsed to check if the shared library or plugin is compatible with the current version of ROOT
 CTVirtualArrayWrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary
 ►CTVirtualAuth
 CTVirtualCollectionIteratorsSmall helper class to generically acquire and release iterators
 ►CTVirtualCollectionProxy
 CTVirtualCollectionPtrIterators
 CROOT::Internal::TVirtualCollectionReader
 ►CTVirtualDragManager
 ►CTVirtualGLManip
 ►CTVirtualGLPainter
 ►CTVirtualIsAProxy
 ►CTVirtualMutexThis class implements a mutex interface
 CTVirtualObjectWrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary
 ►CTVirtualPadEditorAbstract base class used by ROOT graphics editor
 ►CTVirtualPadPainterTo make it possible to use GL for 2D graphic in a TPad/TCanvas
 ►CTVirtualPaveStats
 ►CTVirtualRefProxy
 ►CTVirtualTableInterface
 CTVirtualVectorIterators
 CTWin32SplashThread
 CTWin32ThreadCleanUp
 ►CTMVA::DNN::TWorkspace
 CROOT::TWriteLockGuard
 ►CTXHandlerHandler of asynchronous events for XProofD sockets
 ►CTXMLSetup
 CTXNetSystemConnectGuard
 CTXSemaphoreGuard
 CTXSockBuf
 CTXSockPipe
 ►CTSourceAdapterSelector::Type_t
 ►CTSourceAdapterSelector::Type_t
 ►CTSplitterSelector::Type_t
 ►CTSplitterSelector::Type_t
 CCPyCppyy::typedefpointertoclassobject
 CROOT::TypeTraits::TypeList< Types >Lightweight storage for a collection of types
 CTMVA::TypesSingleton class for Global types used by TMVA
 CTypeTraits
 ►Cstd::unary_function
 Cunary_function
 CROOT::Math::UnaryOp< Operator, RHS, T >UnaryOperation class A class representing unary operators in the parse tree
 CRooRandomizeParamMCSModule::UniParam
 CRooRandomizeParamMCSModule::UniParamSet
 CROOT::Internal::UniqueLockRecurseCount
 CUnuranDistr< Function >UnuranDistr Provides free function based on TF1 to be called by unuran
 CUnuranDistrMulti< Function >Free functions for multidimensional functions needed bby UNURAN
 CUnuranRng< Random >UnuranRng class for interface ROOT random generators to Unuran
 CTTreeCacheUnzip::UnzipState
 CUserGroup_t
 CClingMemberIterInternal::UsingDeclIter::UsingDeclFrame
 CClingMemberIterInternal::UsingDeclIter
 CTString::UStr_t
 CTUUID::uuid_time_t
 CROOT::Experimental::RAttrBase::Val_t
 CCPyCppyy::Parameter::Value
 CROOT::Internal::TCheckHashRecursiveRemoveConsistency::Value
 CTGenCollectionProxy::ValueSmall helper to describe the Value_type or the key_type of an STL container
 CValue
 ►CROOT::Experimental::RAttrMap::Value_t
 CROOT::RDF::RSqliteDS::Value_tUsed to hold a single "cell" of the SELECT query's result table. Can be changed to std::variant once available
 CTMVA::VariableImportanceResult
 CROOT::Minuit2::VariableMetricEDMEstimator
 CTMVA::Config::VariablePlotting
 CTMVA::TransformationHandler::VariableStat
 CTMVA::MethodCFMlpANN_Utils::VARn2
 CTMVA::VarTransformHandler
 ►CROOT::Math::VavilovBase class describing a Vavilov distribution
 CROOT::Minuit2::vec
 CROOT::Math::VecExpr< ExprType, T, D >Expression wrapper class for Vector objects
 ►Cstd::vector< T >STL class
 ►Cstd::vector< const TSchemaRule * >
 ►Cstd::vector< std::vector< Double_t > >
 ►Cstd::vector< TVectorD >
 CROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 >Class for Vector-Matrix multiplication
 CROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 >
 CROOT::Minuit2::VectorOuterProduct< M, T >
 CROOT::Math::VegasParametersStructures collecting parameters for VEGAS multidimensional integration FOr implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
 CROOT::Geom::Vertex_t
 CTGLParametricPlot::Vertex_t
 ►CTMVA::DNN::VGeneralLayer< Architecture_t >Generic General Layer class
 ►CROOT::Math::VirtualIntegratorAbstract class for all numerical integration methods (1D and multi-dim) Interface defining the common methods for the numerical integrator classes of one and multi dimensions The derived class VirtualIntegratorOneDim defines the methods for one-dimensional integration
 CTMVA::VolumeVolume for BinarySearchTree
 ►CTMVA::DNN::VOptimizer< Architecture_t, Layer_t, DeepNet_t >Generic Optimizer class
 CTMVA::DNN::VOptimizer< Architecture_t, VGeneralLayer< Architecture_t >, TDeepNet< Architecture_t, VGeneralLayer< Architecture_t > > >
 CROOT::Experimental::RWebWindow::WebConn
 CROOT::MacOSX::X11::CommandBuffer::WidgetRect
 CWindowAttributes_tWindow attributes that can be inquired
 ►C<X11Drawable>
 CXColor_tDescription of a X11 color
 CXHandleErr_t
 CXHandleIn_t
 CROOT::MacOSX::X11::XLFDName
 CTMVA::Experimental::Internal::XMLConfigContainer for information extracted from TMVA XML config
 CXMLReader
 CXPClientArchiveRequest
 CXPClientInterruptRequest
 CXPClientLoginRequest
 CXPClientProofRequest
 CXPClientReadbufRequest
 CXPClientRequest
 CXPClientSendRcvRequest
 CXpdAdminCpCmd
 CXpdClientSessions
 CXpdEnv
 CXpdGroupEff_t
 CXpdGroupGlobal_t
 CXpdManagerCron_t
 CXpdMsg
 CXpdObject
 CXpdSrvMgrCreateCnt
 CXpdSrvMgrCreateGuard
 ►CXrdClientAbsUnsolMsgHandler
 CXrdClientCacheInterval
 CXrdClientConn
 CXrdClientEnv
 CXrdClientID
 CXrdClientInputBuffer
 CXrdClientMessage
 CXrdClientPhyConnLocker
 CXrdClientReadCache
 CXrdClientReadCacheItem
 CXrdClientSock
 CXrdClientSockConnectParms
 ►CXrdClientUnsolMsgSender
 CXrdClientUrlInfo
 CXrdClientVector< T >
 CXrdClientVector< ClientRequest >
 CXrdClientVector< XrdClientLogConnection * >
 CXrdClientVector< XrdClientMessage * >
 CXrdClientVector< XrdClientPhyConnection * >
 CXrdClientVector< XrdClientReadCacheItem * >
 ►CXrdJob
 CXrdPoll
 CXrdProofdAux
 CXrdProofdClient
 ►CXrdProofdConfig
 CXrdProofdDirective
 CXrdProofdDSInfo
 CXrdProofdFile
 CXrdProofdMultiStr
 CXrdProofdMultiStrToken
 CXrdProofdPInfo
 CXrdProofdPipe
 CXrdProofdPriority
 CXrdProofdProofServ
 CXrdProofdResponse
 CXrdProofdSandbox
 CXrdProofdSessionEntry
 CXrdProofGI
 CXrdProofGroup
 CXrdProofGroupMember
 CXrdProofGroupMgr
 CXrdProofQuery
 CXrdProofSessionInfo
 CXrdProofUI
 CXrdProofWorker
 ►CXrdProtocol
 CXrdROOT
 CXrdSrvBuffer
 CXrdSysPriv
 CXrdSysPrivGuard
 CXShapeEvent
 CTGDMLWrite::Xyz
 CTMemFile::ZeroCopyView_tA read-only memory range which we do not control
 ►CROOT::Experimental::Detail::BASES
 Cbool
 CCGContextRef
 CCGImageRef
 CDouble_t
 CEngineType *
 CFloat_t
 Cint
 CLong64_t
 CMutexT
 CR
 CTMCMutex *
 CTMCthread_lock
 CTMCthread_unlock
 CULong64_t
 Cunsigned int