Logo ROOT   6.07/09
Reference Guide
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345678910]
 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::Experimental::Internal::TUniWeakPtr< T >::AccessorGives transparent access to the shared or unique pointer
 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< std::vector< Bool_t >::const_reference >
 ►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
 Cstd::__ROOT::array_view< T >
 CRooStats::HistFactory::Asimov
 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 TAxisConfig of whatever kind to the corresponding TAxisBase-derived object
 CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kEquidistant >
 CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kGrow >
 CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kIrregular >
 CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kLabels >
 CBalancerInfo
 CRooStats::HistFactory::RooBarlowBeestonLL::BarlowCache
 ►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 >
 Cbasic_string_view< char >
 CROOT::Minuit2::BasicFunctionGradient
 CROOT::Minuit2::BasicFunctionMinimumResult of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum
 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
 CTMVA::DNN::BatchEncapsulates one mini-batch
 CTMVA::BDTEventWrapper
 CRooStats::BernsteinCorrectionBernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term
 CBidirMMapPipeBidirMMapPipe creates a bidirectional channel between the current process and a child it forks
 ►Cbinary_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::BinaryTree
 CTMVA::OptionMap::Binding
 CBinomialNeymanInterval< Sorter >
 ►CBinomialNeymanInterval< FeldmanCousinsSorter >
 CBinomialProbHelper
 CROOT::Fit::BinPointObsolete class, no more in use
 CRooMultiVarGaussian::BitBlock
 CROOT::Math::GenVector_detail::BitReproducible
 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 >
 CRooNDKeysPdf::BoxInfo
 CTGeoBatemanSol::BtCoef_t
 ►CRooSimWSTool::BuildConfig
 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< Double32_t >
 CROOT::Math::Cartesian3D< Scalar >
 CRooVectorDataStore::CatVector
 CTMVA::CCPruner
 CTMVA::CCTreeWrapper
 CTFITSHDU::Cell
 CTEveCaloLegoGL::Cell2D_t
 ►CTEveCaloData::CellGeom_tCell geometry inner structure
 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::Channel
 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
 Cstd::__ROOT::check_bound_t
 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 >
 CROOT::Meta::Selection::ClassAttributes< classAttributes >Used to specify attributes of classes in the "DictSelection" syntax
 CRooWorkspace::CodeRepo::ClassFiles
 CTMVA::ClassifierFactory
 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 >
 CClusterD
 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::Config
 CRooStats::HistFactory::ConfigParser
 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
 CContextSmall helper to keep current directory context
 CROOT::Minuit2::ContoursError
 ►CTMVA::ConvergenceTest
 CROOT::Math::CoordinateTraits< C >
 CROOT::Math::CoordinateTraits< Cartesian3D< Scalar > >
 CROOT::Math::CoordinateTraits< Cylindrical3D< Scalar > >
 CROOT::Math::CoordinateTraits< CylindricalEta3D< Scalar > >
 CROOT::Math::CoordinateTraits< Polar3D< Scalar > >
 CROOT::Math::CoordinateTraits< PtEtaPhiE4D< Scalar > >
 CROOT::Math::CoordinateTraits< PtEtaPhiM4D< Scalar > >
 CROOT::Math::CoordinateTraits< PxPyPzE4D< Scalar > >
 CROOT::Math::CoordinateTraits< PxPyPzM4D< Scalar > >
 CCpuInfo_t
 CROOT::Minuit2::MnCross::CrossFcnLimit
 CROOT::Minuit2::MnCross::CrossNewMin
 CROOT::Minuit2::MnCross::CrossParLimit
 CTMVA::CrossValidationResult
 CROOT::Math::KDTree< _DataPoint >::Cut
 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::Fit::DataVectorClass holding the fit data points
 CROOT::Fit::DataWrapperClass maintaining a pointer to external data Using this class avoids copying the data when performing a fit NOTE: this class is not thread-safe and should not be used in parallel fits
 CROOT::Math::GenVector_detail::BitReproducible::DB8
 CROOT::Math::DefaultCoordinateSystemTagDefaultCoordinateSystemTag Default tag for identifying any coordinate system
 CROOT::Math::Delaunay2DClass to generate a Delaunay triangulation of a 2D set of points
 CTMVA::DeleteFunctor_t< T >
 CROOT::Math::DerivatorClass for computing numerical derivative of a function
 CTKSocket::Desc_t
 CRooStats::DetailedOutputAggregator
 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
 ►CTEveDigitSet::DigitBase_t
 ►CDigitBase_t
 CDiscrDistFree functions adapter needed by UNURAN for one-dimensional discrete distribution
 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::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
 CTGLScene::DrawElement_t
 CRooPlot::DrawOpt
 CTMVA::DTNodeTrainingInfo
 CDUMMY
 CROOT::Fit::DummyDeleter< T >
 CTEveGeoPolyShape::Edge_t
 CTEvePolygonSetProjectedGL::Edge_t
 CTBranchSTL::ElementBranchHelper_t
 CRooMappedCategory::Entry
 ►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::Math::EvaluatorOneDim< MultiFuncType >
 CROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
 CTMVA::kNN::Event
 CEvent_t
 CTMVA::QuickMVAProbEstimator::EventInfo
 CTMVA::DataSetFactory::EventStats
 CROOT::MacOSX::X11::EventTranslator
 ►Cstd::exceptionSTL class
 CExceptionContext_t
 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
 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
 ►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
 CROOT::Minuit2::FlatRandomGen
 CTEveParamList::FloatConfig_t
 CFontAttributes_t
 CROOT::MacOSX::Details::FontCache
 CROOT::MacOSX::Details::FontCache::FontList
 CFontMetrics_t
 CTGFontDialog::FontProp_t
 CFoption_t
 CTLatex::FormSize_tTLatex helper struct holding the dimensions of a piece of text
 CFUMILI2
 ►CFuncCacheElem
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F >
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F * >
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *const >
 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
 ►CFunType
 CRooRandomizeParamMCSModule::GausParam
 CRooRandomizeParamMCSModule::GausParamSet
 CROOT::Minuit2::GaussDataGen
 CROOT::Minuit2::GaussFunction
 CROOT::Minuit2::GaussRandomGen
 CGcCache_t
 CGCValues_t
 CROOT::Minuit2::gen
 CRooMultiVarGaussian::GenData
 ►CROOT::Minuit2::GenericFunctionClass from which all the other classes, representing functions, inherit
 CTMVA::GeneticAlgorithm
 CTMVA::GeneticGenes
 CROOT::Math::GeneticMinimizerParameters
 CTMVA::GeneticPopulation
 CTMVA::GeneticRange
 CRooAbsPdf::GenSpec
 CTLeaf::GetValueHelper< T >
 CTFormLeafInfo::GetValueHelper< T >
 CTLeaf::GetValueHelper< Long64_t >
 CTFormLeafInfo::GetValueHelper< Long64_t >
 CTLeaf::GetValueHelper< LongDouble_t >
 CTFormLeafInfo::GetValueHelper< LongDouble_t >
 CTLeaf::GetValueHelper< ULong64_t >
 CTFormLeafInfo::GetValueHelper< ULong64_t >
 CRgl::Pad::GLLimits
 CROOT::Math::GlobalCoordinateSystemTagTag for identifying vectors based on a global coordinate system
 CROOT::Math::GoFTest
 ►CROOT::Minuit2::GradientCalculatorInterface class for gradient calculators
 Cgroup
 CROOT::Experimental::TAxisConfig::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
 CGSL_BFGS
 CGSL_BFGS2
 CGSL_FR
 CGSL_NLS
 CGSL_PR
 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 >
 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
 CTClingValue::HasTheSameSizeAsClingValue
 CTFITSHDU::HDURecord
 CTEveTrackPropagator::Helix_t
 CHelperOps
 CHEPEVT_DEFHEPEVT common block
 CRooStats::HistFactory::HistFactoryNavigation
 CRooStats::HistFactory::HistoFactor
 CRooStats::HistFactory::HistoSys
 CRooStats::HistFactory::HistRef
 CHoption_tHistogram option structure
 CHparam_tHistogram parameters structure
 ►CRooStats::HypoTestCalculatorHypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults
 ►CIBaseFunc
 ►CROOT::Math::IBaseFunctionMultiDimDocumentation for the abstract class IBaseFunctionMultiDim
 ►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
 Cvdt::details::ieee754Used to switch between different type of interpretations of the data (64 bits)
 ►CRooFactoryWSTool::IFace
 ►CTMVA::IFitterTarget
 ►CROOT::Math::IGradientMultiDimGradient 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::IMethod
 ►CROOT::Math::IMinimizer1DInterface class for numerical methods for one-dimensional minimization
 CBidirMMapPipe_impl::Pages::implImplementation
 ►CImpl
 CTMVA::Increment< T >
 CROOT::Math::rowOffsetsUtils::indices<... >
 Cstd::__ROOT::detail::indices< Indices >
 CTClass::InsertTClassInRegistryRAII
 CTEveParamList::IntConfig_t
 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
 ►CInterpreterCallbacks
 ►CTMVA::Interval
 ►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
 ►CROOT::Math::IOptionsGeneric interface for defining configuration options of a numerical algorithm
 ►Cstd::ios_baseSTL class
 ►CTMVA::IPruneTool
 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
 Cstd::__ROOT::detail::is_array_class< Array >
 Cstd::__ROOT::detail::is_array_class< std::array< T, N > >
 Cstd::__ROOT::detail::is_array_class< std::initializer_list< T > >
 Cstd::__ROOT::detail::is_array_class< std::vector< T > >
 CTEveChunkManager::iterator
 CROOT::Math::KDTree< _DataPoint >::iterator
 ►Citerator
 CTGenericTable::iterator
 CTIndexTable::iterator
 CTTable::iterator
 ►Citerator_traits
 CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, large >Small helper to implement the function to create,access and destroy iterators
 CROOT::Detail::TCollectionProxyInfo::Type< std::vector< Bool_t > >::Iterators
 CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators
 CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, true >
 CROOT::Detail::TCollectionProxyInfo::Iterators< std::vector< T >, false >
 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 * >
 CTMVA::KDEKernel
 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::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
 CTMVA::LDA
 CTMath::Limits< T >
 CTEveStraightLineSet::Line_t
 CLINEAR
 CRgl::Pad::LineAttribSet
 CTHtml::LinkInfo_t
 CROOT::Math::LocalCoordinateSystemTagTag for identifying vectors based on a local coordinate system
 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
 CROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > >
 CROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< Double32_t > >
 ►CTMVA::LossFunction
 CTMVA::LossFunctionEventInfo
 CROOT::Math::rowOffsetsUtils::make_indices_impl< I, IndexTuple, N >
 Cstd::__ROOT::detail::make_indices_impl< First, Step, N, class >
 Cstd::__ROOT::detail::make_indices_impl< First, Step, N, typename std::enable_if<(N==0)>::type >
 Cstd::__ROOT::detail::make_indices_impl< First, Step, N, typename std::enable_if<(N==1)>::type >
 ►CROOT::Math::rowOffsetsUtils::make_indices_impl< 0, indices<>, N >
 ►Cstd::__ROOT::detail::make_indices_impl< First, Step,((Last-First)+(Step-1))/Step >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< I, indices< Indices... >, N >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< N, indices< Indices... >, N >
 Cstd::__ROOT::detail::make_indices_next< IndicesType, Next >
 Cstd::__ROOT::detail::make_indices_next2< IndicesType, Next, Tail >
 ►Cstd::__ROOT::detail::make_indices_next2< detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step, First+(N-1)*Step >
 Cstd::__ROOT::detail::make_indices_next2< indices< Indices... >, Next, Tail >
 ►Cstd::__ROOT::detail::make_indices_next< detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step >
 Cstd::__ROOT::detail::make_indices_next< indices< Indices... >, Next >
 CROOT::Math::detail::manipulator< char_t >
 ►Cstd::map< K, T >STL class
 CTEveStraightLineSet::Marker_t
 CRgl::Pad::MarkerPainter
 CROOT::Math::MathMoreLibrary
 CROOT::Math::MatRepStd< T, D1, D2 >Expression wrapper class for Matrix objects
 CROOT::Math::MatRepStd< double, 5, 5 >
 CROOT::Math::MatRepStd< Double32_t, 5, 5 >
 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::Math::MatRepSym< double, N_CITIES >
 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
 CMemInfo_t
 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_Utils
 CPyROOT::MethodProxy::MethodInfo_t
 CPyROOT::MethodProxy
 Cmg_callbacks
 Cmg_client_options
 Cmg_form_data_handler
 Cmg_request_info::mg_header
 Cmg_option
 Cmg_request_info
 Cmg_server_ports
 ►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
 CMINUIT2
 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
 CROOT::Math::MixMaxEngineImpl< N >
 CROOT::Math::MixMaxEngineImpl< _N >
 CROOT::Minuit2::BasicFunctionMinimum::MnAboveMaxEdm
 CROOT::Minuit2::FunctionMinimum::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::MinimumError::MnHesseFailed
 CROOT::Minuit2::BasicMinimumError::MnInvertFailed
 CROOT::Minuit2::MinimumError::MnInvertFailed
 CROOT::Minuit2::MnLineSearchImplements a 1-dimensional minimization along a given direction (i.e
 CROOT::Minuit2::MnMachinePrecisionDetermines the relative floating point arithmetic precision
 CROOT::Minuit2::BasicMinimumError::MnMadePosDef
 CROOT::Minuit2::MinimumError::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::MinimumError::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::FunctionMinimum::MnReachedCallLimit
 CROOT::Minuit2::MnRefCountedPointer< T >
 CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionGradient >
 CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionMinimum >
 CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumError >
 CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumParameters >
 CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumSeed >
 CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumState >
 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
 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
 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
 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::Node
 CTMVA::kNN::Node< T >
 CTMVA::kNN::Node< TMVA::kNN::Event >
 CRooStats::HistFactory::EstimateSummary::NormFactor
 CRooStats::HistFactory::NormFactor
 ►C<NSApplicationDelegate>
 ►CNSObject
 CROOT::MacOSX::Util::NSScopeGuard< DerivedType >
 CROOT::MacOSX::Util::NSScopeGuard< ROOTApplicationDelegate >
 CROOT::MacOSX::Util::NSStrongReference< DerivedType >
 CROOT::MacOSX::Util::NSStrongReference< NSObject< X11Drawable-p > >
 CROOT::MacOSX::Util::NSStrongReference< NSOpenGLContext >
 CROOT::MacOSX::Util::NSStrongReference< QuartzWindow >
 ►CNSView
 ►CNSWindow
 ►C<NSWindowDelegate>
 CRooStats::NuisanceParametersSamplerHelper class for ToyMCSampler
 CTMVA::null_t< F >
 CROOT::Math::NullTypeFunc1D
 CRooStats::NumberCountingPdfFactory
 CRooSimWSTool::ObjBuildConfig
 ►Cobject
 CPyROOT::ObjectProxy
 CRooSimWSTool::ObjSplitRule
 CTODBCStatement::ODBCBufferRec_t
 CRgl::Pad::OffScreenDevice
 CTMVA::OptionMapClass to storage options for the differents methods
 CROOT::Experimental::TFile::Options_tOptions for TFile construction
 CTHtml::OutputStyle_t
 CRooStats::HistFactory::OverallSys
 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 >
 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::ParamFunctionBaseClass defining the signature for multi-dim parametric functions
 CROOT::Math::ParamFunctorParam Functor class for Multidimensional functions
 Cpasswd
 CTHtml::PathInfo_t
 CPattern
 ►CPdfCacheElem
 CPgSQL_Stmt_t
 CPictureAttributes_t
 CXrdPoll::PipeData
 CTTable::piterator
 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::Plane3DClass 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 )
 CTColorGradient::Point
 CROOT::MacOSX::X11::Point
 CTProofDrawListOfGraphs::Point3D_t
 CTProofDrawListOfPolyMarkers3D::Point4D_t
 CPoint_t
 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
 CTEvePolygonSetProjected::Polygon_t
 CRgl::Pad::PolygonStippleSet
 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
 CROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double > >
 CROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< Double32_t > >
 CRooStats::HistFactory::PreprocessFunction
 CTEveProjection::PreScaleEntry_t
 CProcInfo_t
 CRooStats::ProfileInspector
 CTGLSurfacePainter::Projection_t
 CRooStats::ProofConfigHolds configuration options for proof and proof-lite
 CProofServEnv_t
 CPyROOT::PropertyProxy
 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::PxPyPzE4D< double >
 CROOT::Math::PxPyPzE4D< Double32_t >
 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
 ►CPyROOT::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
 CPyROOT::PyGILRAII
 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
 CPypars_tPythia6 common block Pypars
 CPyROOT::PyRootClassType object to hold TClassRef instance (this is only semantically a presentation of PyRootType instances, not in a C++ sense)
 CPyssmt_tPythia6 common block Pyssmt
 CPysubs_tPythia6 common block Pysubs
 ►CQ3MainWindow
 ►CQApplication
 ►CQObject
 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)
 CTMVA::QuickMVAProbEstimator
 ►CQVBox
 ►CQWidget
 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
 CTMVA::Rank
 CTMVA::Ranking
 CTString::RawStr_t
 CROOT::TMetaUtils::RConstructorType
 CTFormLeafInfo::ReadValueHelper< T >
 CTFormLeafInfo::ReadValueHelper< Long64_t >
 CTFormLeafInfo::ReadValueHelper< LongDouble_t >
 CTFormLeafInfo::ReadValueHelper< ULong64_t >
 CTMVA::RuleFitAPI::RealParms
 ►CRooVectorDataStore::RealVector
 CTEveCaloData::RebinData_t
 CROOT::MacOSX::X11::Rectangle
 CRectangle_t
 ►CRecursiveASTVisitor
 CRedirectHandle_t
 Credirguard
 CROOT::ExecutorUtils::ReduceObjects< T >Merge collection of TObjects
 CTMVA::RegressionVariance
 CTString::Rep_t
 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::MacOSX::X11::ColorParser::RGB_t
 CROOT::Math::RichardsonDerivatorUser class for calculating the derivatives of a function
 Crng_state_st
 CTMVA::ROCCalc
 CTMVA::ROCCurve
 ►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
 CRooBlindTools
 CRooCFunction1Map< VO, VI >
 CRooCFunction2Map< VO, VI1, VI2 >
 CRooCFunction3Map< VO, VI1, VI2, VI3 >
 CRooCFunction4Map< VO, VI1, VI2, VI3, VI4 >
 CRooComplexClass RooComplex is a simple container class for complex values
 ►CRooDirItemRooDirItem is a utility base class for RooFit objects that are to be attached to ROOT directories
 CRooErrorHandler
 CRooFIter
 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
 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 purposes singleton class that terminates all other RooFit singleton services when the process exists
 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
 CROOT::Math::Rotation3DRotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
 CROOT::Math::RotationTraits< C >
 CROOT::Math::RotationTraits< AxisAngle >
 CROOT::Math::RotationTraits< EulerAngles >
 CROOT::Math::RotationTraits< LorentzRotation >
 CROOT::Math::RotationTraits< Quaternion >
 CROOT::Math::RotationTraits< Rotation3D >
 CROOT::Math::RotationTraits< RotationX >
 CROOT::Math::RotationTraits< RotationY >
 CROOT::Math::RotationTraits< RotationZ >
 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 new Y' axis, followed by a third rotation of an angle psi (roll) about the final 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
 Crsa_KEY
 Crsa_KEY_export
 Crsa_NUMBER
 CROOT::Internal::RStl
 CTMVA::Rule
 CTMVA::RuleCut
 CTMVA::RuleEnsemble
 CTMVA::RuleFit
 CTMVA::RuleFitAPI
 CTMVA::RuleFitParams
 CRooStats::HistFactory::Sample
 CROOT::MacOSX::Util::ScopedArray< T >
 CMemstat::SCustomDigest
 CROOT::Math::SDeterminant< n, idim >Dsfact
 CSegment_t
 CSelectionRulesThe class representing the collection of selection rules
 CROOT::Meta::Selection::SelectNoInstanceUsed to avoid to select all instances of a template
 ►CTMVA::SeparationBase
 CXrdClientConn::SessionIDInfo
 ►CTMVA::DNN::SettingsSettings for the training of the neural net
 CSetWindowAttributes_t
 CROOT::Detail::TCollectionProxyInfo::SfinaeHelper
 CRooStats::HistFactory::ShapeFactor
 CRooStats::HistFactory::EstimateSummary::ShapeSys
 CRooStats::HistFactory::ShapeSys
 CTString::ShortStr_t
 CSHtmlExtensions_t
 CSHtmlIndex_t
 CSHtmlMargin_t
 CSHtmlStyle_t
 CSHtmlStyleStack_t
 CSHtmlTokenMap_t
 CshutterData_t
 CROOT::Minuit2::SimplexParametersClass describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process
 CTMVA::SimulatedAnnealing
 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 >
 CTEveCaloData::SliceInfo_t
 CROOT::Math::SMatrix< T, D1, D2, R >SMatrix: a generic fixed size D1 x D2 Matrix class
 CROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepStd< double, 5, 5 > >
 CROOT::Math::SMatrix< double, N_CITIES, N_CITIES, MatRepSym< double, N_CITIES > >
 CROOT::Math::SMatrix< Double32_t, 5, 5, ROOT::Math::MatRepStd< Double32_t, 5, 5 > >
 CROOT::Math::SMatrixIdentity
 CROOT::Math::SMatrixNoInit
 CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow
 CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const
 CRoo2DMomentMorphFunction::SorterL2H
 CRooNDKeysPdf::SorterTV_L2HSorter function
 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
 CRooStats::HistFactory::StatError
 CRooStats::HistFactory::StatErrorConfig
 CROOT::Math::StdEngine< Generator >Wrapper class for std::random generator to be included in ROOT
 CROOT::Math::StdEngineType< Generator >
 CROOT::Math::StdEngineType< std::knuth_b >
 CROOT::Math::StdEngineType< std::minstd_rand >
 CROOT::Math::StdEngineType< std::mt19937 >
 CROOT::Math::StdEngineType< std::mt19937_64 >
 CROOT::Math::StdEngineType< std::random_device >
 CROOT::Math::StdEngineType< std::ranlux24 >
 CROOT::Math::StdEngineType< std::ranlux48 >
 CROOT::Math::StdRandomEngine
 CTMVA::DNN::SteepestSteepest Gradient Descent algorithm (SGD)
 ►Cstreambuf
 CRooMsgService::StreamConfig
 CTGenCollectionProxy::StreamHelperHelper class to facilitate I/O
 CTGDMLWrite::StructLst
 CTGL5DPainter::Surf_t
 CTInterpreter::SuspendAutoParsing
 CROOT::Math::SVector< T, D >SVector: a generic fixed size Vector class
 CTMVA::SVEvent
 CTMVA::SVKernelFunction
 CTMVA::SVKernelMatrix
 CTMVA::SVWorkingSet
 CROOT::Minuit2::sym
 CSysInfo_t
 CTGTableLayout::TableData_t
 CtableDescriptor_st
 ►CTMVA::TActivation
 CTMVA::TActivationChooser
 CTAlienPackage
 CTAnyPtrModels a shared pointer or a unique pointer
 ►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 >
 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
 ►CROOT::Experimental::TAxisBaseHistogram axis base class
 CROOT::Experimental::TAxisViewCommon view on a TAxis, no matter what its kind
 CTBase64This code implements the Base64 encoding and decoding
 CTMVA::DNN::TBatch< AArchitecture >TBatch
 CTMVA::DNN::TBatchIterator< Data_t, AArchitecture >TBatchIterator
 CROOT::Experimental::THistDataMomentUncert< DIMENSIONS, PRECISION, STORAGE >::TBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::THistStatContent< DIMENSIONS, PRECISION, STORAGE >::TBinStatModifying view on a THistStatContent for a given bin
 CROOT::Experimental::THistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION, STORAGE >::TBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::THistStatTotalSumOfWeights< DIMENSIONS, PRECISION, STORAGE >::TBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::THistStatUncertainty< DIMENSIONS, PRECISION, STORAGE >::TBinStatModifying view on a THistStatUncertainty for a given bin
 CROOT::Experimental::THistStatRuntime< DIMENSIONS, PRECISION, STORAGE >::TBinStatNo-op; this class does not provide per-bin statistics
 ►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
 CTOracleStatement::TBufferRec
 CPyROOT::TCallContext
 CROOT::Experimental::TCanvasGraphic container for TDrawable-s
 ►CTCanvasImpABC describing GUI independent main window (with menubar, scrollbars and a drawing area)
 CRgl::Mc::TCell< V >
 CRgl::Mc::TCell< ElementType_t >
 CTChainIndex::TChainIndexEntryHolds a description of indices of trees in the chain
 CTCL
 CROOT::Internal::TClaObjProxy< 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
 CTClingClassInfoEmulation of the CINT ClassInfo class
 CTClingDataMemberInfoEmulation of the CINT DataMemberInfo class
 CTClingMethodArgInfoEmulation of the CINT MethodInfo class
 CTClingMethodInfoEmulation of the CINT MethodInfo class
 CTClingTypedefInfoEmulation of the CINT TypedefInfo class
 CTClingTypeInfoEmulation of the CINT TypeInfo class
 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
 CROOT::Experimental::THistStatContent< DIMENSIONS, PRECISION, STORAGE >::TConstBinStatConst view on a THistStatContent for a given bin
 CROOT::Experimental::THistStatUncertainty< DIMENSIONS, PRECISION, STORAGE >::TConstBinStatConst view on a THistStatUncertainty for a given bin
 CTDirectory::TContext
 ►CTContextMenuImpThis class provides an interface to GUI independent context sensitive popup menus
 ►CTControlBarImpABC describing GUI independent control bar
 ►CPyROOT::TConverter
 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< AFloat >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::TDataLoader< Data_t, AArchitecture >TDataLoader
 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::TCudaDeviceBuffer< AFloat >::TDestructor
 CTMVA::DNN::TCpuBuffer< AFloat >::TDestructor
 CTMVA::DNN::TCudaHostBuffer< AFloat >::TDestructor
 CTMVA::DNN::TDeviceTDevice
 ►CROOT::Experimental::TDirectoryKey/value store of objects
 CROOT::Experimental::Internal::TDirectoryEntry
 ►CROOT::Experimental::Internal::TDrawableBase class for drawable entities: objects that can be painted on a TPad
 CTGLUtil::TDrawQualityModifier
 CTGLUtil::TDrawQualityScaler
 CTDsKey
 CTElementActionT< Element >
 CTElementPosActionT< Element >
 CPyROOT::TemplateProxyTemplate proxy object to return functions and methods
 CROOT::Math::TensorMulOp< Vector1, Vector2 >Class for Tensor Multiplication (outer product) of two vectors giving a matrix
 CRgl::Pad::Tesselator
 Ctest.test
 ►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 >
 CROOT::TExecutor< subc >
 ►CPyROOT::TExecutor
 ►CROOT::TExecutor< TProcessExecutor >
 CTExMapIter
 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
 CTF1ConvolutionClass wrapping convolution of two functions
 CTF1NormSumClass adding two functions: c1*f1+c2*f2
 CTF1ParametersTF1 Parameters class
 CTFileMergeInfo
 CROOT::Experimental::TFilePtrPoints to an object that stores or reads objects in ROOT's binary format
 CROOT::Experimental::Internal::TFillBinCoord< I, COORD, AXES >Fill coord with low bin edge or center or high bin edge of all axes
 CROOT::Experimental::Internal::TFillBinCoord<-1, COORD, AXES >
 CROOT::Experimental::Internal::TFillIterRange< I, AXES >Fill range with begin() and end() of all axes, including under/overflow as specified by over
 CROOT::Experimental::Internal::TFillIterRange<-1, AXES >
 CROOT::Experimental::TFitResult
 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
 CTFUMILI
 CROOT::Experimental::TFunction< DIMENSION >
 CTGDimension
 CTGDMAssignmentHelper< T >
 CROOT::TGenericClassInfo
 ►CTGenericCollectionIterator
 ►CTGeoAttVisualization and tracking attributes for volumes and nodes
 CTGeoElemIterIterator for decay branches
 CTGeoIteratorA geometry iterator
 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
 CTGeoToOCC
 CROOT::Experimental::Internal::TGetBinCount< I, AXES >
 CROOT::Experimental::Internal::TGetBinCount< 0, AXES >
 CROOT::Experimental::Internal::TGetBinIndex< I, HISTIMPL, AXES, GROW >
 CROOT::Experimental::Internal::TGetBinIndex< -1, HISTIMPL, AXES, GROW >
 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
 CTGWin32InterpreterProxyThis class defines thread-safe interface to a command line interpreter
 ►CTGWin32ProxyBaseProxy classes provide thread-safe interface to global objects
 CTH1Merger
 CRgl::Mc::TH3Adapter< H, E >
 CROOT::Experimental::THist< DIMENSIONS, PRECISION, STAT >Histogram class for histograms with DIMENSIONS dimensions, where each bin count is stored by a value of type PRECISION
 CROOT::Experimental::Detail::THistBinPtr< HISTIMPL >Points to a histogram bin (or actually a THistBinRef)
 CROOT::Experimental::Detail::THistBinRef< HISTIMPL >Represents a bin reference
 CROOT::Experimental::Internal::THistBufferedFillBase< DERIVED, HIST, SIZE >
 ►CROOT::Experimental::Internal::THistBufferedFillBase< THistBufferedFill< HIST, SIZE >, HIST, SIZE >
 ►CROOT::Experimental::Internal::THistBufferedFillBase< THistConcurrentFiller< HIST, SIZE >, HIST, SIZE >
 CROOT::Experimental::THistConcurrentFillManager< HIST, SIZE >Manages the synchronization of calls to FillN()
 CROOT::Experimental::THistDataMomentUncert< DIMENSIONS, PRECISION, STORAGE >For now do as TH1: calculate first (xw) and second (x^2w) moment
 CROOT::Experimental::THistDrawOptions< DIMENSION >Drawing options for a histogram with DIMENSIONS
 CROOT::Experimental::THistDrawOptions< DIMENSIONS >
 CROOT::Experimental::Internal::THistDrawOptionsEnum< DIMENSION >
 CROOT::Experimental::Internal::THistDrawOptionsEnum< 1 >Specialization containing 1D hist drawing options
 CROOT::Experimental::Internal::THistDrawOptionsEnum< 2 >Specialization containing 2D hist drawing options
 CROOT::Experimental::Internal::THistDrawOptionsEnum< 3 >Specialization containing 3D hist drawing options
 CROOT::Experimental::Internal::THistImplGen< NDIM, IDIM, DATA, PROCESSEDAXISCONFIG >Generate THist::fImpl from THist constructor arguments
 CROOT::Experimental::Internal::THistImplGen< NDIM, NDIM, DATA, PROCESSEDAXISCONFIG... >Generate THist::fImpl from constructor arguments; recursion end
 CROOT::Experimental::Detail::THistImplPrecisionAgnosticBase< DIMENSIONS >Base class for THistImplBase that abstracts out the histogram's PRECISION
 ►CROOT::Experimental::Detail::THistImplPrecisionAgnosticBase< DATA::GetNDim()>
 CROOT::Experimental::Internal::THistPainterBase< DIMENSION >
 CTHistRenderingRegion
 CROOT::Experimental::THistStatContent< DIMENSIONS, PRECISION, STORAGE >Basic histogram statistics, keeping track of the bin content and the total number of calls to Fill()
 CROOT::Experimental::THistStatRuntime< DIMENSIONS, PRECISION, STORAGE >Interface implementing a pure virtual functions DoFill(), DoFillN()
 CROOT::Experimental::THistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION, STORAGE >Keeps track of the histogram's total sum of squared weights
 CROOT::Experimental::THistStatTotalSumOfWeights< DIMENSIONS, PRECISION, STORAGE >Keeps track of the histogram's total sum of weights
 CROOT::Experimental::THistStatUncertainty< DIMENSIONS, PRECISION, STORAGE >Histogram statistics to keep track of the Poisson uncertainty per bin
 CROOT::Experimental::THistView< DIMENSIONS, PRECISION, STAT >A view on a histogram, selecting a range on a subset of dimensions
 CROOT::Experimental::THistViewOutOfRange< HISTVIEW >
 CROOT::Internal::THnBaseBinIterIterator over THnBase bins (internal implementation)
 CTGeoBoolNode::ThreadData_t
 CTGeoPatternFinder::ThreadData_t
 CTGeoPgon::ThreadData_t
 CTGeoVolumeAssembly::ThreadData_t
 CTGeoXtru::ThreadData_t
 CTIdleTOTimerGuard
 CROOT::Math::test::Timer
 CTIndArray
 ►CROOT::Internal::TInitBehavior
 CTInspectorImpABC describing GUI independent object inspector (abstraction mainly needed for Win32
 CTVirtualCollectionPtrIterators::TInternalIterator
 ►CTClassEdit::TInterpreterLookupHelper
 ►CTInterpreterValue
 CRgl::Mc::TIsoMesh< V >
 CRgl::Mc::TIsoMesh< Double_t >
 CRgl::Mc::TIsoMesh< Float_t >
 ►CTIter
 ►CTIteratorIterator abstract base class
 CTKDEFGT
 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
 ►CROOT::Experimental::TLogHandlerAbstract TLogHandler base class
 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 >
 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
 CTMINUIT
 ►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
 CTNDArrayRef< T >
 CTMVA::DNN::TNet< Architecture_t, Layer_t >Generic neural network class
 CTMVA::DNN::TNet< Architecture_t >
 ►CTMVA::TNeuronInput
 CTMVA::TNeuronInputChooser
 ►CTNonCopyable
 CROOT::TMetaUtils::TNormalizedCtxt
 ►CTObjectMother of all ROOT objects
 ►CTObjLinkWrapper around a TObject so it can be stored in a TList
 ►CROOT::Internal::TObjProxy< T >
 CTOCCToStep
 CROOT::Experimental::TDirectory::ToContentType< T >
 CMemstat::ToLower_t
 CToolBarData_t
 CTMVA::Tools
 CROOT::Internal::TOperatorNewHelper
 CROOT::v5::TOperOffset
 ►CTPaletteEditorEdit the palette via a GUI
 CTMySQLStatement::TParamData
 CPyROOT::TParameter
 CROOT::Internal::TParBranchProcessingRAII
 CROOT::Internal::TParTreeProcessingRAII
 CTPickerStackGuard
 CTPoint
 CTStreamerInfo::TPointerCollectionAdapter
 CTPoints2-D graphics point (world coordinates)
 CTPosixThreadCleanUp
 ►CTPRegexp
 CTProfileHelper
 CTProofDebug
 CTProofLockPathGuard
 CTProofMergePrg
 CTProofProgressDialog
 CTProofServLogHandlerGuard
 CTProtoClass::TProtoRealData
 CTVirtualCollectionProxy::TPushPop
 CTPwdCtx
 CTPyArg
 CPyROOT::TPyBufferFactoryFactory for python buffers of non-string type
 CTPyReturn
 CTPythia6::TPythia6CleanerUtility class to manage the TPythia6 instance
 CTPython
 ►CTQObjectThis is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html)
 CTrackD
 CTrackD32
 ►CROOT::Math::TRandomEngine
 CTRandomEngine
 CROOT::Math::Transform3DBasic 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::TransformationHandler
 CROOT::Math::Translation3DClass 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 > >
 ►CTRecorderState
 CTRedirectOutputGuard
 CTEveManager::TRedrawDisabler
 ►CTRefCntDefinitions for TRefCnt, base class for reference counted objects
 CTBits::TReference
 CTMVA::DNN::TReference< Real_t >The reference architecture class
 CTRegexpRegular expression class
 CROOT::Math::Delaunay2D::Triangle
 Ctriangulateio
 CTRootIOCtor
 CTRootSnifferScanRec
 CTRotation::TRotationRow
 CTRSA_fun
 CROOT::TRWSpinLock
 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 >
 CTClass::TSpinLockGuard
 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::Internal::TStdBitsetHelper< T >
 CROOT::Internal::TStlObjProxy< T >
 CTStorageStorage manager
 ►CTStringBasic string class
 CTSubStringA zero length substring is legal
 CTTabCom
 CTTablePadView3D
 CTTableRange
 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::ROOT::Internal::TTreeView >
 CTThreadPoolTask< aTask, aParam >
 CTThreadPoolTaskImp< aTask, aParam >
 CTTimeBasic time type with millisecond precision
 CTTimeStampThe TTimeStamp encapsulates seconds and ns since EPOCH
 CTMVA::MethodDNN::TTrainingSettings
 CTTreeClonerClass implementing or helping the various TTree cloning method
 ►CROOT::Internal::TTreeGeneratorBase
 CROOT::TTreeProcessor
 ►CROOT::Internal::TTreeReaderValueBase
 CROOT::Internal::TTreeView
 CTTreeViewA helper class that encapsulates a file and a tree
 CTCling::TUniqueString
 CROOT::Experimental::Internal::TUniWeakPtr< T >
 CROOT::Experimental::Internal::TUniWeakPtr< ROOT::Experimental::Detail::THistImplPrecisionAgnosticBase >
 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)
 CTVersionCheck
 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
 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
 ►CTVirtualRefProxy
 ►CTVirtualTableInterface
 CTVirtualVectorIterators
 CTWin32SplashThread
 CTWin32ThreadCleanUp
 ►CTXHandlerHandler of asynchronous events for XProofD sockets
 ►CTXMLSetup
 CTXNetSystemConnectGuard
 CTXSemaphoreGuard
 CTXSockBuf
 CTXSockPipe
 ►CType_t
 ►CType_t
 CTMVA::Types
 ►Cunary_function
 CROOT::Math::UnaryOp< Operator, RHS, T >UnaryOperation class A class representing unary operators in the parse tree
 CRooRandomizeParamMCSModule::UniParam
 CRooRandomizeParamMCSModule::UniParamSet
 CUnuRanDist
 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
 CUserGroup_t
 CTString::UStr_t
 CTUUID::uuid_time_t
 CPyROOT::TParameter::Value
 CTGenCollectionProxy::ValueSmall helper to describe the Value_type or the key_type of an STL container
 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::Math::VavilovTestTest class for class Vavilov and its subclasses
 CROOT::Minuit2::vec
 CROOT::Math::VecExpr< ExprType, T, D >Expression wrapper class for Vector objects
 ►Cstd::vector< T >STL class
 CROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 >Class for Vector-Matrix multiplication
 CROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 >
 CROOT::Minuit2::VectorOuterProduct< M, T >
 CVecTrackD
 CROOT::Math::VegasParametersStructures collecting parameters for VEGAS multidimensional integration FOr implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
 CTGLParametricPlot::Vertex_t
 ►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::Volume
 CROOT::MacOSX::X11::CommandBuffer::WidgetRect
 CWindowAttributes_t
 ►C<X11Drawable>
 CXColor_tDescription of a X11 color
 CXHandleErr_t
 CXHandleIn_t
 CROOT::MacOSX::X11::XLFDName
 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
 ►CBASES
 ►CFunctionType
 ►CIPFType