Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

►NBidirMMapPipe_impl	Namespace for implementation details of BidirMMapPipe
CPageChunk	Class representing a chunk of pages
►CPages	Handle class for a number of Pages
Cimpl	Implementation
►Ncling
►Nutils
►Ncppyy
C_Double
►C_global_cpp
Cstd
C_ns_meta
C_stdmeta
Cdouble
Clong_int
Cshort
CTemplate
Cunsigned_int
Cunsigned_long
Cunsigned_short
►NMemstat
CSCustomDigest
CSFind_t
CTMemStatFAddrContainer
CTMemStatMng
CToLower_t
►NPyROOT
►CMethodProxy
CMethodInfo_t
CObjectProxy
CPropertyProxy
CPyCallable
CPyRootClass	Type object to hold TClassRef instance (this is only semantically a presentation of PyRootType instances, not in a C++ sense)
CTCallContext
CTClassMethodHolder
CTConstructorHolder
CTConverter
CTCppObjectArrayConverter
CTCppObjectArrayExecutor
CTCppObjectBySmartPtrExecutor
CTCppObjectBySmartPtrPtrExecutor
CTCppObjectBySmartPtrRefExecutor
CTCppObjectByValueExecutor
CTCppObjectConverter
CTCppObjectExecutor
CTCppObjectPtrConverter
CTCppObjectPtrPtrExecutor
CTCppObjectPtrRefExecutor
CTCppObjectRefExecutor
CTCStringConverter
CTemplateProxy	Template proxy object to return functions and methods
CTExecutor
CTFunctionHolder
CTLongLongArrayConverter
CTMemoryRegulator
CTMethodHolder
CTNonConstCStringConverter
CTNonConstUCStringConverter
CTNotImplementedConverter
►CTParameter
CValue
CTPyBufferFactory	Factory for python buffers of non-string type
CTPyException
CTPyROOTApplication
CTRefCppObjectConverter
CTRefExecutor
CTSetItemHolder
CTSmartPtrCppObjectConverter
CTSTLIteratorConverter
CTStrictCppObjectConverter
CTValueCppObjectConverter
CTVoidArrayConverter
CTVoidConverter
CTVoidPtrPtrConverter
CTVoidPtrRefConverter
►NRcpp	This is a class to support deprecated method to pass function to R's Environment, based in Rcpp::InternalFunction
►Ntraits
CExporter< std::array< T, i > >
►NRgl
►NFgt
CTKDEAdapter
►NMc
CTCell
CTDefaultSplitter
CTF3Adapter
CTF3EdgeSplitter
CTGridGeometry
CTH3Adapter
CTIsoMesh
CTMeshBuilder
CTSlice
CTSourceAdapterSelector
CTSourceAdapterSelector< TF3 >
CTSourceAdapterSelector< TH3C >
CTSourceAdapterSelector< TH3D >
CTSourceAdapterSelector< TH3F >
CTSourceAdapterSelector< TH3I >
CTSourceAdapterSelector< TH3S >
CTSourceAdapterSelector< TKDEFGT >
CTSplitterSelector
CTSplitterSelector< TF3, V >
CTSplitterSelector< TH3C, V >
CTSplitterSelector< TH3D, V >
CTSplitterSelector< TH3F, V >
CTSplitterSelector< TH3I, V >
CTSplitterSelector< TH3S, V >
CTSplitterSelector< TKDEFGT, V >
►NPad
CBoundingRect
CFillAttribSet
CGLLimits
CLineAttribSet
CMarkerPainter
CMeshPatch_t
COffScreenDevice
CPolygonStippleSet
CTesselator
CPlotTranslation
CTGuardBase
CTOneArgGuard
CTTwoArgsGuard
►NRooStats	Namespace for the RooStats classes
►NHistFactory
CAsimov
CChannel
CConfigParser
CData
►CEstimateSummary
CNormFactor
CShapeSys
CFlexibleInterpVar
Chf_exc
CHistFactoryNavigation
CHistFactorySimultaneous
CHistoFactor
CHistoSys
CHistoToWorkspaceFactory
CHistoToWorkspaceFactoryFast
CHistRef
CLinInterpVar
CMeasurement
CNormFactor
COverallSys
CPreprocessFunction
►CRooBarlowBeestonLL
CBarlowCache
CSample
CShapeFactor
CShapeSys
CStatError
CStatErrorConfig
CAcceptanceRegion
CAsymptoticCalculator	Hypothesis Test Calculator based on the asymptotic formulae for the profile likelihood ratio
CBayesianCalculator	BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method
CBernsteinCorrection	BernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term
CCombinedCalculator	CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals
CConfidenceBelt	ConfidenceBelt is a concrete implementation of the ConfInterval interface
CConfInterval	ConfInterval is an interface class for a generic interval in the RooStats framework
CDebuggingSampler
CDebuggingTestStat
CDetailedOutputAggregator
CFeldmanCousins	(like the Feldman-Cousins technique) is essentially a specific configuration of the more general NeymanConstruction
CFrequentistCalculator	Hypothesis Test Calculator using a full frequentist procedure for sampling the test statistic distribution
CHeaviside	Represents the Heaviside function
CHLFactory	HLFactory is an High Level model Factory allows you to describe your models in a configuration file (datacards) acting as an interface with the RooFactoryWSTool
CHybridCalculator	This class implements the Hypothesis test calculation using an hybrid (frequentist/bayesian) procedure
CHybridCalculatorOriginal	HybridCalculatorOriginal class
CHybridPlot	This class provides the plots for the result of a study performed with the HybridCalculatorOriginal class
CHybridResult
CHypoTestCalculator	HypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults
CHypoTestCalculatorGeneric	Common base class for the Hypothesis Test Calculators
CHypoTestInverter	HypoTestInverter class for performing an hypothesis test inversion by scanning the hypothesis test results of an HypoTestCalculator for various values of the parameter of interest
CHypoTestInverterOriginal	This class is now depratcated and to be replaced by the HypoTestInverter
CHypoTestInverterPlot	Class to plot an HypoTestInverterResult, result of the HypoTestInverter calculator
CHypoTestInverterResult	HypoTestInverterResult class: holds the array of hypothesis test results and compute a confidence interval
CHypoTestPlot	This class provides the plots for the result of a study performed with any of the HypoTestCalculatorGeneric (e.g
CHypoTestResult	HypoTestResult is a base class for results from hypothesis tests
CIntervalCalculator	IntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals
CLikelihoodInterval	LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface
CLikelihoodIntervalPlot	This class provides simple and straightforward utilities to plot a LikelihoodInterval object
CMarkovChain	Stores the steps in a Markov Chain of points
CMaxLikelihoodEstimateTestStat	MaxLikelihoodEstimateTestStat: TestStatistic that returns maximum likelihood estimate of a specified parameter
CMCMCCalculator	Bayesian Calculator estimating an interval or a credible region using the Markov-Chain Monte Carlo method to integrate the likelihood function with the prior to obtain the posterior function
CMCMCIntervalPlot	This class provides simple and straightforward utilities to plot a MCMCInterval object
CMetropolisHastings	This class uses the Metropolis-Hastings algorithm to construct a Markov Chain of data points using Monte Carlo
CMinNLLTestStat	MinNLLTestStat is an implementation of the TestStatistic interface that calculates the minimum value of the negative log likelihood function and returns it as a test statistic
CModelConfig	ModelConfig is a simple class that holds configuration information specifying how a model should be used in the context of various RooStats tools
CNeymanConstruction	NeymanConstruction is a concrete implementation of the NeymanConstruction interface that, as the name suggests, performs a NeymanConstruction
CNuisanceParametersSampler	Helper class for ToyMCSampler
CNumberCountingPdfFactory
CNumEventsTestStat	NumEventsTestStat is a simple implementation of the TestStatistic interface used for simple number counting
CPdfProposal	PdfProposal is a concrete implementation of the ProposalFunction interface
CPointSetInterval	PointSetInterval is a concrete implementation of the ConfInterval interface
CProfileInspector
CProfileLikelihoodCalculator	ProfileLikelihoodCalculator is a concrete implementation of CombinedCalculator (the interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals)
CProfileLikelihoodTestStat	ProfileLikelihoodTestStat is an implementation of the TestStatistic interface that calculates the profile likelihood ratio at a particular parameter point given a dataset
CProofConfig	Holds configuration options for proof and proof-lite
CProposalFunction	ProposalFunction is an interface for all proposal functions that would be used with a Markov Chain Monte Carlo algorithm
CProposalHelper
CRatioOfProfiledLikelihoodsTestStat	TestStatistic that returns the ratio of profiled likelihoods
CSamplingDistPlot	This class provides simple and straightforward utilities to plot SamplingDistribution objects
CSamplingDistribution	This class simply holds a sampling distribution of some test statistic
CSamplingSummary
CSamplingSummaryLookup
CSequentialProposal	Class implementing a proposal function that samples the parameter space by moving only in one coordinate (choosen randomly) at each step
CSimpleInterval
CSimpleLikelihoodRatioTestStat	TestStatistic class that returns -log(L[null] / L[alt]) where L is the likelihood
CSPlot	This class calculates sWeights used to create an sPlot
CTestStatistic	TestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class
CTestStatSampler	TestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions
CToyMCImportanceSampler	ToyMCImportanceSampler is an extension of the ToyMCSampler for Importance Sampling
CToyMCPayload
CToyMCSampler	ToyMCSampler is an implementation of the TestStatSampler interface
CToyMCStudy	ToyMCStudy is an implementation of RooAbsStudy for toy Monte Carlo sampling
CUniformProposal	UniformProposal is a concrete implementation of the ProposalFunction interface for use with a Markov Chain Monte Carlo algorithm
CUpperLimitMCSModule	This class allow to compute in the ToyMcStudy framework the ProfileLikelihood upper limit for each toy-MC sample generated
►NROOT	Namespace for new ROOT classes and functions
►NDetail
CTBranchProxy
►CTCollectionProxyInfo
CAddress
CEnviron
CEnvironBase
CInsert
CIterators
CIterators< Cont_t, true >
CIterators< std::vector< T >, false >
CIteratorValue
CIteratorValue< Cont_t, value_ptr * >
CMapInsert
CPairHolder
CPushback
CPushback< Internal::TStdBitsetHelper< Bitset_t > >
CPushback< std::vector< bool > >
CPushfront
CSfinaeHelper
CType
►CType< Internal::TStdBitsetHelper< Bitset_t > >
►CIterators
CPtrSize_t
►CType< std::vector< Bool_t > >
CIterators
CTHistImpl
CTHistImplBase	Interface class for THistImpl
CTHistImplPrecisionAgnosticBase	Base class for THistImplBase that abstracts out the histogram's PRECISION
►CTSchemaRuleSet
CTMatches
►NFit	Namespace for the fitting classes
CBasicFCN	BasicFCN class: base class for the objective functions used in the fits It has a reference to the data and th emodel function used in the fit
CBinData	Class describing the binned data sets : vectors of x coordinates, y values and optionally error on y values and error on coordinates The dimension of the coordinate is free There are 4 different options:
CBinPoint	Obsolete class, no more in use
CChi2FCN	Chi2FCN class for binnned fits using the least square methods
CDataOptions	DataOptions : simple structure holding the options on how the data are filled
CDataRange	Class describing the range in the coordinates it supports multiple range in a coordinate
CDataVector	Class holding the fit data points
CDataWrapper	Class 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
CDummyDeleter
CFcnAdapter
CFitConfig	Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class
CFitData	Base class for all the fit data types
CFitResult	Class 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
CFitter	Fitter class, entry point for performing all type of fits
CLogLikelihoodFCN	LogLikelihoodFCN class for likelihood fits
CParameterSettings	Class, describing value, limits and step size of the parameters Provides functionality also to set/retrieve values, step sizes, limits and fix the parameters
CPoissonLikelihoodFCN	Class evaluating the log likelihood for binned Poisson likelihood fits it is template to distinguish gradient and non-gradient case
CSparseData
CUnBinData	Class describing the unbinned data sets (just x coordinates values) of any dimensions
►NInternal
CAxisConfigToType	Converts a TAxisConfig of whatever kind to the corresponding TAxisBase-derived object
CAxisConfigToType< TAxisConfig::kEquidistant >
CAxisConfigToType< TAxisConfig::kGrow >
CAxisConfigToType< TAxisConfig::kIrregular >
CAxisConfigToType< TAxisConfig::kLabels >
CFillBinCoord_t	Fill coord with low bin edge or center or high bin edge of all axes
CFillBinCoord_t<-1, COORD, AXES >
CFillIterRange_t	Fill range with begin() and end() of all axes, including under/overflow as specified by over
CFillIterRange_t<-1, AXES >
CHistImplGen_t	Generate THist::fImpl from THist constructor arguments
CHistImplGen_t< DIMENSIONS, DIMENSIONS, PRECISION, STATISTICS, PROCESSEDAXISCONFIG...>	Generate THist::fImpl from constructor arguments; recursion end
CHistIterFullRange_t	A predicate for THistBinIterBase to accept all bins
CRStl
CTArrayCharProxy
CTArrayProxy
CTArrayType
CTArrayType< T, 0 >
CTBranchDescriptor
CTBranchProxyClassDescriptor
CTBranchProxyDescriptor
CTBranchProxyDirector
CTBranchProxyHelper
CTClaArrayProxy
CTClaImpProxy
CTClaObjProxy
CTClaProxy
CTCoopPtrTypeErased	Type-specific derived implementation of a TCoopPtrTypeErasedBase, to invoke the destructor of the TCoopPtr<POINTEE> upon destruction of the TCoopPtrTypeErased
CTCoopPtrTypeErasedBase	To handle polymorphic TCoopPtr<POINTEE>s, convert them to TCoopPtrTypeErased<POINTEE>s and access them through their common base TCoopPtrTypeErasedBase
CTDefaultInitBehavior
CTDrawable	Base class for drawable entities: objects that can be painted on a TPad
CTF1Builder	Internal class used by TF1 for defining template specialization for different TF1 constructors
CTF1Builder< const char * >	TF1 building from a string used to build a TFormula based on a lambda function
CTFileImplBase	Base class for storage-specific ROOT file implementations
CTFriendProxy
CTFriendProxyDescriptor
CTGetBinCount
CTGetBinCount< 0, AXES >
CTGetBinIndex
CTGetBinIndex< -1, HISTIMPL, AXES, GROW >
CTHistBinIter	A bin iterator taking a predicate whether it should skip a bin
CTHistBinIterBase
CTHistBufferedFillBase
CTHistDrawable
CTHistDrawOptionsEnum
CTHistDrawOptionsEnum< 1 >	Specialization containing 1D hist drawing options
CTHistDrawOptionsEnum< 2 >	Specialization containing 2D hist drawing options
CTHistDrawOptionsEnum< 3 >	Specialization containing 3D hist drawing options
CTHistPainterBase
CTHnBaseBinIter	Iterator over THnBase bins (internal implementation)
CTHnBaseBrowsable	TBrowser helper for THnBase
CTImpProxy
CTInitBehavior
CTMultiArrayType
CTNamedBranchProxy
CTObjProxy
CTOperatorNewHelper
CTQObjectInitBehavior
CTSchemaHelper
CTSchemaRuleProcessor
CTSchemaType
CTStdBitsetHelper
CTStlArrayProxy
CTStlImpProxy
CTStlObjProxy
CTStlProxy
CTStlSimpleProxy
CTTableInitBehavior
CTTreeGeneratorBase
CTTreeProxyGenerator
CTTreeReaderArrayBase
CTTreeReaderDescriptor
CTTreeReaderGenerator
CTTreeReaderValueBase
CTVirtualCollectionReader
►NMacOSX
►NDetails
CCocoaPrivate
►CFontCache
CFontList
►NUtil
CAutoreleasePool
CCFScopeGuard
CCFStrongReference
CNSScopeGuard
CNSStrongReference
CScopedArray
►NX11
►CColorParser
CRGB_t
CCommand
CEventTranslator
CPoint
CRectangle
CXLFDName
►NMath
►NCholeskyDecompHelpers	Helpers for CholeskyDecomp
C_decomposer	Struct to do a Cholesky decomposition
C_decomposer< F, 0, M >	Struct to do a Cholesky decomposition (specialized, N = 0)
C_decomposer< F, 1, M >	Struct to do a Cholesky decomposition (specialized, N = 1)
C_decomposer< F, 2, M >	Struct to do a Cholesky decomposition (specialized, N = 2)
C_decomposer< F, 3, M >	Struct to do a Cholesky decomposition (specialized, N = 3)
C_decomposer< F, 4, M >	Struct to do a Cholesky decomposition (specialized, N = 4)
C_decomposer< F, 5, M >	Struct to do a Cholesky decomposition (specialized, N = 5)
C_decomposer< F, 6, M >	Struct to do a Cholesky decomposition (specialized, N = 6)
C_decomposerGenDim	Struct to do a Cholesky decomposition (general dimensionality)
C_inverter	Struct to obtain the inverse from a Cholesky decomposition
C_inverter< F, 0, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 0)
C_inverter< F, 1, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 1)
C_inverter< F, 2, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 2)
C_inverter< F, 3, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 3)
C_inverter< F, 4, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 4)
C_inverter< F, 5, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 5)
C_inverter< F, 6, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 6)
C_inverterGenDim	Struct to obtain the inverse from a Cholesky decomposition (general dimensionality)
C_solver	Struct to solve a linear system using its Cholesky decomposition
C_solver< F, 0, V >	Struct to solve a linear system using its Cholesky decomposition (N=0)
C_solver< F, 1, V >	Struct to solve a linear system using its Cholesky decomposition (N=1)
C_solver< F, 2, V >	Struct to solve a linear system using its Cholesky decomposition (N=2)
C_solver< F, 3, V >	Struct to solve a linear system using its Cholesky decomposition (N=3)
C_solver< F, 4, V >	Struct to solve a linear system using its Cholesky decomposition (N=4)
C_solver< F, 5, V >	Struct to solve a linear system using its Cholesky decomposition (N=5)
C_solver< F, 6, V >	Struct to solve a linear system using its Cholesky decomposition (N=6)
C_solverGenDim	Struct to solve a linear system using its Cholesky decomposition (generalised dimensionality)
CPackedArrayAdapter	Adapter for packed arrays (to SMatrix indexing conventions)
►Ndetail
Cmanipulator
►NGenVector_detail
►CBitReproducible
CDB8
CBitReproducibleException
►Ngv_detail
CERROR_This_Rotation_Conversion_is_NOT_Supported
►NRoots	Root-Finding Algorithms
CBisection	Roots::Bisection Bisection algorithm, simplest algorithm for bracketing the roots of a function, but slowest one
CBrent	Brent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information
CFalsePos	False Position algorithm based on linear interpolation
CNewton	Newton algorithm, which computes the derivative at each iteration See the GSL manual for more information
CSecant	Secant algorithm, simplified version of Newton method, which does not require the derivative at every step
CSteffenson	Steffenson method, providing the fastes convergence
►NrowOffsetsUtils
Cindices
Cmake_indices
Cmake_indices_impl
Cmake_indices_impl< I, indices< Indices...>, N >
Cmake_indices_impl< N, indices< Indices...>, N >
►Ntest
CTimer
CAdaptiveIntegratorMultiDim	Class for adaptive quadrature integration in multi-dimensions using rectangular regions
CAddOp	Addition Operation Class
CAddPolicy	Matrix addition policy
CAddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > >
CAssign	Structure to assign from an expression based to general matrix to general matrix
CAssign< 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
CAssign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >	Structure to assign from an expression based to symmetric matrix to symmetric matrix
CAssignItr	Structure for assignment to a general matrix from iterator
CAssignItr< T, D1, D2, MatRepSym< T, D1 > >	Specialized structure for assignment to a symmetrix matrix from iterator
CAssignSym	Force Expression evaluation from general to symmetric
CAxisAngle	AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis
CBaseIntegratorOptions	Base 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
CBasicFitMethodFunction	FitMethodFunction class Interface for objective functions (like chi2 and likelihood used in the fit) In addition to normal function interface provide interface for calculating each data contrinution to the function which is required by some algorithm (like Fumili)
CBasicMinimizer	Base Minimizer class, which defines the basic funcionality of various minimizer implementations (apart from Minuit and Minuit2) It provides support for storing parameter values, step size, parameter transofrmation etc
CBinaryOp	BinaryOperation class A class representing binary operators in the parse tree
CBinaryOpCopyL	Binary Operation class with value storage for the left argument
CBinaryOpCopyR	Binary Operation class with value storage for the right argument
CBoost	Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix
CBoostX	Class representing a Lorentz Boost along the X axis, by beta
CBoostY	Class representing a Lorentz Boost along the Y axis, by beta
CBoostZ	Class representing a Lorentz Boost along the Z axis, by beta
CBrentMinimizer1D	User class for performing function minimization
CBrentRootFinder	Class for finding the root of a one dimensional function using the Brent algorithm
CCartesian2D	Class describing a 2D cartesian coordinate system (x, y coordinates)
CCartesian3D	Class describing a 3D cartesian coordinate system (x, y, z coordinates)
CChebyshevApprox	Class describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials
CChebyshevPol
CCholeskyDecomp	Class to compute the Cholesky decomposition of a matrix
CCholeskyDecompGenDim	Class to compute the Cholesky decomposition of a matrix
CCholInverter
CCompileTimeChecker
CCompileTimeChecker< false >
CConstant	Constant expression class A class representing constant expressions (literals) in the parse tree
CCoordinateTraits
CCoordinateTraits< Cartesian3D< Scalar > >
CCoordinateTraits< Cylindrical3D< Scalar > >
CCoordinateTraits< CylindricalEta3D< Scalar > >
CCoordinateTraits< Polar3D< Scalar > >
CCoordinateTraits< PtEtaPhiE4D< Scalar > >
CCoordinateTraits< PtEtaPhiM4D< Scalar > >
CCoordinateTraits< PxPyPzE4D< Scalar > >
CCoordinateTraits< PxPyPzM4D< Scalar > >
CCylindrical3D	Class describing a cylindrical coordinate system based on rho, z and phi
CCylindricalEta3D	Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z
CDefaultCoordinateSystemTag	DefaultCoordinateSystemTag Default tag for identifying any coordinate system
►CDelaunay2D	Class to generate a Delaunay triangulation of a 2D set of points
CTriangle
CDerivator	Class for computing numerical derivative of a function
CDeterminant	Detrminant for a general squared matrix Function to compute the determinant from a square matrix ( \( \det(A)\)) of dimension idim and order n
CDisplacementVector2D	Class describing a generic displacement vector in 2 dimensions
CDisplacementVector3D	Class describing a generic displacement vector in 3 dimensions
CDistSampler	Interface class for generic sampling of a distribution, i.e
CDistSamplerOptions	DistSampler options class
CDivOp	Division (element-wise) Operation Class
CEulerAngles	EulerAngles class describing rotation as three angles (Euler Angles)
CEvaluatorOneDim
CEvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
CExpr
CFabs	Unary abs Operation Class
CFactory	Factory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager
CFastInverter	Fast Matrix Inverter class Class to specialize calls to Dinv
CFastInverter< 3 >	3x3 direct matrix inversion using Cramer Rule use only for FastInverter
CFastInverter< 4 >	4x4 matrix inversion using Cramers rule
CFastInverter< 5 >	5x5 Matrix inversion using Cramers rule
CFunctor	Documentation for class Functor class
CFunctor1D	Functor1D class for one-dimensional functions
CFunctorGradHandler	Functor Handler class for gradient functions where both callable objects are provided for the function evaluation (type Func) and for the gradient (type GradFunc)
CFunctorHandler	Functor Handler class is responsible for wrapping any other functor and pointer to free C functions
CFunctorImpl	FunctorImpl is a base class for the functor handler implementation class
CGaussIntegrator	User class for performing function integration
CGaussLegendreIntegrator	User class for performing function integration
CGenAlgoOptions	Class implementing generic options for a numerical algorithm Just store the options in a map of string-value pairs
CGeneticMinimizer	GeneticMinimizer
CGeneticMinimizerParameters
CGenVector_exception
CGlobalCoordinateSystemTag	Tag for identifying vectors based on a global coordinate system
CGoFTest
CGradFunctor	GradFunctor class for Multidimensional gradient functions
CGradFunctor1D	GradFunctor1D class for one-dimensional gradient functions
CGSL1DMinimizerWrapper	Wrapper class for gsl_min_fminimizer structure
CGSLChebSeries	Wrapper class for C struct gsl_cheb_series
CGSLDerivator	Class 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 )
CGSLFunctionAdapter	Class for adapting any C++ functor class to C function pointers used by GSL
CGSLFunctionDerivWrapper	Class to wrap a gsl_function_fdf (with derivatives)
CGSLFunctionWrapper	Wrapper class to the gsl_function C structure
CGSLIntegrationWorkspace
CGSLIntegrator	Class for performing numerical integration of a function in one dimension
CGSLInterpolator	Interpolation class based on GSL interpolation functions
CGSLMCIntegrationWorkspace
CGSLMCIntegrator
CGSLMinimizer	GSLMinimizer class
CGSLMinimizer1D	Minimizer for arbitrary one dimensional functions
CGSLMiserIntegrationWorkspace	Workspace for MISER
CGSLMonteFunctionAdapter
CGSLMonteFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm
CGSLMultiFit	GSLMultiFit, internal class for implementing GSL non linear least square GSL fitting
CGSLMultiFitFunctionAdapter	Class for adapting a C++ functor class to C function pointers used by GSL MultiFit Algorithm The templated C++ function class must implement:
CGSLMultiFitFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
CGSLMultiMinDerivFunctionWrapper	Wrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm
CGSLMultiMinFunctionAdapter	Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms
CGSLMultiMinFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
CGSLMultiMinimizer	GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives
CGSLMultiRootBaseSolver	GSLMultiRootBaseSolver, internal class for implementing GSL multi-root finders This is the base class for GSLMultiRootSolver (solver not using derivatives) and GSLMUltiRootDerivSolver (solver using derivatives)
CGSLMultiRootDerivFunctionWrapper	Wrapper to a multi-dim function with derivatives for multi roots algorithm
CGSLMultiRootDerivSolver	GSLMultiRootDerivSolver, internal class for implementing GSL multi-root finders using derivatives
CGSLMultiRootFinder	Class for Multidimensional root finding algorithms bassed on GSL
CGSLMultiRootFunctionAdapter	Class for adapting a C++ functor class to C function pointers used by GSL MultiRoot Algorithm The templated C++ function class must implement:
CGSLMultiRootFunctionWrapper	Wrapper to a multi-dim function without derivatives for multi roots algorithm
CGSLMultiRootSolver	GSLMultiRootSolver, internal class for implementing GSL multi-root finders not using derivatives
CGSLNLSMinimizer	GSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting
CGSLPlainIntegrationWorkspace
CGSLQRngNiederreiter2	Niederreiter generator gsl_qrng_niederreiter_2 from here
CGSLQRngSobol	Sobol generator gsl_qrng_sobol from here
CGSLQRngWrapper	GSLQRngWrapper class to wrap gsl_qrng structure
CGSLQuasiRandomEngine	GSLQuasiRandomEngine 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
CGSLRandomEngine	GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator
CGSLRngCMRG	Combined multiple recursive generator (L'Ecuyer) see here
CGSLRngGFSR4	Lagged Fibonacci generator by Ziff see here
CGSLRngMinStd	MINSTD generator (Park and Miller) see here
CGSLRngMRG	5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here
CGSLRngMT	Mersenne-Twister generator gsl_rng_mt19937 from here
CGSLRngRand	BSD rand() generator gsl_rmg_rand from here
CGSLRngRanLux	Old Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here
CGSLRngRanLuxD1	Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 1 (It throws away 202 value for every 12 used) see here
CGSLRngRanLuxD2	Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 2 (It throws away 397 value for every 12 used) see here
CGSLRngRanLuxS1	Second generation of Ranlux generator for single precision with luxury level of 1 (It throws away 202 values for every 12 used) see here
CGSLRngRanLuxS2	Second generation of Ranlux generator for Single precision with luxury level of 2 (It throws away 397 value for every 12 used) see here
CGSLRngRanMar	RANMAR generator see here
CGSLRngTaus	Tausworthe generator by L'Ecuyer see here
CGSLRngWrapper	GSLRngWrapper class to wrap gsl_rng structure
CGSLRootFdFSolver	Root-Finder with derivatives implementation class using GSL
CGSLRootFinder	Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives
CGSLRootFinderDeriv	Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives
CGSLRootFSolver	Root-Finder implementation class using GSL
CGSLSimAnFunc	GSLSimAnFunc class description
CGSLSimAnMinimizer	GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL
CGSLSimAnnealing	GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function
CGSLSimAnParams	Structure holding the simulated annealing parameters
CGSLVegasIntegrationWorkspace	Workspace for VEGAS
CIBaseFunctionMultiDim	Documentation for the abstract class IBaseFunctionMultiDim
CIBaseFunctionOneDim	Interface (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 )
CIBaseParam	Documentation for the abstract class IBaseParam
CIGradientFunctionMultiDim	Interface (abstract class) for multi-dimensional functions providing a gradient calculation
CIGradientFunctionOneDim	Interface (abstract class) for one-dimensional functions providing a gradient calculation
CIGradientMultiDim	Gradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function
CIGradientOneDim	Specialized 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
CIMinimizer1D	Interface class for numerical methods for one-dimensional minimization
CIntegrandTransform	Auxillary inner class for mapping infinite and semi-infinite integrals
CIntegratorMultiDim	User class for performing multidimensional integration
CIntegratorMultiDimOptions	Numerical multi dimensional integration options
CIntegratorOneDim	User Class for performing numerical integration of a function in one dimension
CIntegratorOneDimOptions	Numerical one dimensional integration options
CInterpolator	Class for performing function interpolation of points
CInverter	Matrix Inverter class Class to specialize calls to Dinv
CInverter< 0 >	Inverter<0>
CInverter< 1 >	1x1 matrix inversion \(a_{11} \to 1/a_{11}\)
CInverter< 2 >	2x2 matrix inversion using Cramers rule
CIOptions	Generic interface for defining configuration options of a numerical algorithm
CIParametricFunctionMultiDim	IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam
CIParametricFunctionOneDim	Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam
CIParametricGradFunctionMultiDim	Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition to function evaluation with respect to the coordinates also the gradient with respect to the parameters, via the method ParameterGradient
CIParametricGradFunctionOneDim	Interface (abstract class) for parametric one-dimensional gradient functions providing in addition to function evaluation with respect the coordinates also the gradient with respect to the parameters, via the method ParameterGradient
CIRootFinderMethod	Interface for finding function roots of one-dimensional functions
►CKDTree
CBaseNode
CBinNode
CComparePoints
CCut
CHeadNode
Citerator
CSplitNode
CTerminalNode
CKelvinFunctions
CLCGEngine
CLocalCoordinateSystemTag	Tag for identifying vectors based on a local coordinate system
CLorentzRotation	Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix
CLorentzVector	Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part
CLSResidualFunc	LSResidualFunc class description
CMathMoreLibrary
CMatRepStd	Expression wrapper class for Matrix objects
CMatRepSym	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
CMatrixMulOp	Class for Matrix-Matrix multiplication
CMemFunHandler	Functor Handler to Wrap pointers to member functions The member function type must be (XXX means any name is allowed) : double XXX ( double x) for 1D functions and double XXXX (const double *x) for multi-dimensional functions
CMemGradFunHandler	Functor Handler to Wrap pointers to member functions for the evaluation of the function and the gradient
CMersenneTwisterEngine	Random number generator class based on M
Cmeta_col_dot
Cmeta_col_dot< 0 >
Cmeta_dot
Cmeta_dot< 0 >
Cmeta_mag
Cmeta_mag< 0 >
Cmeta_matrix_dot
Cmeta_matrix_dot< 0 >
Cmeta_row_dot
Cmeta_row_dot< 0 >
CMinimizer	Abstract 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
CMinimizerOptions	Minimizer options
CMinimizerVariableTransformation	Base class for MinimizerVariable transformations defining the functions to deal with bounded parameters
CMinimTransformFunction	MinimTransformFunction class to perform a transformations on the variables to deal with fixed or limited variables (support both double and single bounds) The class manages the passed function pointer
CMinimTransformVariable	MinimTransformVariable 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
CMinOp	Subtraction Operation Class
CMinus	Unary Minus Operation Class
CMinusEquals	Evaluate the expression performing a -= operation Need to check whether creating a temporary object with the expression result (like in op: A -= A * B )
CMinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >	Specialization for symmetrix -= general : NOT Allowed operation
CMinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >	Specialization for symmetric matrices
CMiserParameters	Structures collecting parameters for MISER multidimensional integration
CMixMaxEngine	MIXMAX Random number generator
CMulOp	Multiplication (element-wise) Operation Class
CMultiDimParamFunctionAdapter	MultiDimParamFunctionAdapter class to wrap a one-dimensional parametric function in a multi dimensional parameteric function interface This is used typically in fitting where internally the function is stored as multidimension
CMultiDimParamGradFunctionAdapter	MultiDimParamGradFunctionAdapter class to wrap a one-dimensional parametric gradient function in a multi dimensional parameteric gradient function interface This is used typically in fitting where internally the function is stored as multidimension
CMultiNumGradFunction	MultiNumGradFunction class to wrap a normal function in a gradient function using numerical gradient calculation provided by the class Derivator (based on GSL numerical derivation)
CMultPolicy	Matrix-matrix multiplication policy
CNullTypeFunc1D
COneDimMultiFunctionAdapter	OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one
COneDimParamFunctionAdapter	OneDimParamFunctionAdapter class to wrap a multi-dim parameteric function in one dimensional one
CParamFunction	Base template class for all Parametric Functions
CParamFunctionBase	Class defining the signature for multi-dim parametric functions
CParamFunctor	Param Functor class for Multidimensional functions
►CParamFunctorHandler	ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions
CFuncEvaluator
CFuncEvaluator< F * >
CFuncEvaluator< F *const >
CParamMemFunHandler	ParamFunctor Handler to Wrap pointers to member functions
CPlaceExpr
CPlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CPlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CPlaceMatrix	Structure to deal when a submatrix is placed in a matrix
CPlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CPlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CPlainParameters
CPlane3D	Class describing a geometrical plane in 3 dimensions
CPlusEquals	Evaluate the expression performing a += operation Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
CPlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >	Specialization for symmetrix += general : NOT Allowed operation
CPlusEquals< 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 )
CPolar2D	Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI)
CPolar3D	Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI)
CPolynomial	Parametric Function class describing polynomials of order n
CPositionVector2D	Class describing a generic position vector (point) in 2 dimensions
CPositionVector3D	Class describing a generic position vector (point) in 3 dimensions
CPtEtaPhiE4D	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+)
CPtEtaPhiM4D	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+)
CPxPyPzE4D	Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E)
CPxPyPzM4D	Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M)
CQuasiRandom	User class for MathMore random numbers template on the Engine type
CQuaternion	Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k)
CRandom	Documentation for the Random class
CRandomBaseEngine
CRandomFunctions
CRandomFunctions< EngineType, ROOT::Math::GSLRandomEngine >	Specialized implementation of the Random functions based on the GSL library
CRandomFunctionsImpl	Definition of the generic impelmentation class for the RandomFunctions
CRandomFunctionsImpl< 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
CRetrieveMatrix	Structure for getting sub matrices We have different cases according to the matrix representations
CRetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CRetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CRichardsonDerivator	User class for calculating the derivatives of a function
CRMinimizer	RMinimizer class
CRootFinder	User Class to find the Root of one dimensional functions
CRotation3D	Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
CRotationTraits
CRotationTraits< AxisAngle >
CRotationTraits< EulerAngles >
CRotationTraits< LorentzRotation >
CRotationTraits< Quaternion >
CRotationTraits< Rotation3D >
CRotationTraits< RotationX >
CRotationTraits< RotationY >
CRotationTraits< RotationZ >
CRotationX	Rotation class representing a 3D rotation about the X axis by the angle of rotation
CRotationY	Rotation class representing a 3D rotation about the Y axis by the angle of rotation
CRotationZ	Rotation class representing a 3D rotation about the Z axis by the angle of rotation
CRotationZYX	Rotation 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
CRowOffsets	Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix
CSDeterminant	Dsfact
CSinVariableTransformation	Sin Transformation class for dealing with double bounded variables
CSInverter	Dsinv
►CSMatrix	SMatrix: a generic fixed size D1 x D2 Matrix class
CSMatrixRow
CSMatrixRow_const
CSMatrixIdentity
CSMatrixNoInit
CSqr	Unary Square Operation Class
CSqrt	Unary Square Root Operation Class
CSqrtLowVariableTransformation	Sqrt Transformation class for dealing with lower bounded variables
CSqrtUpVariableTransformation	Sqrt Transformation class for dealing with upper bounded variables
CStdEngine	Wrapper class for std::random generator to be included in ROOT
CStdRandomEngine
CSVector	SVector: a generic fixed size Vector class
CTDataPoint
CTDataPointN
CTensorMulOp	Class for Tensor Multiplication (outer product) of two vectors giving a matrix
CTRandomEngine
CTransform3D	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
CTranslation3D	Class describing a 3 dimensional translation
CTransposeOp	Class for Transpose Operations
CTranspPolicy	Matrix transpose policy
CTranspPolicy< T, D1, D2, MatRepSym< T, D1 > >
CUnaryOp	UnaryOperation class A class representing unary operators in the parse tree
CVavilov	Base class describing a Vavilov distribution
CVavilovAccurate	Class describing a Vavilov distribution
CVavilovAccurateCdf	Class describing the Vavilov cdf
CVavilovAccuratePdf	Class describing the Vavilov pdf
CVavilovAccurateQuantile	Class describing the Vavilov quantile function
CVavilovFast	Class describing a Vavilov distribution
CVavilovTest	Test class for class Vavilov and its subclasses
CVecExpr	Expression wrapper class for Vector objects
CVectorMatrixColOp	Class for Vector-Matrix multiplication
CVectorMatrixRowOp
CVegasParameters	Structures collecting parameters for VEGAS multidimensional integration FOr implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
CVirtualIntegrator	Abstract 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
CVirtualIntegratorMultiDim	Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator
CVirtualIntegratorOneDim	Interface (abstract) class for 1D numerical integration It must be implemented by the concrate Integrator classes like ROOT::Math::GSLIntegrator
CWrappedFunction	Template class to wrap any C++ callable object which takes one argument i.e
CWrappedMemFunction	Template class to wrap any member function of a class taking a double and returning a double in a 1D function interface For example, if you have a class like: struct X { double Eval(double x); }; you can wrapped in the following way: WrappedMemFunction<X, double ( X::* ) (double) > f;
CWrappedMemMultiFunction
CWrappedMultiFunction	Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface
CWrappedMultiTF1	Class to Wrap a ROOT Function class (like TF1) in a IParamMultiFunction interface of multi-dimensions to be used in the ROOT::Math numerical algorithm This wrapper class does not own the TF1 pointer, so it assumes it exists during the wrapper lifetime
CWrappedParamFunction	WrappedParamFunction class to wrap any multi-dimensional function pbject implementing the operator()(const double * x, const double * p) in an interface-like IParamFunction with a vector storing and caching internally the parameter values
CWrappedParamFunctionGen	WrappedParamGenFunction class to wrap any multi-dimensional function implementing the operator()(const double * ) in an interface-like IParamFunction, by fixing some of the variables and define them as parameters
CWrappedTF1	Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of one dimensions to be used in the ROOT::Math numerical algorithms The wrapper does not own bby default the TF1 pointer, so it assumes it exists during the wrapper lifetime
►NMeta
►NSelection
CClassAttributes	Used to specify attributes of classes in the "DictSelection" syntax
CKeepFirstTemplateArguments	Used to specify the number of arguments to be kept
CMemberAttributes	Used to specify attributes of data members in the "DictSelection" syntax
CSelectNoInstance	Used to avoid to select all instances of a template
►NMinuit2
CABObj
CABObj< sym, LASymMatrix, double >
CABObj< vec, LAVector, double >
CABProd
CABSum
CAlgebraicProdType
CAlgebraicProdType< gen, gen >
CAlgebraicProdType< gen, sym >
CAlgebraicProdType< gen, vec >
CAlgebraicProdType< sym, gen >
CAlgebraicProdType< sym, sym >
CAlgebraicProdType< sym, vec >
CAlgebraicProdType< T, T >
CAlgebraicProdType< vec, gen >
CAlgebraicProdType< vec, sym >
CAlgebraicSumType
CAlgebraicSumType< gen, vec >
CAlgebraicSumType< sym, vec >
CAlgebraicSumType< T, T >
CAlgebraicSumType< vec, gen >
CAlgebraicSumType< vec, sym >
CAnalyticalGradientCalculator
CBasicFunctionGradient
►CBasicFunctionMinimum	Result of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum
CMnAboveMaxEdm
CMnReachedCallLimit
►CBasicMinimumError	Internal Class containing the error information on the estimated minimum : Error matrix + dcovar + additional flags for quality and validity checks
CMnHesseFailed
CMnInvertFailed
CMnMadePosDef
CMnNotPosDef
CBasicMinimumParameters
CBasicMinimumSeed
CBasicMinimumState
CCombinedMinimizer	Combined minimizer: combination of Migrad and Simplex
CCombinedMinimumBuilder
CContoursError
CDavidonErrorUpdator	Update of the covariance matrix for the Variable Metric minimizer (MIGRAD)
CFCNAdapter	Template wrapped class for adapting to FCNBase signature
CFCNBase	Interface (abstract class) defining the function to be minimized, which has to be implemented by the user
CFCNGradAdapter	Template wrapped class for adapting to FCNBase signature a IGradFunction
CFCNGradientBase	Extension of the FCNBase for providing the analytical Gradient of the function
CFlatRandomGen
CFumiliBuilder	Builds the FunctionMinimum using the Fumili method
CFumiliChi2FCN	Extension of the FCNBase for the Fumili method
CFumiliErrorUpdator	In the case of the Fumili algorithm the Error matrix (or the Hessian matrix containing the (approximate) second derivatives) is calculated using a linearization of the model function negleting second derivatives
CFumiliFCNAdapter	Template wrapped class for adapting to FumiliFCNBase signature
CFumiliFCNBase	Extension of the FCNBase for the Fumili method
CFumiliGradientCalculator
CFumiliMaximumLikelihoodFCN	Extension of the FCNBase for the Fumili method
CFumiliMinimizer	Instantiates the seed generator and Minimum builder for the Fumili minimization method
CFumiliStandardChi2FCN	Class implementing the standard chi square function, which is the sum of the squares of the figures-of-merit calculated for each measurement point, the individual figures-of-merit being: (the Value predicted by the model-measured Value)/standard deviation
CFumiliStandardMaximumLikelihoodFCN	Class implementing the Elements member function for the standard maximum likelihood method
CFunctionGradient
CFunctionMinimizer	Base 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
►CFunctionMinimum	Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum
CMnAboveMaxEdm
CMnReachedCallLimit
CGaussDataGen
CGaussFcn
CGaussFcn2
CGaussFunction
CGaussianModelFunction	Sample implementation of a parametric function
CGaussRandomGen
Cgen
CGenericFunction	Class from which all the other classes, representing functions, inherit
CGradientCalculator	Interface class for gradient calculators
CHessianGradientCalculator	HessianGradientCalculator: class to calculate Gradient for Hessian
CInitialGradientCalculator	Class to calculate an initial estimate of the gradient
CLASymMatrix	Class describing a symmetric matrix of size n
CLAVector
CMatrixInverse
CMatrixInverse< vec, M, T >
CMinimumBuilder
►CMinimumError	MinimumError keeps the inv
CMnHesseFailed
CMnInvertFailed
CMnMadePosDef
CMnNotPosDef
CMinimumErrorUpdator
CMinimumParameters
CMinimumSeed	MinimumSeed contains the starting values for the minimization produced by the SeedGenerator
CMinimumSeedGenerator	Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization;
CMinimumState	MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder)
CMinosError	Class holding the result of Minos (lower and upper values) for a specific parameter
CMinuit2Minimizer	Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm
CMinuitParameter	Class 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;
CMnApplication	Application interface class for minimizers (migrad, simplex, Minimize, Scan) User normally instantiates the derived class like ROOT::Minuit2::MnMigrad for using Migrad for minimization
CMnContours	API 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;
CMnCovarianceSqueeze	Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index
►CMnCross
CCrossFcnLimit
CCrossNewMin
CCrossParLimit
CMnEigen	API class for calculating the eigenvalues of symmetric matrix
CMnFcn	Wrapper class to FCNBase interface used internally by Minuit
CMnFumiliMinimize	API class for minimization using Fumili technology; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CMnFunctionCross	MnFunctionCross
CMnGlobalCorrelationCoeff	Class for global correlation coefficient
CMnHesse	API class for calculating the numerical covariance matrix (== 2x Inverse Hessian == 2x Inverse 2nd derivative); can be used by the user or Minuit itself
CMnLineSearch	Implements a 1-dimensional minimization along a given direction (i.e
CMnMachinePrecision	Determines the relative floating point arithmetic precision
CMnMigrad	API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CMnMinimize	API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CMnMinos	API 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;
CMnParabola	This class defines a parabola of the form a*x*x + b*x + c
CMnParabolaFactory
CMnParabolaPoint	A point of a parabola
CMnParameterScan	Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found
CMnPlot	MnPlot produces a text-screen graphical output of (x,y) points, e.g
CMnPosDef	Force the covariance matrix to be positive defined by adding extra terms in the diagonal
CMnPrint
CMnRefCountedPointer
CMnReferenceCounter
CMnScan	API class for minimization using a scan method to find the minimum; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CMnSeedGenerator	Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer;
CMnSimplex	API class for minimization using the Simplex method, which does not need and use the derivatives of the function, but only function values
CMnStrategy	API 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)
CMnTiny
CMnTraceObject
CMnUserCovariance	Class containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide internal matrix representation to user
CMnUserFcn	Wrapper used by Minuit of FCN interface containing a reference to the transformation object
CMnUserParameters	API 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
CMnUserParameterState	Class which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand;
CMnUserTransformation	Class dealing with the transformation between user specified parameters (external) and internal parameters used for minimization
CMnVectorTransform
CModularFunctionMinimizer	Base common class providing the API for all the minimizer Various Minimize methods are provided varying on the type of FCN function passesd and on the objects used for the parameters
CMPIProcess
CMPITerminate
CNegativeG2LineSearch	In 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
CNumerical2PGradientCalculator	Class performing the numerical gradient calculation
CParametricFunction	Function which has parameters
CQuad12F
CQuad1F
CQuad4F
CQuad4FGrad
CQuad8F
CScanBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CScanMinimizer	Class implementing the required methods for a minimization using SCAN API is provided in the upper ROOT::Minuit2::ModularFunctionMinimizer class
CSimplexBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CSimplexMinimizer	Class implementing the required methods for a minimization using Simplex
CSimplexParameters	Class describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process
CSimplexSeedGenerator	Generate Simplex starting point (state)
CSinParameterTransformation	Class for the transformation for double-limited parameter Using a sin function one goes from a double-limited parameter range to an unlimited one
CSqrtLowParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CSqrtUpParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CStackAllocator	StackAllocator controls the memory allocation/deallocation of Minuit
CStackAllocatorHolder
CStackError
CStackOverflow	Define stack allocator symbol
Csym
CVariableMetricBuilder	Build (find) function minimum using the Variable Metric method (MIGRAD)
CVariableMetricEDMEstimator
CVariableMetricMinimizer	Instantiates the SeedGenerator and MinimumBuilder for Variable Metric Minimization method
Cvec
CVectorOuterProduct
►NQuartz
CCGAAStateGuard
CCGStateGuard
CTextLine
►NR	Namespace associated R package for ROOT
Cclass_
►CTRDataFrame	This is a class to create DataFrames from ROOT to R
CBinding
CTRFunctionExport	This is a class to pass functions from ROOT to R
CTRFunctionImport	This is a class to pass functions from ROOT to R
►CTRInterface
CBinding
CTRObject	This is a class to get ROOT's objects from R's objects
►NTF1Helper
CTGradientParFunction	Function class representing the derivative with respect a parameter of a given TF1
►NTMetaUtils
►CAnnotatedRecordDecl
CCompareByName
CRConstructorType
CTClingLookupHelper
CTNormalizedCtxt
►Nv5
CTF1Data
CTFormula
CTFormulaPrimitive
CTOperOffset
►NVc
►NAVX
Cc_log
Cc_log< double >
Cc_trig
CConst
CDebugStream
CForeachHelper
CGatherHelper
CHasVectorDivisionHelper
CIndexesFromZeroData
CIndexesFromZeroData< char >
CIndexesFromZeroData< int >
CIndexesFromZeroData< short >
CIndexesFromZeroData< signed char >
CIndexesFromZeroData< unsigned char >
CIndexesFromZeroData< unsigned int >
CIndexesFromZeroData< unsigned short >
CIndexTypeHelper
CIndexTypeHelper< char >
CIndexTypeHelper< double >
CIndexTypeHelper< float >
CIndexTypeHelper< int >
CIndexTypeHelper< sfloat >
CIndexTypeHelper< short >
CIndexTypeHelper< unsigned char >
CIndexTypeHelper< unsigned int >
CIndexTypeHelper< unsigned short >
CMask
CMask< VectorSize, 16u >
CMask< VectorSize, 32u >
CScatterHelper
CSortHelper
CSseVectorType
CSseVectorType< m128 >
CSseVectorType< m128d >
CSseVectorType< m128i >
CSseVectorType< m256 >
CSseVectorType< m256d >
CSseVectorType< m256i >
CStaticCastHelper
CStaticCastHelper< double, double >
CStaticCastHelper< double, float >
CStaticCastHelper< double, int >
CStaticCastHelper< double, unsigned int >
CStaticCastHelper< float, double >
CStaticCastHelper< float, float >
CStaticCastHelper< float, int >
CStaticCastHelper< float, short >
CStaticCastHelper< float, unsigned int >
CStaticCastHelper< float, unsigned short >
CStaticCastHelper< int, double >
CStaticCastHelper< int, float >
CStaticCastHelper< int, int >
CStaticCastHelper< int, short >
CStaticCastHelper< int, unsigned int >
CStaticCastHelper< sfloat, short >
CStaticCastHelper< sfloat, unsigned short >
CStaticCastHelper< short, float >
CStaticCastHelper< short, int >
CStaticCastHelper< short, sfloat >
CStaticCastHelper< short, short >
CStaticCastHelper< short, unsigned short >
CStaticCastHelper< unsigned int, double >
CStaticCastHelper< unsigned int, float >
CStaticCastHelper< unsigned int, int >
CStaticCastHelper< unsigned int, unsigned int >
CStaticCastHelper< unsigned int, unsigned short >
CStaticCastHelper< unsigned short, float >
CStaticCastHelper< unsigned short, sfloat >
CStaticCastHelper< unsigned short, short >
CStaticCastHelper< unsigned short, unsigned int >
CStaticCastHelper< unsigned short, unsigned short >
CSwizzledVector
CVector
CVectorHelper
CVectorHelper< char >
CVectorHelper< double >
CVectorHelper< float >
CVectorHelper< int >
CVectorHelper< m128i >
CVectorHelper< m256 >
CVectorHelper< m256d >
CVectorHelper< m256i >
CVectorHelper< sfloat >
CVectorHelper< signed short >
CVectorHelper< unsigned char >
CVectorHelper< unsigned int >
CVectorHelper< unsigned short >
CVectorHelperSize
CVectorTypeHelper
CVectorTypeHelper< char >
CVectorTypeHelper< double >
CVectorTypeHelper< float >
CVectorTypeHelper< int >
CVectorTypeHelper< sfloat >
CVectorTypeHelper< short >
CVectorTypeHelper< unsigned char >
CVectorTypeHelper< unsigned int >
CVectorTypeHelper< unsigned short >
CWriteMaskedVector
►NCommon
►NInternal
CCopyConst
CCopyConst< const A, B >
CEnableInterleaves
CAliasingEntryHelper
CInterleavedMemoryAccess
CInterleavedMemoryAccessBase
CInterleavedMemoryReadAccess
CInterleavedMemoryWrapper	Wraps a pointer to memory with convenience functions to access it via vectors
CLogImpl
CTypenameForLdexp
CTypenameForLdexp< Vc::sfloat >
CVectorMemoryUnion
CVectorTuple
CVectorTuple< 2, const V >
CVectorTuple< 2, V >
►NError
Cinvalid_operands_of_types
►NInternal
CFlagObject
CFlagObject< AlignedFlag >
CFlagObject< StreamingAndAlignedFlag >
CFlagObject< StreamingAndUnalignedFlag >
CFlagObject< UnalignedFlag >
CHelperImpl
CHelperImpl< SSE3Impl >
CHelperImpl< SSE41Impl >
CHelperImpl< SSE42Impl >
CHelperImpl< SSSE3Impl >
CHelperImpl< Vc::AVXImpl >
CHelperImpl< Vc::ScalarImpl >
CHelperImpl< Vc::SSE2Impl >
CMapImpl
CMapImpl< Vc::SSE42Impl >
►NMem
CScaleForBlend
►NScalar
CForeachHelper
CMask
CSwizzledVector
CVector
CVectorAlignedBaseT
CWriteMaskedVector
►NSSE
Cc_general
Cc_log
Cc_log< double >
Cc_trig
CConst
CCtorTypeHelper
CCtorTypeHelper< float >
CCtorTypeHelper< short >
CCtorTypeHelper< unsigned short >
CDebugStream
CDetermineGatherMask
CDetermineGatherMask< Float8Mask >
CDetermineMask
CDetermineMask< sfloat, 8 >
CExpandTypeHelper
CExpandTypeHelper< float >
CExpandTypeHelper< short >
CExpandTypeHelper< unsigned short >
CFloat8GatherMask
CFloat8Mask
CForeachHelper
CIndexTypeHelper
CIndexTypeHelper< 16u >
CIndexTypeHelper< 2u >
CIndexTypeHelper< 4u >
CIndexTypeHelper< 8u >
CM256
CMask
CMaskHelper
CMaskHelper< 2 >
CMaskHelper< 4 >
CMaskHelper< 8 >
CParameterHelper
CSortHelper
CSortHelper< M256, Size >
CStaticCastHelper
CStaticCastHelper< double, double >
CStaticCastHelper< double, float >
CStaticCastHelper< double, int >
CStaticCastHelper< double, unsigned int >
CStaticCastHelper< float, double >
CStaticCastHelper< float, float >
CStaticCastHelper< float, int >
CStaticCastHelper< float, short >
CStaticCastHelper< float, unsigned int >
CStaticCastHelper< float, unsigned short >
CStaticCastHelper< float8, short >
CStaticCastHelper< float8, unsigned short >
CStaticCastHelper< int, double >
CStaticCastHelper< int, float >
CStaticCastHelper< int, int >
CStaticCastHelper< int, unsigned int >
CStaticCastHelper< short, float8 >
CStaticCastHelper< short, short >
CStaticCastHelper< short, unsigned short >
CStaticCastHelper< unsigned int, double >
CStaticCastHelper< unsigned int, float >
CStaticCastHelper< unsigned int, int >
CStaticCastHelper< unsigned int, unsigned int >
CStaticCastHelper< unsigned short, float8 >
CStaticCastHelper< unsigned short, short >
CStaticCastHelper< unsigned short, unsigned short >
CSwizzledVector
CVector
CVectorHelper
CVectorHelper< _M128 >
CVectorHelper< _M128D >
CVectorHelper< _M128I >
CVectorHelper< double >
CVectorHelper< float >
CVectorHelper< float8 >
CVectorHelper< int >
CVectorHelper< M256 >
CVectorHelper< signed short >
CVectorHelper< unsigned int >
CVectorHelper< unsigned short >
CVectorHelperSize
CVectorTraits
CVectorTypeHelper
CVectorTypeHelper< double >
CVectorTypeHelper< float >
CVectorTypeHelper< sfloat >
CWriteMaskedVector
C_MemorySizeCalculation
CBinaryOperation
CCpuId	This class is available for x86 / AMD64 systems to read and interpret information about the CPU's capabilities
CDetermineEntryType
CDetermineEntryType< sfloat >
CImplementationT
CMath
CMath< double >
CMath< float >
CMemory	A helper class for fixed-size two-dimensional arrays
CMemory< V, 0u, 0u >	A helper class that is very similar to Memory<V, Size> but with dynamically allocated memory and thus dynamic size
CMemory< V, Size, 0u >	A helper class to simplify usage of correctly aligned and padded memory, allowing both vector and scalar access
CMemoryBase	Common interface to all Memory classes, independent of allocation on the stack or heap
CMemoryDimensionBase
CMemoryDimensionBase< V, Parent, 1, RowMemory >
CMemoryDimensionBase< V, Parent, 2, RowMemory >
CNegateTypeHelper
CNegateTypeHelper< unsigned char >
CNegateTypeHelper< unsigned int >
CNegateTypeHelper< unsigned short >
COperand
Csfloat
CTrigonometric
CVectorPointerHelper	Helper class for the Memory::vector(size_t) class of functions
CVectorPointerHelperConst	Helper class for the Memory::vector(size_t) class of functions
C_Configuration	Configuration ------------------------------------------------------------—
C_ExpandMacroFunction	Put std namespace directly onto ROOT ----------------------------------——
CModuleFacade	Allow loading ROOT classes as attributes ---------------------------------—
CRootNameCompleter
►CTAxisBase	Histogram axis base class
Cconst_iterator	Random const_iterator through bins
►CTAxisConfig	Objects used to configure the different axis types
CGrow_t	Tag type signalling that an axis should be able to grow; used for calling the appropriate constructor
CTAxisEquidistant	Axis with equidistant bin borders
CTAxisGrow	An axis that can extend its range, keeping the number of its bins unchanged
CTAxisIrregular	An axis with non-equidistant bins (also known as "variable binning")
CTAxisLabels	A TAxisGrow that has a label assigned to each bin and a bin width of 1
CTAxisView	Common view on a TAxis, no matter what its kind
CTCanvas	Graphic container for TDrawable-s
CTCoopPtr	Several pointers point to the same object, any of them can delete the object, setting all of them to nullptr
CTDirectory	Key/value store of objects
CTFilePtr	Points to an object that stores or reads objects in ROOT's binary format
CTFitResult
CTFunction
CTGenericClassInfo
CTHist	Histogram class for histograms with DIMENSIONS dimensions, where each bin count is stored by a value of type PRECISION
CTHistBufferedFill	Buffers calls to Fill()
CTHistConcurrentFiller	Buffers a thread's Fill calls and submits them to the THistConcurrentFillManager
CTHistConcurrentFillManager	Manages the synchronization of calls to FillN()
CTHistDrawOptions	Drawing options for a histogram with DIMENSIONS
CTHistStatEntries
CTHistStatMomentUncert
CTHistStatRuntime
CTHistStatUncertainty
CTHistView	A view on a histogram, selecting a range on a subset of dimensions
CTHistViewOutOfRange
CTKey
CTLogEntry
CTLogHandler	Abstract TLogHandler base class
CTLogManager
►CTSchemaRule
CTSources
►NROOTaaS
►Nhtml
►Nexport
►Ncpphighlighter
CCppHighlighter
►NiPyROOT
►Ncppcompleter
CCppCompleter
►Ncppmagic
CCppMagics
►Ncpptransformer
CCppTransformer
►Nutils
CCanvasDrawer
CCaptureDrawnCanvases
CStreamCapture
►NRootCsg	I've modified some very nice bounding box tree code from Gino van der Bergen's Free Solid Library below
CTBaseMesh
►NROOTwriter
CROOTwriter
►Nstd	STL namespace
►Ndetail
Cindices
Cis_array_class
Cis_array_class< std::array< T, N > >
Cis_array_class< std::initializer_list< T > >
Cis_array_class< std::vector< T > >
Cmake_indices_
►Cmake_indices_impl
Ctype
Cmake_indices_impl< First, Step, N, typename std::enable_if<(N==0)>::type >
Cmake_indices_impl< First, Step, N, typename std::enable_if<(N==1)>::type >
Cmake_indices_next
Cmake_indices_next2
Cmake_indices_next2< indices< Indices...>, Next, Tail >
Cmake_indices_next< indices< Indices...>, Next >
Carray_view
Ccheck_bound_t
Chash< ROOT::TKey >
Cnumeric_limits< ::ROOT::Vc::SSE::int_v >
Cnumeric_limits< ::ROOT::Vc::SSE::short_v >
Cnumeric_limits< ::ROOT::Vc::SSE::uint_v >
Cnumeric_limits< ::ROOT::Vc::SSE::ushort_v >
►NTClassEdit
CTInterpreterLookupHelper
CTSplitType
►NTCollectionProxyInfo
CEnviron	Small helper to save proxy environment in the event of recursive calls
CMap	Small helper to encapsulate all necessary data accesses for containers like vector, list, deque
CPushfront	Small helper to encapsulate all necessary data accesses for containers like forward_list
CType	Small helper to encapsulate basic data accesses for all STL continers
►NTMath
CLimits
►NTMVA	Abstract ClassifierFactory template that handles arbitrary types
►NkNN
CEvent
CModulekNN
CNode
CAbsValue
CBDTEventWrapper
CBinarySearchTree
CBinarySearchTreeNode
CBinaryTree
CCCPruner
►CCCTreeWrapper
CCCTreeNode
CClassifierFactory
CClassInfo
Ccompose_binary_t
Ccompose_unary_t
►CConfig
CIONames
CVariablePlotting
CConfigurable
CConvergenceTest
CCostComplexityPruneTool
CCrossEntropy
CDataInputHandler
CDataSet
►CDataSetFactory
CEventStats
CDataSetInfo
CDataSetManager
CDecisionTree
CDecisionTreeNode
CDeleteFunctor_t
CDTNodeTrainingInfo
CEvent
CExpectedErrorPruneTool
CFactory
CFitterBase
CGeneticAlgorithm
CGeneticFitter
CGeneticGenes
CGeneticPopulation
CGeneticRange
CGiniIndex
CGiniIndexWithLaplace
CIFitterTarget
CIMethod
CIncrement
CInterval
CIPruneTool
CKDEKernel
CLDA
CLogInterval
CMCFitter
CMethodANNBase
CMethodBase
CMethodBayesClassifier
CMethodBDT
CMethodBoost
CMethodC50
CMethodCategory
CMethodCFMlpANN
►CMethodCFMlpANN_Utils
CVARn2
CMethodCompositeBase
CMethodCuts
CMethodDT
CMethodFDA
CMethodFisher
CMethodHMatrix
CMethodInfo
CMethodKNN
CMethodLD
CMethodLikelihood
CMethodMLP
CMethodPDEFoam
CMethodPDERS
CMethodPyAdaBoost
CMethodPyGTB
CMethodPyRandomForest
CMethodRSNNS
CMethodRSVM
CMethodRuleFit
CMethodRXGB
CMethodSVM
CMethodTMlpANN
CMinuitFitter
CMinuitWrapper
CMisClassificationError
CMsgLogger
CNode
Cnull_t
COptimizeConfigParameters
COption
COption< T * >
COptionBase
CPDEFoam
CPDEFoamCell
CPDEFoamDecisionTree
CPDEFoamDecisionTreeDensity
CPDEFoamDensityBase
CPDEFoamDiscriminant
CPDEFoamDiscriminantDensity
CPDEFoamEvent
CPDEFoamEventDensity
CPDEFoamKernelBase
CPDEFoamKernelGauss
CPDEFoamKernelLinN
CPDEFoamKernelTrivial
CPDEFoamMultiTarget
CPDEFoamTarget
CPDEFoamTargetDensity
CPDEFoamVect
CPDF
CPruningInfo
CPyMethodBase
►CQuickMVAProbEstimator
CEventInfo
CRandomGenerator
CRank
CRanking
CReader
CRegressionVariance
CResults
CResultsClassification
CResultsMulticlass
CResultsRegression
CRMethodBase
CROCCalc
CRootFinder
CRule
CRuleCut
CRuleEnsemble
CRuleFit
►CRuleFitAPI
CIntParms
CRealParms
CRuleFitParams
CSdivSqrtSplusB
CSeparationBase
CSimulatedAnnealing
CSimulatedAnnealingFitter
CStatDialogBDT
CStatDialogBDTReg
CStatDialogMVAEffs
CSVEvent
CSVKernelFunction
CSVKernelMatrix
CSVWorkingSet
CTActivation
CTActivationChooser
CTActivationIdentity
CTActivationRadial
CTActivationReLU
CTActivationSigmoid
CTActivationTanh
CTimer
CTMVAGaussPair
CTMVAGUI
CTNeuron
CTNeuronInput
CTNeuronInputAbs
CTNeuronInputChooser
CTNeuronInputSqSum
CTNeuronInputSum
CTools
►CTransformationHandler
CVariableStat
CTreeInfo
CTSpline1
CTSpline2
CTSynapse
CTypes
CVariableDecorrTransform
CVariableGaussTransform
CVariableIdentityTransform
CVariableInfo
CVariableNormalizeTransform
CVariablePCATransform
CVariableRearrangeTransform
CVariableTransformBase
CVolume
►NTStreamerInfoActions
CTActionSequence
CTConfiguration	Base class of the Configurations
CTConfiguredAction
CTLoopConfiguration	Base class of the Configurations for the member wise looping routines
►Nvdt
►Ndetails
Cieee754	Used to switch between different type of interpretations of the data (64 bits)
►Nwriter
Cwriter
C_root_std_complex
C_Ulp_ExponentVector
C_Ulp_ExponentVector< Vc::sfloat_v >
C_UnitTest_Compare
C_UnitTest_Failure
C_UnitTest_Global_Object
C_x3d_data_
C_x3d_sizeof_
CADD_PASS
CAnyCollectionProxy
CAnyCollectionStreamer
CApplicationWindow	Main Qt&Root Application Window:
►CBaker
COptions
CBalancerInfo
CBaseSelectionRule
Cbasic_string_view
►CBidirMMapPipe	BidirMMapPipe creates a bidirectional channel between the current process and a child it forks
CPollEntry	For poll() interface
CBinaryOpPolicy
CBinomialNeymanInterval
CBinomialProbHelper
CClassSelectionRule
CClusterD
CColorStruct_t
CCompareAsc
CcompareBAasc
CcompareBAdesc
CCompareDesc
CContDist	Free functions adapter needed by UNURAN for onedimensional continuous distributions
CContext	Small helper to keep current directory context
CCpuInfo_t
CDiscrDist	Free functions adapter needed by UNURAN for one-dimensional discrete distribution
Cdrr_func_cache
Cdrr_func_entry
CDUMMY
CEditor
CEvent_t
CExceptionContext_t
CexponentToDivisor
CexponentToDivisor< 1, center >
CexponentToDivisor< 1024, center >
CexponentToDivisor< 128, center >
CexponentToDivisor< 256, center >
CexponentToDivisor< 384, center >
CexponentToDivisor< 512, center >
CexponentToDivisor< 640, center >
CexponentToDivisor< 768, center >
CexponentToDivisor< 896, center >
CexponentToDivisor< center, center >
CexponentToMultiplier
CexponentToMultiplier< -1, center >
CexponentToMultiplier< -128, center >
CexponentToMultiplier< -256, center >
CexponentToMultiplier< -384, center >
CexponentToMultiplier< -512, center >
CexponentToMultiplier< -640, center >
CexponentToMultiplier< -768, center >
CexponentToMultiplier< -896, center >
CexponentToMultiplier< center, center >
CexponentToMultiplier<-1024, center >
CFeldmanCousinsBinomialInterval
CFeldmanCousinsSorter
CFileStat_t
CFontAttributes_t
CFontMetrics_t
CFoption_t
CFUMILI2
Cfuncptr_and_voidptr_t
CGaussFunction
CGcCache_t
CGCValues_t
Cgroup
CGSL_BFGS
CGSL_BFGS2
CGSL_FR
CGSL_NLS
CGSL_PR
Chash< std::experimental::basic_string_view< _CharT, _Traits > >
CHelperOps
CHEPEVT_DEF
CHoption_t	Histogram option structure
CHparam_t	Histogram parameters structure
CisEqualType
CisEqualType< T, T >
CLINEAR
CMainWindow
CMandel
CMandelBase
CMemInfo_t
Cmg_callbacks
►Cmg_request_info
Cmg_header
CMINUIT2
CMultiDist	Free functions adapter needed by UNURAN for multidimensional cont distribution
CMYSQL_BIND
CMYSQL_STMT
►CParamHistFunc
CCacheElem
CPassiveKeyGrab
Cpasswd
CPgSQL_Stmt_t
CPictureAttributes_t
►CPiecewiseInterpolation
CCacheElem
CPoint_t
CProcInfo_t
CProgressWriter
CProofServEnv_t
Cpthread_cond_t
CPybins_t
CPydat1_t
CPydat2_t
CPydat3_t
CPydat4_t
CPydatr_t
CPyint1_t
CPyint2_t
CPyint3_t
CPyint4_t
CPyint5_t
CPyint6_t
CPyint7_t
CPyint8_t
CPyint9_t
CPyints_t
CPyjets_t
CPymssm_t
CPypars_t
CPyssmt_t
CPysubs_t
CQuartzImage
CQuartzPixmap
CQuartzView
CQuartzWindow
CRectangle_t
CRedirectHandle_t
Credirguard
Crng_state_st
CRoo1DMomentMorphFunction	1-dimensional morph function between a list of input functions (varlist) as a function of one input parameter (m)
CRoo1DTable
CRoo2DKeysPdf	Two-dimensional kernel estimation PDF
►CRoo2DMomentMorphFunction	2-dimensional morph function between a list of function-numbers as a function of two input parameters (m1 and m2)
CSorterL2H
►CRooAbsAnaConvPdf
CCacheElem	Iterator over _convNormSet
CRooAbsArg	RooAbsArg is the common abstract base class for objects that represent a value (of arbitrary type) and "shape" that in general depends on (is a client of) other RooAbsArg subclasses
CRooAbsBinning
CRooAbsCache
►CRooAbsCachedPdf
CAnaIntConfig	Registry for analytical integration codes
CPdfCacheElem
►CRooAbsCachedReal
CFuncCacheElem
CRooAbsCacheElement
CRooAbsCategory
CRooAbsCategoryLValue
CRooAbsCollection
►CRooAbsData
CPlotOpt
CRooAbsDataStore
CRooAbsFunc
CRooAbsGenContext
CRooAbsHiddenReal
CRooAbsIntegrator
CRooAbsLValue
CRooAbsMCStudyModule
CRooAbsMoment
CRooAbsNumGenerator
CRooAbsOptTestStatistic
►CRooAbsPdf	RooAbsPdf is the abstract interface for all probability density functions The class provides hybrid analytical/numerical normalization for its implementations, error tracing and a MC generator interface
CCacheElem	Normalization set with for above integral
CGenSpec
CRooAbsProxy
►CRooAbsReal	RooAbsReal is the common abstract base class for objects that represent a real value and implements functionality common to all real-valued objects such as the ability to plot them, to construct integrals of them, the ability to advertise (partial) analytical integrals etc
CEvalError
CPlotOpt
CRooAbsRealLValue
CRooAbsRootFinder
CRooAbsSelfCachedPdf
CRooAbsSelfCachedReal
CRooAbsString
CRooAbsStudy
CRooAbsTestStatistic
CRooAcceptReject
CRooAdaptiveGaussKronrodIntegrator1D
CRooAdaptiveIntegratorND
CRooAddGenContext
►CRooAddition
CCacheElem	Iterator over set
►CRooAddModel
CCacheElem	Transiet cache with transformed values of coefficients
CIntCacheElem
►CRooAddPdf
CCacheElem	Transiet cache with transformed values of coefficients
CRooAICRegistry
CRooArgList
CRooArgProxy
CRooArgSet
CRooArgusBG	RooArgusBG is a RooAbsPdf implementation describing the ARGUS background shape
CRooBCPEffDecay	PDF describing decay time distribution of B meson including effects of standard model CP violation
CRooBCPGenDecay
CRooBDecay
CRooBernstein
CRooBifurGauss
CRooBinIntegrator
CRooBinnedGenContext
CRooBinning
CRooBinningCategory
CRooBlindTools
CRooBMixDecay
CRooBreitWigner
CRooBrentRootFinder
CRooBukinPdf
CRooCachedPdf
CRooCachedReal
CRooCacheManager
CRooCategory
CRooCategoryProxy
CRooCategorySharedProperties
CRooCatType
CRooCBShape
CRooCFunction1Binding
CRooCFunction1Map
CRooCFunction1PdfBinding
CRooCFunction1Ref
CRooCFunction2Binding
CRooCFunction2Map
CRooCFunction2PdfBinding
CRooCFunction2Ref
CRooCFunction3Binding
CRooCFunction3Map
CRooCFunction3PdfBinding
CRooCFunction3Ref
CRooCFunction4Binding
CRooCFunction4Map
CRooCFunction4PdfBinding
CRooCFunction4Ref
CRooChangeTracker
CRooChebychev
CRooChi2MCSModule
CRooChi2Var
CRooChiSquarePdf
►CRooClassFactory
CClassFacIFace
CRooCmdArg
CRooCmdConfig
CRooComplex
CRooCompositeDataStore
CRooConstraintSum
CRooConstVar
CRooConvCoefVar
CRooConvGenContext
CRooConvIntegrandBinding
CRooCurve
►CRooCustomizer
CCustIFace
CRooDataHist
CRooDataHistSliceIter
CRooDataProjBinding
CRooDataSet
CRooDataWeightedAverage
CRooDecay
CRooDerivative
CRooDirItem
CRooDLLSignificanceMCSModule
CRooDouble
CRooDstD0BG
CRooEffGenContext
CRooEfficiency
►CRooEffProd
CCacheElem
CRooEllipse
CRooErrorHandler
CRooErrorVar
►CRooExpensiveObjectCache
CExpensiveObject
CRooExponential
CRooExtendedBinding
CRooExtendedTerm
CRooExtendPdf
►CRooFactoryWSTool
CIFace
CSpecialsIFace
►CRooFFTConvPdf
CFFTCacheElem
CRooFirstMoment
CRooFIter
CRooFitResult
CRooFoamGenerator
CRooFormula
CRooFormulaVar
CRooFracRemainder
CRooFunctor
CRooFunctor1DBinding
CRooFunctor1DPdfBinding
CRooFunctorBinding
CRooFunctorPdfBinding
CRooGamma
CRooGaussian
CRooGaussKronrodIntegrator1D
CRooGaussModel
CRooGenContext
CRooGenericPdf
CRooGenFitStudy
CRooGenFunction
CRooGenProdProj
CRooGExpModel
CRooGlobalFunc
CRooGrid
CRooHashTable
CRooHist
CRooHistConstraint
►CRooHistError
CBinomialSumAsym
CBinomialSumEff
CPoissonSum
CRooHistFunc
CRooHistPdf
CRooImproperIntegrator1D
CRooInt
►CRooIntegralMorph
CMorphCacheElem
CRooIntegrator1D
CRooIntegrator2D
CRooIntegratorBinding
CRooInvTransform
CRooJeffreysPrior
CRooKeysPdf
CRooLandau
CRooLegendre
CRooLinearVar
CRooLinkedList
CRooLinkedListElem
CRooLinkedListIter
CRooLinTransBinning
CRooList
CRooListProxy
CRooLognormal
CRooMapCatEntry
►CRooMappedCategory
CEntry
CRooMath
CRooMathCoreReg
CRooMathMoreReg
CRooMCIntegrator
CRooMCStudy
CRooMinimizer
CRooMinimizerFcn
CRooMinuit
CRooMoment
►CRooMomentMorph
CCacheElem
CRooMPSentinel
►CRooMsgService
CStreamConfig
CRooMultiBinomial
CRooMultiCategory
CRooMultiCatIter
CRooMultiGenFunction
►CRooMultiVarGaussian
CAnaIntData
CBitBlock
CGenData
CRooNameReg
CRooNameSet
►CRooNDKeysPdf
CBoxInfo
CSorterTV_L2H	Sorter function
CRooNLLVar
CRooNonCentralChiSquare
CRooNonCPEigenDecay
►CRooNormSetCache
CPairCmp
CRooNovosibirsk
CRooNumber
CRooNumCdf
CRooNumConvolution
CRooNumConvPdf
CRooNumGenConfig
CRooNumGenFactory
CRooNumIntConfig
CRooNumIntFactory
►CRooNumRunningInt
CRICacheElem
CRooObjCacheManager
CRooParamBinning
CRooParametricStepFunction
CRooParamHistFunc
►CRooPlot
CDrawOpt
CRooPlotable
CRooPoisson
CRooPolynomial
CRooPolyVar
CRooPrintable
CRooProdGenContext
►CRooProdPdf
CCacheElem
►CRooProduct
CCacheElem
CRooProfileLL
►CRooProjectedPdf
CCacheElem
CRooProofDriverSelector
CRooPullVar
CRooQuasiRandomGenerator
►CRooRandom
CGuard
►CRooRandomizeParamMCSModule
CGausParam
CGausParamSet
CUniParam
CUniParamSet
CRooRangeBinning
CRooRangeBoolean
CRooRealAnalytic
CRooRealBinding
CRooRealConstant
CRooRealIntegral
CRooRealMPFE
CRooRealProxy
►CRooRealSumPdf
CCacheElem
CRooRealVar
CRooRealVarSharedProperties
CRooRecursiveFraction
CRooRefArray
CRooRefCountList
CRooResolutionModel
CRooScaledFunc
CRooSecondMoment
CRooSegmentedIntegrator1D
CRooSegmentedIntegrator2D
CRooSentinel
CRooSetPair
CRooSetProxy
CRooSharedProperties
CRooSharedPropertiesList
CRooSimGenContext
CRooSimPdfBuilder
CRooSimSplitGenContext
►CRooSimultaneous
CCacheElem
►CRooSimWSTool
CBuildConfig
CMultiBuildConfig
CObjBuildConfig
CObjSplitRule
CSimWSIFace
CSplitRule
CRooSpHarmonic
CRooStepFunction
CRooStreamParser
CRooStringVar
CRooStudyManager
CRooStudyPackage
CRooSuperCategory
CRooTable
CROOTApplicationDelegate
CRooTFnBinding
CRooTFnPdfBinding
CRooTFoamBinding
CRooThreshEntry
CRooThresholdCategory
CRooTMathReg
CRooTObjWrap
CROOTOpenGLView
CRooTrace
CRooTreeData
CRooTreeDataStore
CRooTruthModel
CRooUnblindCPAsymVar
CRooUnblindOffset
CRooUnblindPrecision
CRooUnblindUniform
CRooUniform
CRooUniformBinning
CRooUnitTest
►CRooVectorDataStore
CCatVector
CRealFullVector
CRealVector
CRooVoigtian
►CRooWorkspace
►CCodeRepo
CClassFiles
CClassRelInfo
CExtraHeader
CWSDir
CRooXYChi2Var
Crr_fcn_info
Crsa_KEY
Crsa_KEY_export
Crsa_NUMBER
►CRScanner
CAnnotatedNamespaceDecl
CSegment_t
CSelectionRules	The class representing the collection of selection rules
CSetWindowAttributes_t
CSHtmlExtensions_t
CSHtmlIndex_t
CSHtmlMargin_t
CSHtmlStyle_t
CSHtmlStyleStack_t
CSHtmlTokenMap_t
CshutterData_t
CSQLite3_Stmt_t
CSysInfo_t
CtableDescriptor_st
CTAdvancedGraphicsDialog
CTAFS
CTAlien
CTAlienCollection
CTAlienDirectory
CTAlienDirectoryEntry
CTAlienFile
CTAliEnFind
CTAlienJDL
CTAlienJob
CTAlienJobStatus
CTAlienJobStatusList
CTAlienMasterJob
CTAlienMasterJobStatus
CTAlienPackage
CTAlienResult
CTAlienSystem
CTApplication	This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers
CTApplicationImp	ABC describing GUI independent application implementation protocol
►CTApplicationRemote
CTARFileStat
CTApplicationServer
CTArc	Create an Arc
CTArcBall	Implements the arc-ball rotation manipulator
CTArchiveFile	Class describing an archive file containing multiple sub-files, like a ZIP or TAR archive
CTArchiveMember
CTARInterruptHandler
CTArray	Abstract array base class
CTArrayC	Array of chars or bytes (8 bits per element)
CTArrayD	Array of doubles (64 bits per element)
CTArrayF	Array of floats (32 bits per element)
CTArrayI	Array of integers (32 bits per element)
CTArrayL	Array of longs (32 or 64 bits per element)
CTArrayL64	Array of long64s (64 bits per element)
CTArrayS	Array of shorts (16 bits per element)
CTArrow	Draw all kinds of Arrows
CTArrowEditor
CTASImage	Image class
CTASImagePlugin
CTASLogHandler
CTASLogHandlerGuard
►CTASPaletteEditor	This is a GUI window to edit a color palette
CLimitLine
CPaintPalette
CTASPluginGS	Allows to read PS/EPS/PDF files via GhostScript
►CTAtomicCount
CLockGuard
CTAtt3D	Use this attribute class when an object should have 3D capabilities
CTAttAxis	Manages histogram axis attributes
CTAttBBox	Helper for management of bounding-box information
CTAttBBox2D	Abstract base class for elements drawn in the editor
CTAttCanvas	Manages canvas attributes
CTAttFill	Fill Area Attributes class
CTAttFillEditor
CTAttImage	TImage attributes
CTAttLine	Line Attributes class
CTAttLineEditor
CTAttMarker	Marker Attributes class
CTAttMarkerEditor
CTAttPad	Manages default Pad attributes
CTAttParticle
CTAttText	Text Attributes class
CTAttTextEditor
CTAuthenticate
CTAxis	Class to manage histogram axis
CTAxis3D	The 3D axis painter class
CTAxisEditor
CTBackCompFitter	Backward compatible implementation of TVirtualFitter
CTBase64	This code implements the Base64 encoding and decoding
CTBaseClass	Each class (see TClass) has a linked list of its base class(es)
CTBasket	Manages buffers for branches of a Tree
CTBasketSQL	Implement TBasket for a SQL backend
CTBenchmark	This class is a ROOT utility to help benchmarking applications
CTBinomialEfficiencyFitter	Binomial fitter for the division of two histograms
►CTBits	Container of bits
CTReference
CTBonjourBrowser
CTBonjourRecord
CTBonjourRegistrar
CTBonjourResolver
CTBox	Create a Box
CTBranch	A TTree is a list of TBranches
CTBranchClones	A Branch for the case of an array of clone objects
CTBranchElement	A Branch for the case of an object
CTBranchObject	A Branch for the case of an object
CTBranchRef	A branch containing and managing a TRefTable for TRef autoloading
►CTBranchSTL	A Branch handling STL collection of pointers (vectors, lists, queues, sets and multisets) while storing them in split mode
CElementBranchHelper_t
CTBRIK	A box with faces perpendicular to the axes
CTBrowser	Using a TBrowser one can browse all ROOT objects
CTBrowserImp	ABC describing GUI independent browser implementation protocol
CTBrowserPlugin
CTBtInnerNode	Inner node of a TBtree
CTBtItem	Item stored in inner nodes of a TBtree
CTBtLeafNode	Leaf node of a TBtree
CTBtNode	Abstract base class (ABC) of a TBtree node
CTBtree	B-tree class
CTBtreeIter	Iterator of btree
CTBuffer	Buffer base class used for serializing objects
CTBuffer3D	Generic 3D primitive description class
CTBuffer3DCutTube	Cut tube segment description class - see TBuffer3DTypes for producer classes
CTBuffer3DSphere	Sphere description class - see TBuffer3DTypes for producer classes Supports hollow and cut spheres
CTBuffer3DTube	Complete tube description class - see TBuffer3DTypes for producer classes
CTBuffer3DTubeSeg	Tube segment description class - see TBuffer3DTypes for producer classes
CTBuffer3DTypes
CTBufferFile	The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket
CTBufferJSON
CTBufferSQL	Implement TBuffer for a SQL backend
CTBufferSQL2	Converts data to SQL statements or read data from SQL tables
CTBufferXML	Class for serializing/deserializing object to/from xml
CTButton	A TButton object is a user interface object
CTCanvas	The Canvas class
CTCanvasImp	ABC describing GUI independent main window (with menubar, scrollbars and a drawing area)
CTCastorFile	A TNetFile interfaced to the Castor storage backend
CTChain	A chain is a collection of files containg TTree objects
CTChainElement	A TChainElement describes a component of a TChain
►CTChainIndex	A Chain Index
CTChainIndexEntry	Holds a description of indices of trees in the chain
CTChair
CTChirpFile	Read and write data via a Chirp server
CTChirpSystem
CTCivetweb
CTCL
►CTClass	The ROOT global object gROOT contains a list of all defined classes
CInsertTClassInRegistryRAII
CTDeclNameRegistry
CTNameMapNode
CTSpinLockGuard
CTClassDocInfo
CTClassDocOutput
CTClassGenerator	Objects following this interface can be passed onto the TROOT object to implement a user customized way to create the TClass objects
CTClassMenuItem	Describes one element of the context menu associated to a class The menu item may describe
CTClassRef	TClassRef is used to implement a permanent reference to a TClass object
CTClassStreamer
CTClassTable	This class registers for all classes their name, id and dictionary function in a hash table
CTClassTree	Draw inheritance tree and their relations for a list of classes
►CTCling	This class defines an interface to the cling C++ interpreter
CCharPtrCmp_t
CTUniqueString
CTClingBaseClassInfo	Emulation of the CINT BaseClassInfo class
CTClingCallbacks
CTClingCallFunc	Emulation of the CINT CallFunc class
CTClingClassInfo	Emulation of the CINT ClassInfo class
CTClingDataMemberInfo	Emulation of the CINT DataMemberInfo class
CTClingMethodArgInfo	Emulation of the CINT MethodInfo class
CTClingMethodInfo	Emulation of the CINT MethodInfo class
CTClingTypedefInfo	Emulation of the CINT TypedefInfo class
CTClingTypeInfo	Emulation of the CINT TypeInfo class
►CTClingValue	Bridge between cling::Value and ROOT
CHasTheSameSizeAsClingValue
CTClonesArray	An array of clone (identical) objects
CTCollection	Collection abstract base class
CTCollectionClassStreamer	Class streamer object to implement TClassStreamer functionality for I/O emulation
CTCollectionMemberStreamer	Class streamer object to implement TMemberStreamer functionality for I/O emulation
CTCollectionMethodBrowsable	TCollectionMethodBrowsable extends TCollectionPropertyBrowsable by showing all methods of the collection itself
CTCollectionPropertyBrowsable	A tiny browser helper object (and its generator) for adding a virtual (as in "not actually part of the class", not in C++ virtual) "@size()" method to a collection
CTCollectionProxyFactory	TCollectionProxyFactory Interface to collection proxy and streamer generator
CTCollectionStreamer	Class streamer object to implement TClassStreamer functionality for I/O emulation
CTColor	The color creation and management class
►CTColorGradient	TColorGradient extends basic TColor
CPoint
CTColorWheel	Draw the ROOT Color Wheel
CTColumnView
CTComplex
CTCondition
CTConditionImp
CTCondor
CTCondorSlave
CTCONE	A conical tube
CTConfidenceLevel	Class to compute 95% CL limits
CTCONS	A segment of a conical tube
CTContextMenu	This class provides an interface to context sensitive popup menus
CTContextMenuImp	This class provides an interface to GUI independent context sensitive popup menus
CTControlBar	A Control Bar is a fully user configurable tool which provides fast access to frequently used operations
CTControlBarButton	Created by the TControlBar
CTControlBarImp	ABC describing GUI independent control bar
CTConvertClonesArrayToProxy	Small helper to read a TBuffer containing a TClonesArray into any valid collection
CTConvertMapToProxy
CTCreatePrimitives	Creates new primitives
CTCrown	To draw a Crown
CTCTUB	A cut tube with 11 parameters
CTCurlyArc	Implements curly or wavy arcs used to draw Feynman diagrams
CTCurlyArcEditor
CTCurlyLine	Implements curly or wavy polylines used to draw Feynman diagrams
CTCurlyLineEditor
CTCut	A specialized string object used for TTree selections
CTCutG	Graphical cut class
CTDatabasePDG
CTDataMember	All ROOT classes may have RTTI (run time type identification) support added
CTDataSet
CTDataSetIter
CTDataSetManager
CTDataSetManagerAliEn
CTDataSetManagerFile
CTDataType	Basic data type descriptor (datatype information is obtained from CINT)
CTDatime	This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130 124559)
CTDavixFile
CTDavixFileInternal
CTDavixSystem
CTDCacheFile	A TDCacheFile is like a normal TFile except that it may read and write its data via a dCache server (for more on the dCache daemon see http://www-dcache.desy.de/
CTDCacheSystem
CTDecayChannel
CTDecompBase
CTDecompBK
CTDecompChol
CTDecompLU
CTDecompQRH
CTDecompSparse
CTDecompSVD
CTDialogCanvas	A canvas specialized to set attributes
CTDiamond	Draw a Diamond
CTDictAttributeMap	The ROOT object has a list of properties which are stored and retrieved using TDictAttributeMap
CTDictionary	This class defines an abstract interface that must be implemented by all classes that contain dictionary information
►CTDirectory	Describe directory structure in memory
CTContext
CTDirectoryFile	A ROOT file is structured in Directories (like a file system)
CTDNDData
CTDocDirective
CTDocHtmlDirective
CTDocLatexDirective
CTDocMacroDirective
CTDocMethodWrapper
CTDocOutput
CTDocParser
CTDOMParser
CTDrawFeedback
CTDSet
CTDSetElement
CTDSetProxy
CTDsKey
CTEditQueryFrame
CTEfficiency	Class to handle efficiency histograms
CTElementActionT
CTElementPosActionT
CTEllipse	Draw Ellipses
CTELTU	A cylinder with an elliptical section
Ctemplate	Small helper to implement the function to create,access and destroy iterators
Ctemplate	Small helper to encapsulate whether to return the value pointed to by the iterator or its address
CTEmulatedCollectionProxy	Streamer around an arbitrary STL like container, which implements basic container functionality
CTEmulatedMapProxy	Streamer around a map container
CTEntryList	A List of entry numbers in a TTree or TChain
CTEntryListArray	A list of entries and subentries in a TTree or TChain
CTEntryListBlock	Used by TEntryList to store the entry numbers
CTEntryListFromFile	Manages entry lists from different files, when they are not loaded in memory at the same time
CTEnum	Implements the enum type
CTEnumConstant	Implements the constants of the enum type
CTEnv	Reads config files, by default named .rootrc
CTEnvRec
CTestDialog
CTestMainFrame
CTestMsgBox
CTestProgress
CTestShutter
CTestSliders
CTEve3DProjection	3D scaling projection
CTEveArrow	Class used for display of a thick arrow
CTEveArrowEditor	GUI editor for TEveArrow
CTEveArrowGL	OpenGL renderer class for TEveArrow
CTEveBox	3D box with arbitrary vertices (cuboid)
CTEveBoxGL	OpenGL renderer class for TEveBox
CTEveBoxProjected	Projection of TEveBox
CTEveBoxProjectedGL	OpenGL renderer class for TEveBoxProjected
►CTEveBoxSet	Collection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds, cones)
CBAABox_t
CBAABoxFixedDim_t
CBCone_t
CBEllipticCone_t
CBFreeBox_t
CBOrigin_t
CTEveBoxSetGL	A GL rendering class for TEveBoxSet
CTEveBrowser	Specialization of TRootBrowser for Eve
CTEveCalo2D	Visualization of a calorimeter event data in 2D
CTEveCalo2DGL	OpenGL renderer class for TEveCalo2D
CTEveCalo3D	Visualization of a calorimeter event data in 3D
CTEveCalo3DEditor	GUI editor for TEveCalo3D
CTEveCalo3DGL	OpenGL renderer class for TEveCalo3D
►CTEveCaloData	A central manager for calorimeter event data
CCellData_t	Cell data inner structure
CCellGeom_t	Cell geometry inner structure
CCellId_t
CRebinData_t
CSliceInfo_t
CTEveCaloDataHist	A central manager for calorimeter data of an event written in TH2F
CTEveCaloDataVec	Calo data for universal cell geometry
CTEveCaloLego	Visualization of calorimeter data as eta/phi histogram
CTEveCaloLegoEditor	GUI editor for TEveCaloLego
►CTEveCaloLegoGL	OpenGL renderer class for TEveCaloLego
CCell2D_t
CTEveCaloLegoOverlay	GL-overlay control GUI for TEveCaloLego
CTEveCaloViz	Base class for calorimeter data visualization
CTEveCaloVizEditor	GUI editor for TEveCaloEditor
►CTEveChunkManager	Vector-like container with chunked memory allocation
Citerator
CTEveChunkVector
CTEveCluster
CTEveCompositeFrame	Abstract base-class for frame-slots that encompass EVE-windows (sub-classes of TEveWindow)
CTEveCompositeFrameInMainFrame	An EVE window-slot contained within a TGMainFrame
CTEveCompositeFrameInPack	An EVE window-slot contained within one frame of a TGPack
CTEveCompositeFrameInTab	An EVE window-slot contained within one tab of a TGTab
CTEveCompound	Description of TEveCompound
CTEveCompoundProjected	Description of TEveCompoundProjected
CTEveContextMenu	Specialization of TContext menu
►CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
CDigitBase_t
CTEveDigitSetEditor	Editor for TEveDigitSet class
CTEveDigitSetGL	OpenGL renderer class for TEveDigitSet
►CTEveElement	Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management
CTEveListTreeInfo	Structure holding information about TGListTree and TGListTreeItem that represents given TEveElement
CTEveElementEditor	Editor for TEveElement class
CTEveElementList	A list of TEveElements
CTEveElementListProjected	A projected element list – required for proper propagation of render state to projected views
CTEveElementObjectPtr	TEveElement with external TObject as a holder of visualization data
CTEveEventManager	Base class for event management and navigation
CTEveException	Exception class thrown by TEve classes and macros
CTEveFrameBox	Description of a 2D or 3D frame that can be used to visually group a set of objects
CTEveFrameBoxGL	A class encapsulating GL rendering of TEveFrameBox via a static member function
CTEveGDoubleValuator	Composite GUI element for selection of range (label, two number-entries and double-slider)
CTEveGedEditor	Specialization of TGedEditor for proper update propagation to TEveManager
CTEveGedNameFrame	Specialization of TGedNameFrame used in EVE
CTEveGedNameTextButton	Specialization of TGTextButton for EVE name frame
CTEveGeoManagerHolder	Exception safe wrapper for setting gGeoManager
CTEveGeoNode	Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement
CTEveGeoNodeEditor	Editor for TEveGeoNode class
►CTEveGeoPolyShape	Description of TEveGeoPolyShape
CEdge_t
CTEveGeoShape	Wrapper for TGeoShape with absolute positioning and color attributes allowing display of extracted TGeoShape's (without an active TGeoManager) and simplified geometries (needed for non-linear projections)
CTEveGeoShapeExtract	Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts
CTEveGeoShapeProjected	A 3D projected TEveGeoShape
CTEveGeoTopNode	A wrapper over a TGeoNode, possibly displaced with a global trasformation stored in TEveElement
CTEveGeoTopNodeEditor	Editor for TEveGeoTopNode class
CTEveGListTreeEditorFrame	Composite GUI frame for parallel display of a TGListTree and TEveGedEditor
CTEveGridStepper	Provide discrete position coordinates for placement of objects on regular grids
CTEveGridStepperEditor	Editor for TEveGridStepper class
CTEveGridStepperSubEditor	Sub-editor for TEveGridStepper class
CTEveGTriVecValuator	Composite GUI element for setting three numerical values (label, three number-entries)
CTEveGValuator	Composite GUI element for single value selection (supports label, number-entry and slider)
CTEveGValuatorBase	Base class for composite GUI elements for setting of numeric values
CTEveHit
CTEveJetCone	Draws a jet cone with leading particle is specified in (eta,phi) and cone radius is given
CTEveJetConeEditor	GUI editor for TEveJetCone
CTEveJetConeGL	OpenGL renderer class for TEveJetCone
CTEveJetConeProjected	Projection of TEveJetCone
CTEveJetConeProjectedGL	OpenGL renderer class for TEveJetConeProjected
CTEveLegoEventHandler	A base class of TGLEventHandler
CTEveLine	An arbitrary polyline with fixed line and marker attributes
CTEveLineEditor	Editor for TEveLine class
CTEveLineGL	GL-renderer for TEveLine class
CTEveLineProjected	Projected copy of a TEveLine
CTEveListTreeItem	Special list-tree-item for Eve
CTEveMacro	Sub-class of TMacro, overriding Exec to unload the previous version and cleanup after the execution
CTEveMagField	Abstract base-class for interfacing to magnetic field needed by the TEveTrackPropagator
CTEveMagFieldConst	Implements constant magnetic field, given by a vector fB
CTEveMagFieldDuo	Implements constant magnetic filed that switches on given axial radius fR2 from vector fBIn to fBOut
►CTEveManager	Central application manager for Eve
CTExceptionHandler	Exception handler for Eve exceptions
CTRedrawDisabler
CTEveMCRecCrossRef
CTEveMCTrack
CTEventIter
CTEventIterObj
►CTEventIterTree
CTFileTree
CTEventIterUnit
CTEventList	A TEventList object is a list of selected events (entries) in a TTree
CTEvePad	This was intended as a TPad wrapper to allow smart updates of groups of pads
CTEvePadHolder	Exception safe wrapper for setting gPad
►CTEveParamList	Collection of named parameters
CBoolConfig_t
CFloatConfig_t
CIntConfig_t
CTEveParamListEditor	GUI editor for TEveParamList
CTEvePathMarkT	Special-point on track:
CTEvePlot3D	Description of TEvePlot3D
CTEvePlot3DGL	OpenGL renderer class for TEvePlot3D
CTEvePointSelector	TEvePointSelector is a sub-class of TSelectorDraw for direct extraction of point-like data from a Tree
CTEvePointSelectorConsumer	TEvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the TEvePointSelector class
CTEvePointSet	TEvePointSet is a render-element holding a collection of 3D points with optional per-point TRef and an arbitrary number of integer ids (to be used for signal, volume-id, track-id, etc)
CTEvePointSetArray	An array of point-sets with each point-set playing a role of a bin in a histogram
CTEvePointSetArrayEditor	Editor for TEvePointSetArray class
CTEvePointSetProjected	Projected copy of a TEvePointSet
►CTEvePolygonSetProjected	A set of projected polygons
CPolygon_t
►CTEvePolygonSetProjectedGL	GL-renderer for TEvePolygonSetProjected class
CEdge_t
CTEveProjectable	Abstract base-class for non-linear projectable objects
CTEveProjected	Abstract base class for classes that hold results of a non-linear projection transformation
►CTEveProjection	Base-class for non-linear projections
CPreScaleEntry_t
CTEveProjectionAxes	Axes for non-linear projections
CTEveProjectionAxesEditor	GUI editor for TEveProjectionAxes
CTEveProjectionAxesGL	OpenGL renderer class for TEveProjectionAxes
CTEveProjectionManager	Manager class for steering of projections and managing projected objects
CTEveProjectionManagerEditor	GUI editor for TEveProjectionManager class
►CTEveQuadSet	Supports various internal formats that result in rendering of a set of planar (lines, rectangles, hexagons with shared normal) objects
CQFreeQuad_t
CQHex_t
CQLineFixC_t
CQOrigin_t
CQRect_t
CQRectFixC_t
CQRectFixDim_t
CQRectFixDimC_t
CTEveQuadSetGL	GL-renderer for TEveQuadSet class
CTEveRecCascade
CTEveRecKink
CTEveRecTrackT
CTEveRecV0
CTEveRefBackPtr	Base-class for reference-counted objects with reverse references to TEveElement objects
CTEveRefCnt	Base-class for reference-counted objects
CTEveRGBAPalette	A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes
CTEveRGBAPaletteEditor	Editor for TEveRGBAPalette class
CTEveRGBAPaletteOverlay	Description of TEveRGBAPaletteOverlay
CTEveRGBAPaletteSubEditor	Sub-editor for TEveRGBAPalette class
CTEveRhoZProjection	Transformation from 3D to 2D
CTEveRPhiProjection	XY projection with distortion around given center
CTEveScalableStraightLineSet	Straight-line-set with extra scaling, useful for projectables that need to be scaled in accordance with an external object
CTEveScene	Eve representation of TGLScene
CTEveSceneInfo	TEveUtil representation of TGLSceneInfo
CTEveSceneList	List of Scenes providing common operations on TEveScene collections
CTEveSecondarySelectable	Semi-abstract interface for classes supporting secondary-selection
CTEveSelection	Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight)
CTEveSelectorToEventList	TSelector that stores entry numbers of matching TTree entries into an event-list
CTEveShape	Abstract base-class for 2D/3D shapes
CTEveShapeEditor	GUI editor for TEveShape
►CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CLine_t
CMarker_t
CTEveStraightLineSetEditor	Editor for TEveStraightLineSet class
CTEveStraightLineSetGL	GL-renderer for TEveStraightLineSet class
CTEveStraightLineSetProjected	Projected replica of a TEveStraightLineSet
CTEveText	TEveElement class used for displaying FreeType GL fonts
CTEveTextEditor	GUI editor for TEveText
CTEveTextGL	OpenGL renderer class for TEveText
CTEveTrack	Visual representation of a track
CTEveTrackEditor	Editor for TEveTrack class
CTEveTrackGL	GL-renderer for TEveTrack class
CTEveTrackList	A list of tracks supporting change of common attributes and selection based on track parameters
CTEveTrackListEditor	Editor for TEveTrackList class
CTEveTrackListProjected	Specialization of TEveTrackList for holding TEveTrackProjected objects
CTEveTrackProjected	Projected copy of a TEveTrack
CTEveTrackProjectedGL	GL-renderer for TEveTrackProjected class
►CTEveTrackPropagator	Holding structure for a number of track rendering parameters
CHelix_t
CTEveTrackPropagatorEditor	GUI editor for TEveTrackPropagator
CTEveTrackPropagatorSubEditor	Sub-editor for TEveTrackPropagator class
CTEveTrans	TEveTrans is a 4x4 transformation matrix for homogeneous coordinates stored internally in a column-major order to allow direct usage by GL
CTEveTransEditor	Editor for TEveTrans class
CTEveTransSubEditor	Sub-editor for TEveTrans class
CTEveTriangleSet	Made from a list of vertices and a list of triangles (triplets of vertex indices)
CTEveTriangleSetEditor	Editor for TEveTriangleSet class
CTEveTriangleSetGL	GL-renderer for TEveTriangleSet class
CTEveUtil	Standard utility functions for Eve
CTEveVector2T	Minimal, templated two-vector
CTEveVector4T	Minimal, templated four-vector
CTEveVectorT	Minimal, templated three-vector
CTEveViewer	Eve representation of TGLViewer
CTEveViewerList	List of Viewers providing common operations on TEveViewer collections
CTEveViewerListEditor	GUI editor for TEveViewerList
CTEveVSD	Visualization Summary Data - a collection of trees holding standard event data in experiment independent format
CTEveWindow	Abstract base-class for representing eve-windows
CTEveWindowEditor	GUI editor for TEveWindow
CTEveWindowFrame	Encapsulates TGFrame into an eve-window
CTEveWindowManager	Manager for EVE windows
CTEveWindowPack	Encapsulates TGPack into an eve-window
CTEveWindowSlot	Description of TEveWindowSlot
CTEveWindowTab	Encapsulates TGTab into an eve-window
CTExec	TExec is a utility class that can be used to execute a C++ command when some event happens in a pad
►CTExMap	This class stores a (key,value) pair using an external hash
CAssoc_t
CTExMapIter
CTF1	1-Dim function class
CTF12	A projection of a TF2 along X or Y
CTF1Convolution	Class wrapping convolution of two functions
CTF1Editor
CTF1NormSum	Class adding two functions: c1*f1+c2*f2
CTF1Parameters	TF1 Parameters class
CTF2	A 2-Dim function with parameters
CTF2GL	GL renderer for TF2
CTF3	A 3-Dim function with parameters
CTFastCgi
CTFeldmanCousins
CTFFTComplex
CTFFTComplexReal
CTFFTReal
CTFFTRealComplex
CTFile	A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format
CTFileCacheRead	A cache when reading files over the network
CTFileCacheWrite	A cache when writing files over the network
CTFileCollection	Class that contains a list of TFileInfo's and accumulated meta data information about its entries
CTFileDrawMap	This class is automatically called by TFile::DrawMap
CTFileHandler
CTFileInfo	Class describing a generic file including meta information
CTFileInfoMeta
CTFileIter
CTFileMergeInfo
CTFileMerger	This class provides file copy and merging services
CTFileOpenHandle	Class holding info about the file being opened
CTFilePrefetch	The prefetching mechanism uses two classes (TFilePrefetch and TFPBlock) to prefetch in advance a block of tree entries
CTFileSet
CTFileStager
►CTFitEditor
CFuncParamData_t	TF1Convolution object
CTFitParametersDialog
CTFitResult	Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O
CTFitResultPtr	Provides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointer, i.e
►CTFITSHDU	FITS file interface class
CCell
CColumn
CHDURecord
CTFitter
CTFoam
CTFoamCell
CTFoamIntegrand
CTFoamMaxwt
CTFoamSampler	TFoamSampler class class implementing the ROOT::Math::DistSampler interface using FOAM for sampling arbitrary distributions
CTFoamVect
CTFolder	A TFolder object is a collection of objects and folders
►CTFormLeafInfo	This class is a small helper class to implement reading a data member on an object stored in a TTree
CGetValueHelper
CGetValueHelper< Long64_t >
CGetValueHelper< LongDouble_t >
CGetValueHelper< ULong64_t >
CReadValueHelper
CReadValueHelper< Long64_t >
CReadValueHelper< LongDouble_t >
CReadValueHelper< ULong64_t >
CTFormLeafInfoCast	A small helper class to implement casting an object to a different type (equivalent to dynamic_cast)
CTFormLeafInfoClones	A small helper class to implement reading a data member on a TClonesArray object stored in a TTree
CTFormLeafInfoCollection	A small helper class to implement reading a data member on a generic collection object stored in a TTree
CTFormLeafInfoCollectionObject	A small helper class to implement reading a data member on a TClonesArray object stored in a TTree
CTFormLeafInfoCollectionSize	Used to return the size of a collection
CTFormLeafInfoDirect	A small helper class to implement reading a data member on an object stored in a TTree
CTFormLeafInfoMethod	Asmall helper class to implement executing a method of an object stored in a TTree
CTFormLeafInfoMultiVarDim	A helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoMultiVarDimClones	A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoMultiVarDimCollection	A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoMultiVarDimDirect	A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoNumerical	A small helper class to implement reading a numerical value inside a collection
CTFormLeafInfoPointer	A small helper class to implement reading a data member by following a pointer inside a branch of TTree
CTFormLeafInfoReference	A small helper class to implement the following of reference objects stored in a TTree
CTFormLeafInfoTTree	A small helper class to implement reading from the containing TTree object itself
CTFormula	The F O R M U L A class
CTFormulaFunction	Helper class for TFormula
CTFormulaParamOrder	Functor defining the parameter order
CTFormulaVariable	Another helper class for TFormula
CTFPBlock	This class represents the encapsulation of a block request
CTFractionFitter	Fits MC fractions to data histogram
CTFrame	Define a Frame
CTFrameEditor
CTFree	Service class for TFile
CTFriendElement	A TFriendElement TF describes a TTree object TF in a file
CTFTP
CTFUMILI
CTFumili
CTFumiliMinimizer	TFumiliMinimizer class: minimizer implementation based on TFumili
CTFunction	Global functions class (global functions are obtained from CINT)
CTFunctionParametersDialog
CTFunctionTemplate	Dictionary for function template This class describes one single function template
CTG16ColorSelector
CTGApplication
CTGaxis	The axis painter class
CTGButton
CTGButtonGroup
CTGCanvas
CTGCheckButton
CTGClient
CTGCocoa	This class implements TVirtualX interface for MacOS X, using Cocoa and Quartz 2D
CTGColorDialog
CTGColorFrame
CTGColorPalette
CTGColorPick
CTGColorPopup
CTGColorSelect
CTGColumnLayout
CTGComboBox
CTGComboBoxPopup
CTGCommandPlugin
CTGCompositeFrame
CTGContainer
CTGDimension
CTGDMAssignmentHelper
CTGDMLBaseTGDMMapHelper
CTGDMLParse
CTGDMLRefl
►CTGDMLWrite
CNameLst
CStructLst
CXyz
CTGDMMapHelper
CTGDNDManager
CTGDockableFrame
CTGDockButton
CTGDockHideButton
CTGDoubleHSlider
CTGDoubleSlider
CTGDoubleVSlider
CTGDragWindow
CTGedEditor
►CTGedFrame
CTGedSubFrame
CTGedMarkerPopup
CTGedMarkerSelect
CTGedNameFrame
CTGedPatternFrame
CTGedPatternPopup
CTGedPatternSelect
CTGedPatternSelector
CTGedPopup
CTGedSelect
►CTGenCollectionProxy	Proxy around an arbitrary container, which implements basic functionality and iteration
CMethod	Small helper to execute (compiler) generated function for the access to STL or other containers
CMethod0
CStreamHelper	Helper class to facilitate I/O
CTStaging	Small helper to stage the content of an associative container when reading and before inserting it in the actual collection
CValue	Small helper to describe the Value_type or the key_type of an STL container
CTGenCollectionStreamer
CTGenerator
►CTGenericCollectionIterator
CRegularIterator
CVectorIterator
►CTGenericTable
Citerator
CTGenPhaseSpace
CTGeoArb8
CTGeoAtt
►CTGeoBatemanSol
CBtCoef_t
CTGeoBBox
CTGeoBBoxEditor
►CTGeoBoolNode
CThreadData_t
CTGeoBranchArray
CTGeoBuilder
CTGeoCacheState
CTGeoChecker
CTGeoCombiTrans
CTGeoCombiTransEditor
CTGeoCompositeShape
CTGeoCone
CTGeoConeEditor
CTGeoConeSeg
CTGeoConeSegEditor
CTGeoCtub
CTGeoCtubEditor
CTGeoDecayChannel
CTGeoElement
CTGeoElementRN
CTGeoElementTable
CTGeoElemIter
CTGeoEltu
CTGeoEltuEditor
CTGeoExtension
CTGeoGedFrame
CTGeoGenTrans
CTGeoGlobalMagField
CTGeoGtra
CTGeoGtraEditor
CTGeoHalfSpace
CTGeoHelix
CTGeoHMatrix
CTGeoHype
CTGeoHypeEditor
CTGeoIdentity
CTGeoIntersection
CTGeoIsotope
CTGeoIterator
CTGeoIteratorPlugin
CTGeoManager
CTGeoManagerEditor
CTGeoMaterial
CTGeoMaterialDialog
CTGeoMaterialEditor
CTGeoMatrix
CTGeoMatrixDialog
CTGeoMCGeometry
CTGeoMedium
CTGeoMediumDialog
CTGeoMediumEditor
CTGeometry	TGeometry description
CTGeoMixture
CTGeoMixtureEditor
CTGeoNavigator
CTGeoNavigatorArray
CTGeoNode
CTGeoNodeCache
CTGeoNodeEditor
CTGeoNodeMatrix
CTGeoNodeOffset
CTGeoOverlap
CTGeoPainter
CTGeoPara
CTGeoParaboloid
CTGeoParaEditor
CTGeoParallelWorld
CTGeoPatternCylPhi
CTGeoPatternCylR
►CTGeoPatternFinder
CThreadData_t
CTGeoPatternHoneycomb
CTGeoPatternParaX
CTGeoPatternParaY
CTGeoPatternParaZ
CTGeoPatternSphPhi
CTGeoPatternSphR
CTGeoPatternSphTheta
CTGeoPatternTrapZ
CTGeoPatternX
CTGeoPatternY
CTGeoPatternZ
CTGeoPcon
CTGeoPconEditor
CTGeoPconSection
►CTGeoPgon
CThreadData_t
CTGeoPgonEditor
CTGeoPhysicalNode
CTGeoPNEntry
CTGeoPolygon
CTGeoRCExtension
CTGeoRCPtr
CTGeoRotation
CTGeoRotationEditor
CTGeoScale
CTGeoScaledShape
CTGeoShape
CTGeoShapeAssembly
CTGeoShapeDialog
CTGeoSphere
CTGeoSphereEditor
CTGeoStateInfo
CTGeoSubtraction
CTGeoTabManager
CTGeoToOCC
CTGeoTorus
CTGeoTorusEditor
CTGeoToStep
CTGeoTrack
CTGeoTransientPanel
CTGeoTranslation
CTGeoTranslationEditor
CTGeoTrap
CTGeoTrapEditor
CTGeoTrd1
CTGeoTrd1Editor
CTGeoTrd2
CTGeoTrd2Editor
CTGeoTreeDialog
CTGeoTube
CTGeoTubeEditor
CTGeoTubeSeg
CTGeoTubeSegEditor
CTGeoUniformMagField
CTGeoUnion
CTGeoVolume
►CTGeoVolumeAssembly
CThreadData_t
CTGeoVolumeDialog
CTGeoVolumeEditor
CTGeoVolumeMulti
CTGeoVoxelFinder
►CTGeoXtru
CThreadData_t
CTGEventHandler
CTGFALFile	Read and write data via the underlying Grid access mechanism
CTGFALSystem	Directory handler for GFAL
CTGFileBrowser
CTGFileContainer
CTGFileDialog
CTGFileInfo
CTGFileItem
CTGFont
►CTGFontDialog
CFontProp_t
CTGFontPool
CTGFontTypeComboBox
CTGFrame
CTGFrameElement
CTGFrameElementPack
CTGFSComboBox
CTGGC
CTGGCPool
CTGGotoDialog
CTGGroupFrame
CTGHButtonGroup
CTGHeaderFrame
CTGHorizontal3DLine
CTGHorizontalFrame
CTGHorizontalLayout
CTGHotString
CTGHProgressBar
CTGHScrollBar
CTGHSlider
CTGHSplitter
CTGHtml
CTGHtmlAnchor
CTGHtmlBlock
CTGHtmlBrowser
CTGHtmlCell
CTGHtmlElement
CTGHtmlForm
CTGHtmlHr
CTGHtmlImage
CTGHtmlImageMarkup
CTGHtmlInput
CTGHtmlLayoutContext
CTGHtmlLi
CTGHtmlListStart
CTGHtmlMapArea
CTGHtmlMarkupElement
CTGHtmlRef
CTGHtmlScript
CTGHtmlSpaceElement
CTGHtmlTable
CTGHtmlTextElement
CTGHtmlUri
CTGIcon
CTGIconLBEntry
CTGIdleHandler
CTGImageMap
CTGInputDialog
CTGInsets
CTGItemContext	Empty object used as context menu support for TGLVTreeEntries
CTGL2DArray
CTGL5DDataSet
CTGL5DDataSetEditor	GUI editor for OpenGL 5D Painter
►CTGL5DPainter	TGL5DPainter implements "gl5d" option for TTree::Draw
CSurf_t
CTGLabel
CTGLAdapter	Allow plot-painters to be used for gl-inpad and gl-viewer
CTGLAnnotation	GL-overlay annotation
CTGLAutoRotator	Automatically rotates GL camera
CTGLAxis	GL Axis
CTGLAxisPainter
CTGLAxisPainterBox	Utility class to paint axis in GL
CTGLayoutHints
CTGLayoutManager
CTGLBContainer
CTGLBEntry
CTGLBoundingBox	Concrete class describing an orientated (free) or axis aligned box of 8 vertices
CTGLBoxCut	Used by plot-painters to determine the area of the plot that is cut away
CTGLBoxPainter	Paints TH3 histograms by rendering variable-sized boxes matching the bin contents
CTGLCamera	Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it
CTGLCameraGuide	Draws arrows showing camera orientation in the overlay
CTGLCameraOverlay	A GL overlay element which displays camera furstum
CTGLCapabilityEnabler
CTGLCapabilitySwitch
CTGLClip	Abstract clipping shape - derives from TGLPhysicalShape Adds clip mode (inside/outside) and pure virtual method to approximate shape as set of planes
CTGLClipBox	Concrete clip box object
CTGLClipPlane	Concrete clip plane object
CTGLClipSet	A collection of concrete TGLClip objects to be selected from
CTGLClipSetEditor	GUI editor for TGLClipSet
CTGLClipSetSubEditor	GUI sub-editor for TGLClipSet
CTGLColor	Class encapsulating color information in preferred GL format - an array of four unsigned bytes
CTGLColorSet	Class encapsulating a set of colors used throughout standard rendering
CTGLContext	This class encapsulates window-system specific information about a GL-context and alows their proper management in ROOT
CTGLContextIdentity	Identifier of a shared GL-context
CTGLContextPrivate
CTGLCylinder	Implements a native ROOT-GL cylinder that can be rendered at different levels of detail
CTGLDisableGuard
CTGLEmbeddedViewer	Minimal GL-viewer that can be embedded in a standard ROOT frames
CTGLEnableGuard
CTGLEventHandler	Base-class and default implementation of event-handler for TGLViewer
CTGLFaceSet	Implements a native ROOT-GL representation of an arbitrary set of polygons
CTGLFaderHelper
CTGLFBO	Frame-buffer object
CTGLFloatHolder
CTGLFont	A wrapper class for FTFont
CTGLFontManager	A FreeType GL font manager
CTGLFormat	Encapsulation of format / contents of an OpenGL buffer
CTGLH2PolyPainter	Paint TH2Poly
CTGLHistPainter	The histogram painter class using OpenGL
CTGLineLBEntry
CTGLineStyleComboBox
CTGLineWidthComboBox
CTGLIsoPainter	"gliso" option for TH3
CTGListBox
CTGListDetailsLayout
CTGListLayout
CTGListTree
CTGListTreeItem
CTGListTreeItemStd
CTGListView
CTGLite
CTGLiteJob
CTGLiteJobStatus
CTGLiteResult
CTGLLegoPainter	Plot-painter implementing LEGO rendering of TH2 histograms in cartesian, polar, cylindrical and spherical coordinates
CTGLLevelPalette
CTGLLightSet	Encapsulates a set of lights for OpenGL
CTGLLightSetEditor
CTGLLightSetSubEditor	Sub-editor for TGLLightSet
CTGLLine3	3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'
►CTGLLockable	Simple locking interface used by viewer and scene
CTUnlocker
CTGLLogicalShape	Abstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc
CTGLManager
CTGLManip	Abstract base class for viewer manipulators, which allow direct in viewer manipulation of a (TGlPhysicalShape) object - currently translation, scaling and rotation along/round objects local axes
CTGLManipSet	Combine all available manipulators in a collection
CTGLMatrix	16 component (4x4) transform matrix - column MAJOR as per GL
CTGlobal	Global variables class (global variables are obtained from CINT)
CTGlobalMappedFunction
CTGLObject	Base-class for direct OpenGL renderers
CTGLongPosition
CTGLOrthoCamera	Orthographic projection camera
CTGLOutput	Wrapper class for GL capture & output routines
CTGLOverlayButton	GL-overlay button
CTGLOverlayElement	An overlay element
CTGLOverlayList	Manage a collection of overlay elements
CTGLOvlSelectRecord	Selection record for overlay objects
CTGLPadPainter	"Delegating" part of TGLPadPainter
CTGLPaintDevice
CTGLParametricEquation	A parametric surface is a surface defined by a parametric equation, involving two parameters (u, v):
CTGLParametricEquationGL	GL-renderer wrapper for TGLParametricEquation
►CTGLParametricPlot
CVertex_t
CTGLPerspectiveCamera	Perspective projection camera - with characteristic foreshortening
CTGLPhysicalShape	Concrete physical shape - a GL drawable
CTGLPlane	3D plane class - of format Ax + By + Cz + D = 0
CTGLPlot3D	Description of TGLPlot3D
CTGLPlotBox	Implementation of a box around a histogram/function for plot-painters
CTGLPlotCamera	Camera for TGLPlotPainter and sub-classes
CTGLPlotCoordinates	Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if certain axis is logarithmic
CTGLPlotPainter	Base class for plot-painters that provide GL rendering of various 2D and 3D histograms, functions and parametric surfaces
CTGLPolyLine	To draw a 3D polyline in a GL window
CTGLPolyMarker
CTGLPShapeObj	Wrap TGLPysicalShape into TObject so that it can be edited using GED
CTGLPShapeObjEditor	GUI editor for TGLPShapeObj
CTGLPShapeRef	Base class for references to TGLPysicalShape that need to be notified when the shape is destroyed
CTGLQuadric	Wrapper class for GLU quadric shape drawing object
CTGLRect	Viewport (pixel base) 2D rectangle class
CTGLRedrawTimer
CTGLRnrCtx	Aggregates data for a given redering context as needed by various parts of the ROOT's OpenGL infrastructure
CTGLRotateManip	Rotate manipulator - attaches to physical shape and draws local axes widgets - rings drawn from attached physical center, in plane defined by axis
CTGLSAFrame	Standalone GL Viewer GUI main frame
CTGLSAViewer	The top level standalone GL-viewer - created via plugin manager
CTGLScaleManip	Scale manipulator - attaches to physical shape and draws local axes widgets with box heads
►CTGLScene	TGLScene provides management and rendering of ROOT's default 3D /object representation as logical and physical shapes
CDrawElement_t
CTSceneInfo
CTGLSceneBase	Scene base-class – provides basic interface expected by the TGLViewer or its sub-classes:
CTGLSceneInfo	Base class for extended scene context
CTGLScenePad	Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents
CTGLSelectBuffer	Encapsulates OpenGL select buffer
CTGLSelectionBuffer
CTGLSelectRecord	Standard selection record including information about containing scene and details ob out selected object (TGLPhysicalShape*, TObject* or simply a void* for foreign scenes)
CTGLSelectRecordBase
CTGLSphere	Implements a native ROOT-GL sphere that can be rendered at different levels of detail
CTGLStopwatch	Stopwatch object for timing GL work
►CTGLSurfacePainter	Implements painting of TH2 with "SURF" option
CProjection_t
CTGLText	GL Text
CTGLTF3Painter	Plot-painter for TF3 functions
CTGLTH3Composition
CTGLTH3CompositionPainter
CTGLTH3Slice	A slice of a TH3
CTGLTransManip	Translation manipulator - attaches to physical shape and draws local axes widgets with arrow heads
►CTGLUtil	Wrapper class for various misc static functions - error checking, draw helpers etc
CTColorLocker
CTDrawQualityModifier
CTDrawQualityScaler
CTGLVContainer
CTGLVector3	3 component (x/y/z) vector class
CTGLVEntry
CTGLVertex3	3 component (x/y/z) vertex class
CTGLViewer	Base GL viewer object - used by both standalone and embedded (in pad) GL
CTGLViewerBase	Base class for GL viewers
CTGLViewerEditor	GUI editor for TGLViewer
CTGLVoxelPainter
CTGLWidget	GL window with context
►CTGMainFrame
CTGMapKey
CTGMatrixLayout
CTGMdiButtons
CTGMdiContainer
CTGMdiCornerWinResizer
CTGMdiDecorFrame
CTGMdiFrame
CTGMdiFrameList
CTGMdiGeometry
CTGMdiHorizontalWinResizer
CTGMdiMainFrame
CTGMdiMenuBar
CTGMdiTitleBar
CTGMdiTitleIcon
CTGMdiVerticalWinResizer
CTGMdiWinResizer
CTGMenuBar
CTGMenuEntry
CTGMenuTitle
CTGMime
CTGMimeTypes
CTGMsgBox
CTGNumberEntry
CTGNumberEntryField
CTGNumberEntryLayout
CTGNumberFormat
CTGObject
CTGondzioSolver
CTGOSXGLManager
CTGPack
CTGPasswdDialog
CTGPicture
CTGPictureButton
CTGPicturePool
CTGPopupMenu
CTGPosition
CTGPrintDialog
CTGProgressBar
CTGQuartz	This is non-GUI part of TVirtualX interface, implemented for MacOS X, using CoreGraphics (Quartz)
CTGRadioButton
CTGraph	A Graph is a graphics object made of two arrays X and Y with npoints each
CTGraph2D	Graphics object made of three arrays X, Y and Z with the same number of points each
CTGraph2DErrors	Graph 2D class with errors
CTGraph2DPainter	The TGraphDelaunay painting class
CTGraphAsymmErrors	TGraph with assymetric error bars
CTGraphBentErrors	A TGraphBentErrors is a TGraph with bent, assymetric error bars
CTGraphDelaunay	TGraphDelaunay generates a Delaunay triangulation of a TGraph2D
CTGraphDelaunay2D
CTGraphEdge	An edge object connecting two nodes which can be added in a TGraphStruct
CTGraphEditor
CTGraphErrors	A TGraphErrors is a TGraph with error bars
CTGraphNode	A graph node object which can be added in a TGraphStruct
CTGraphPainter	The graph painter class
CTGraphPolar	To draw a polar graph
CTGraphPolargram	To draw polar axis
CTGraphQQ	This class allows to draw quantile-quantile plots
CTGraphSmooth	A helper class to smooth TGraph
CTGraphStruct	The Graph Structure is an interface to the graphviz package
CTGraphTime	TGraphTime is used to draw a set of objects evolving with nsteps in time between tmin and tmax
CTGRecorder
CTGRectangle
CTGRectMap
CTGRedirectOutputGuard
CTGRegion
CTGRegionWithId
CTGResourcePool
CTGrid
CTGridCollection
CTGridJDL
CTGridJob
CTGridJobStatus
CTGridJobStatusList
CTGridResult
CTGroupButton	A specialized TButton used in a group of Buttons
CTGRowLayout
CTGScrollBar
CTGScrollBarElement
CTGSearchDialog
CTGSearchType
CTGSelectBox	This class represent a specialized expression editor for TTVLVEntry 'true name' and 'alias' data members
CTGSelectedPicture
CTGShapedFrame
CTGShutter
CTGShutterItem
CTGSimpleTable
CTGSimpleTableInterface
CTGSlider
CTGSpeedo
CTGSplitButton
CTGSplitFrame
CTGSplitter
CTGSplitTool
CTGStatusBar
CTGString
CTGTab
CTGTabElement
CTGTabLayout
CTGTable
CTGTableCell
CTGTableFrame
CTGTableHeader
CTGTableHeaderFrame
►CTGTableLayout
CTableData_t
CTGTableLayoutHints
CTGText
CTGTextBuffer
CTGTextButton
CTGTextEdit
CTGTextEditor
CTGTextEntry
CTGTextLayout
CTGTextLBEntry
CTGTextLine
CTGTextView
CTGTextViewostream
CTGTextViewStreamBuf
CTGTileLayout
CTGToolBar
CTGToolTip
CTGTRA	A general twisted trapezoid
CTGTransientFrame
CTGTreeLBEntry
CTGTreeTable	TGTreeTable is a TGTable that owns it's own interface
CTGTripleHSlider
CTGTripleVSlider
CTGuiBldAction
CTGuiBldDragManager
CTGuiBldEditor
CTGuiBldGeometryFrame
CTGuiBldHintsButton
CTGuiBldHintsEditor
CTGuiBldNameFrame
CTGuiBuilder
CTGuiFactory	This ABC is a factory for GUI components
CTGUndockedFrame
CTGUnknownWindowHandler
CTGVButtonGroup
CTGVertical3DLine
CTGVerticalFrame
CTGVerticalLayout
CTGVFileSplitter
CTGView
CTGViewFrame
CTGViewPort
CTGVProgressBar
CTGVScrollBar
CTGVSlider
CTGVSplitter
CTGWidget
CTGWin32	This class is the basic interface to the Win32 graphics system
CTGWin32GLManager
CTGWin32GLManagerProxy
CTGWin32ProxyBase
CTGWin32VirtualXProxy
CTGWindow
CTGX11	This class is the basic interface to the X11 (Xlib) graphics system
CTGX11TTF	Interface to low level X11 (Xlib)
CTGXYLayout
CTGXYLayoutHints
CTH1	The TH1 histogram class
CTH1C	1-D histogram with a bype per channel (see TH1 documentation)
CTH1D	1-D histogram with a double per channel (see TH1 documentation)}
CTH1Editor
CTH1F	1-D histogram with a float per channel (see TH1 documentation)}
CTH1I	1-D histogram with a int per channel (see TH1 documentation)}
CTH1K	TH1K class supports the nearest K Neighbours method, widely used in cluster analysis
CTH1S	1-D histogram with a short per channel (see TH1 documentation)
CTH2	Service class for 2-Dim histogram classes
CTH2C	2-D histogram with a bype per channel (see TH1 documentation)
CTH2D	2-D histogram with a double per channel (see TH1 documentation)}
CTH2Editor
CTH2F	2-D histogram with a float per channel (see TH1 documentation)}
CTH2GL	Rendering of TH2 and derived classes
CTH2I	2-D histogram with a int per channel (see TH1 documentation)}
CTH2Poly	2D Histogram with Polygonal Bins
CTH2PolyBin	Helper class to represent a bin in the TH2Poly histogram
CTH2S	2-D histogram with a short per channel (see TH1 documentation)
CTH3	The 3-D histogram classes derived from the 1-D histogram classes
CTH3C	3-D histogram with a bype per channel (see TH1 documentation)
CTH3D	3-D histogram with a double per channel (see TH1 documentation)}
CTH3F	3-D histogram with a float per channel (see TH1 documentation)}
CTH3GL	OpenGL renderer class for TH3
CTH3I	3-D histogram with a int per channel (see TH1 documentation)}
CTH3S	3-D histogram with a short per channel (see TH1 documentation)
CTHaarMatrixT
CTHashList	THashList implements a hybrid collection class consisting of a hash table and a list to store TObject's
CTHashTable	THashTable implements a hash table to store TObject's
CTHashTableIter	Iterator of hash table
CTHbookBranch	HBOOK Branch
CTHbookFile	This class is an interface to the Hbook objects in Hbook files
CTHbookKey	HBOOK Key
CTHbookTree	A wrapper class supporting Hbook ntuples (CWN and RWN)
CTHDFSFile	Reads and writes its data via the HDFS protocols
CTHDFSSystem	Directory handler for HDFS (THDFSFile)
CTHelix	THelix has two different constructors
CTHilbertMatrixT
CTHilbertMatrixTSym
CTHistPainter	The histogram painter class
CTHLimitsFinder	Class to find nice axis limits
CTHn	Multidimensional histogram
CTHnBase	Multidimensional histogram base
CTHnIter	Iterator over THnBase bins
CTHnSparse	Efficient multidimensional histogram
CTHnSparseArrayChunk	THnSparseArrayChunk is used internally by THnSparse
CTHnSparseT	Templated implementation of the abstract base THnSparse
CTHnT	Templated implementation of the abstract base THn
CTHostAuth
CTHStack	The Histogram stack class
►CTHtml
CDocEntityInfo_t
CDocSyntax_t
CLinkInfo_t
COutputStyle_t
CPathInfo_t
CTFileDefinition
CTFileSysDB
CTFileSysDir
CTFileSysEntry
CTFileSysRoot
CTHelperBase
CTModuleDefinition
CTPathDefinition
CTHttpCallArg
CTHttpEngine
CTHttpServer
CTHYPE	An hyperboloid (not implemented)
CTIdleTOTimer
CTIdleTOTimerGuard
CTileFrame
CTImage	An abstract interface to image processing library
CTImageDump	Save canvas as an image (GIF, JPEG, PNG, XPM, TIFF etc.)
CTImagePalette	A class to define a conversion from pixel values to pixel color
CTImagePlugin
►CTimeStampCounter
CData
CTIndArray
►CTIndexTable
Citerator
CTInetAddress	This class represents an Internet Protocol (IP) address
CTInspectCanvas	Pointer to class of the foreign object
CTInspectorImp	ABC describing GUI independent object inspector (abstraction mainly needed for Win32
CTInstrumentedIsAProxy
►CTInterpreter	This class defines an abstract interface to a generic command line interpreter
CCallFuncIFacePtr_t
CSuspendAutoParsing
CTInterpreterValue
CTIsAProxy	TIsAProxy implementation class
CTIter
CTIterator	Iterator abstract base class
CTIterCategory
CTKDE	Kernel Density Estimation class
CTKDEFGT
CTKDTree	Kd-tree
CTKDTreeBinning	<- TKDTreeBinning - A class providing multidimensional binning ->
CTKey	Book space in a file, create I/O buffers, to fill them, (un)compress them
CTKeyMapFile	Utility class for browsing TMapFile objects
CTKeySQL	TKeySQL represents metainforamtion about object, which was written to SQL database
CTKeyXML
►CTKSocket
CDesc_t
►CTLatex	To draw Mathematical Formula
CFormSize_t	TLatex helper struct holding the dimensions of a piece of text
CTextSpec_t	TLatex helper struct holding the attributes of a piece of text
CTLatexFormSize	TLatex helper class used to compute the size of a portion of a formula
CTLDAPAttribute
CTLDAPEntry
CTLDAPResult
CTLDAPServer
►CTLeaf	A TLeaf describes individual elements of a TBranch See TBranch structure in TTree
CGetValueHelper
CGetValueHelper< Long64_t >
CGetValueHelper< LongDouble_t >
CGetValueHelper< ULong64_t >
CTLeafB	A TLeaf for an 8 bit Integer data type
CTLeafC	A TLeaf for a variable length string
CTLeafD	A TLeaf for a 64 bit floating point data type
CTLeafElement	A TLeaf for the general case when using the branches created via a TStreamerInfo (i.e
CTLeafF	A TLeaf for a 32 bit floating point data type
CTLeafI	A TLeaf for an Integer data type
CTLeafL	A TLeaf for a 64 bit Integer data type
CTLeafO	A TLeaf for a bool data type
CTLeafObject	A TLeaf for a general object derived from TObject
CTLeafS	A TLeaf for a 16 bit Integer data type
CTLegend	This class displays a legend box (TPaveText) containing several legend entries
CTLegendEntry	Storage class for one entry of a TLegend
CTLibraryDocInfo
CTLimit	Algorithm to compute 95% C.L
CTLimitDataSource	This class serves as interface to feed data into the TLimit routines
CTLine	A simple line
CTLinearFitter	The Linear Fitter - For fitting functions that are LINEAR IN PARAMETERS
CTLinearGradient	Define a linear color gradient
CTLinearMinimizer	TLinearMinimizer class: minimizer implementation based on TMinuit
CTLineEditor
CTLink	Special TText object used to show hyperlinks
CTList	A doubly linked list
CTListIter	Iterator of linked list
CTListOfDataMembers	A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of TDataMember that were described unloaded data member
CTListOfEnums	A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum
CTListOfEnumsWithLock	A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum
CTListOfEnumsWithLockIter	Iterator for TListOfEnumsWithLock
CTListOfFunctions	A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function
CTListOfFunctionsIter	Iterator for TListOfFunctions
CTListOfFunctionTemplates	A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function
CTListOfTypes	A collection of TDataType designed to hold the typedef information and numerical type information
CTLockFile	A scoped lock based on files
CTLockGuard
►CTLorentzRotation
CTLorentzRotationRow
CTLorentzVector
CTMacOSXSystem
CTMacro	Class supporting a collection of lines with C++ code
CTMakeProject
CTMap	TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval (therefore TMap does not conserve the order of the entries)
CTMapFile	This class implements a shared memory region mapped to a file
CTMapIter	Iterator of map
CTMapRec	Keep track of an object in the mapped file
CTMarker	Manages Markers
CTMarker3DBox	A special 3-D marker designed for event display
CTMaterial	Manages a detector material
CTMathText	To draw TeX Mathematical Formula
CTMatrixDEigen
CTMatrixDSymEigen
CTMatrixT
CTMatrixTBase
CTMatrixTColumn
CTMatrixTColumn_const
CTMatrixTDiag
CTMatrixTDiag_const
CTMatrixTFlat
CTMatrixTFlat_const
CTMatrixTLazy
CTMatrixTRow
CTMatrixTRow_const
CTMatrixTSparse
CTMatrixTSparseDiag
CTMatrixTSparseDiag_const
CTMatrixTSparseRow
CTMatrixTSparseRow_const
CTMatrixTSub
CTMatrixTSub_const
CTMatrixTSym
CTMatrixTSymLazy
CTMCParticle
CTMCVerbose
CTMD5	This code implements the MD5 message-digest algorithm
CTMehrotraSolver
CTMemberInspector	Abstract base class for accessing the data-members of a class
CTMemberStreamer
►CTMemFile	A TMemFile is like a normal TFile except that it reads and writes only from memory
CTMemBlock
CTMemStat
CTMemStatHook
CTMemStatShow	Utility class post-processing the file generated by TMemStat (default memstat.root)
CTMergerInfo
CTMessage
CTMessageHandler	Handle messages that might be generated by the system
CTMethod	Each ROOT class (see TClass) has a linked list of methods
CTMethodArg	Each ROOT method (see TMethod) has a linked list of its arguments
CTMethodBrowsable	This helper object allows the browsing of methods of objects stored in branches
CTMethodCall	Method or function calling interface
CTMINUIT
CTMinuit	Implementation in C++ of the Minuit package written by F
CTMinuit2TraceObject
CTMinuitMinimizer	TMinuitMinimizer class: ROOT::Math::Minimizer implementation based on TMinuit
CTMixture	Manages a detector mixture
CTMLPAnalyzer
CTModuleDocInfo
CTMonaLisaText
CTMonaLisaValue
CTMonaLisaWriter
CTMonitor
CTMPClient	Base class for multiprocess applications' clients
CTMPWorker	This class works in conjuction with TMPClient, reacting to messages received from it as specified by the Notify and HandleInput methods
CTMultiDimFit	Multidimensional Fits in ROOT
CTMultiGraph	A TMultiGraph is a collection of TGraph (or derived) objects
CTMultiLayerPerceptron
CTMutex
CTMutexImp
CTMySQLResult
CTMySQLRow
CTMySQLServer
►CTMySQLStatement
CTParamData
CTNamed	Base class for all named ROOT classes
CTNDArray
CTNDArrayRef
CTNDArrayT
CTNetFile
CTNetFileStager
CTNetSystem
CTNetXNGFile
CTNetXNGFileStager
CTNetXNGSystem
CTNeuron
CTNewChainDlg
CTNewQueryDlg
CTNode	TNode description
CTNodeDiv	Description of parameters to divide a 3-D geometry object
CTNonCopyable
CTNonSplitBrowsable	Allows a TBrowser to browse non-split branches as if they were split
CTNtuple	A simple TTree restricted to a list of float variables only
CTNtupleD	A simple TTree restricted to a list of double variables only
CTObjArray	An array of TObjects
CTObjArrayIter	Iterator of object array
CTObject	Mother of all ROOT objects
CTObjectRefSpy
CTObjectSet
CTObjectSpy	Monitors objects for deletion and reflects the deletion by reverting the internal pointer to zero
CTObjectTable	This class registers all instances of TObject and its derived classes in a hash table
CTObjLink	Wrapper around a TObject so it can be stored in a TList
CTObjOptLink
CTObjString	Collectable string class
CTOCCToStep
CTODBCResult
CTODBCRow
CTODBCServer
►CTODBCStatement
CODBCBufferRec_t
CToolBarData_t
CTOptionListItem
CTOracleResult
CTOracleRow
CTOracleServer
►CTOracleStatement
CTBufferRec
CTOrdCollection	Ordered collection
CTOrdCollectionIter	Iterator of ordered collection
CTOutputListSelectorDataMap
CTPackageDescription
CTPacketizer
CTPacketizerAdaptive
CTPacketizerFile
CTPacketizerMulti
CTPacketizerUnit
CTPad	The most important graphics class in the ROOT system
CTPadEditor
CTPadPainter	Implement TVirtualPadPainter which abstracts painting operations
CTPainter3dAlgorithms	The Legos and Surfaces painter class
CTPair	Class used by TMap to store (key,value) pairs
CTPaletteAxis	The palette painting class
CTPaletteEditor	Edit the palette via a GUI
CTPARA	A parallelepiped
CTParallelCoord	Parallel Coordinates class
CTParallelCoordEditor	This is the TParallelCoord editor
CTParallelCoordRange	A TParallelCoordRange is a range used for parallel coordinates plots
CTParallelCoordSelect	A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord
CTParallelCoordVar	TParallelCoord axes
CTParallelMergingFile
CTParameter	Named parameter, streamable and storable
CTParticle
CTParticleClassPDG
CTParticlePDG
CTPave	A TBox with a bordersize and a shadow option
CTPaveClass	A TPaveLabel specialized to process classes inside a TClassTree
CTPaveLabel	A Pave (see TPave) with a text centered in the Pave
CTPaveStats	The histogram statistics painter class
CTPaveStatsEditor
CTPavesText	A PaveText (see TPaveText) with several stacked paves
CTPaveText	A Pave (see TPave) with text, lines or/and boxes inside
CTPBHandleDSType
CTPBHistType
CTPBReadType
CTPCON	A polycone
CTPDF	Interface to PDF
CTPerfEvent
CTPerfStats
CTPGON	A polygon
CTPgSQLResult
CTPgSQLRow
CTPgSQLServer
CTPgSQLStatement
CTPickerStackGuard
CTPie	Draw a Pie Chart,
CTPieEditor
CTPieSlice	A slice of a piechart, see the TPie class
CTPieSliceEditor
CTPluginHandler
CTPluginManager	This class implements a plugin library manager
CTPMERegexp	Wrapper for PCRE library (Perl Compatible Regular Expressions)
CTPoint
CTPoints	2-D graphics point (world coordinates)
CTPoints3D
CTPoints3DABC	Abstract class to define Arrays of 3D points
CTPointsArray3D
CTPointSet3D	TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering
CTPointSet3DGL	Direct OpenGL renderer for TPointSet3D
CTPolyLine	Defined by an array on N points in a 2-D space
CTPolyLine3D	A 3-dimensional polyline
CTPolyLineShape
CTPolyMarker	A PolyMarker is defined by an array on N points in a 2-D space
CTPolyMarker3D	A 3D polymarker
CTPoolProcessor
CTPoolWorker	This class works together with TProcPool to allow the execution of functions in server processes
CTPoolWorker< F, T, void >
CTPoolWorker< F, void, R >
CTPosixCondition
CTPosixMutex
CTPosixThread
CTPosixThreadCleanUp
CTPosixThreadFactory
CTPostScript	Interface to PostScript
CTPRegexp
CTPrimary
CTPrincipal	Principal Components Analysis (PCA)
CTProcessEventTimer
CTProcessID	A TProcessID identifies a ROOT job in a unique way in time and space
CTProcessUUID	This class is a specialized TProcessID managing the list of UUIDs
CTProcPool	This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time
CTProfile	Profile Historam
CTProfile2D	Profile2D histograms are used to display the mean value of Z and its RMS for each cell in X,Y
CTProfile3D	Profile3D histograms are used to display the mean value of T and its RMS for each cell in X,Y,Z
CTProfileHelper
►CTProof
CMD5Mod_t
CTProofBench
CTProofBenchDataSet
CTProofBenchRun
CTProofBenchRunCPU
CTProofBenchRunDataRead
CTProofChain
CTProofCondor
CTProofDebug
CTProofDesc
CTProofDraw
CTProofDrawEntryList
CTProofDrawEventList
CTProofDrawGraph
CTProofDrawHist
►CTProofDrawListOfGraphs
CPoint3D_t
►CTProofDrawListOfPolyMarkers3D
CPoint4D_t
CTProofDrawPolyMarker3D
CTProofDrawProfile
CTProofDrawProfile2D
CTProofInputHandler
CTProofInterruptHandler
CTProofLimitsFinder
CTProofLite
CTProofLockPath
CTProofLockPathGuard
CTProofLog
CTProofLogElem
CTProofMergePrg
CTProofMgr
CTProofMgrLite
►CTProofMonSender
CTDSetPlet
CTProofMonSenderML
CTProofMonSenderSQL
CTProofNodeInfo
CTProofNodes
CTProofOutputFile
CTProofOutputList
CTProofPerfAnalysis
►CTProofPlayer
CTCleanup
CTProofPlayerLite
CTProofPlayerLocal
CTProofPlayerRemote
CTProofPlayerSlave
CTProofPlayerSuperMaster
CTProofProgressDialog
CTProofProgressInfo
CTProofProgressLog
CTProofProgressMemoryPlot
CTProofProgressStatus
CTProofQueryResult
CTProofResources
CTProofResourcesStatic
CTProofServ
CTProofServLite
CTProofServLogHandler
CTProofServLogHandlerGuard
CTProofSuperMaster
CTProofVectorContainer
►CTProtoClass	Persistent version of a TClass
CTProtoRealData
CTPServerSocket
CTPSocket
CTPwdCtx
CTPyArg
CTPyClassGenerator
CTPyDispatcher
CTPyMultiGenFunction
CTPyMultiGradFunction
CTPyReturn
CTPySelector
►CTPythia6
CTPythia6Cleaner
CTPythia6Decayer
CTPythia8
CTPythia8Decayer
CTPython
CTQApplication
CTQCanvasImp
CTQCanvasMenu
CTQClass
CTQCommand	The Command design pattern is based on the idea, that all editing in an application is done by creating instances of command objects
CTQConnection	TQConnection class is an internal class, used in the object communication mechanism
CTQObject	This is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html)
CTQObjSender
CTQpDataBase
CTQpDataDens
CTQpDataSparse
CTQpLinSolverBase
CTQpLinSolverDens
CTQpLinSolverSparse
CTQpProbBase
CTQpProbDens
CTQpProbSparse
CTQpResidual
CTQpSolverBase
CTQpVar
CTQRootApplication
CTQRootCanvas
CTQRootDialog
CTQRootGuiFactory
CTQtRootGuiFactory
CTQuaternion
CTQueryDescription
CTQueryResult	A container class for query results
CTQueryResultManager
CTQUndoManager	Recorder of operations for undo and redo
CTrackD
CTrackD32
CTRadialGradient	Define a radial color gradient
CTRandom	This is the base class for the ROOT Random number generators
CTRandom1	The Ranlux Random number generator class
CTRandom2	Random number generator class based on the maximally quidistributed combined Tausworthe generator by L'Ecuyer
CTRandom3	Random number generator class based on M
CTRealData	Manages the effective list of all data members for a given class
CTReaperTimer
CTRecCmdEvent
CTRecEvent
CTRecExtraEvent
CTRecGuiEvent
CTRecorder
CTRecorderInactive
CTRecorderPaused
CTRecorderRecording
CTRecorderReplaying
CTRecorderState
CTRecWinPair
CTRedirectOutputGuard
CTRef	Persistent Reference link to a TObject A TRef is a lightweight object pointing to any TObject
CTRefArray	An array of references to TObjects
CTRefArrayIter	Iterator of object array
CTRefArrayProxy	A container proxy, which allows to access references stored in a TRefArray from TTree::Draw
CTRefCnt	Definitions for TRefCnt, base class for reference counted objects
CTRefProxy
CTRefTable	A TRefTable maintains the association between a referenced object and the parent object supporting this referenced object
CTRegexp	Regular expression class
CTRemoteObject	Protocol for browsing ROOT objects from a remote ROOT session
CTResponseTable
CTRFIOFile	A ROOT file that reads/writes via a rfiod server
CTRFIOSystem	Directory handler for RFIO
Ctriangulateio
CTRint
CTRobustEstimator
CTRolke
CTROOT	ROOT top level object description
CTRootApplication
CTRootAuth
CTRootBrowser
CTRootBrowserLite
CTRootCanvas
CTRootContextMenu
CTRootControlBar
CTRootDialog
CTRootEmbeddedCanvas
CTRootGuiBuilder
CTRootGuiFactory
CTRootHelpDialog
CTRootIOCtor
CTRootSecContext
CTRootSniffer
CTRootSnifferScanRec
CTRootSnifferStore	Abstract interface for storage of hierarchy scan in TRootSniffer
CTRootSnifferStoreJson	Storage of hierarchy scan in TRootSniffer in JSON format
CTRootSnifferStoreXml	Storage of hierarchy scan in TRootSniffer in XML format
►CTRotation
CTRotationRow
CTRotMatrix	Manages a detector rotation matrix
CTRSA_fun
CTRuby
CTRWLock
CTS3HTTPRequest
CTS3WebFile
CTSapDBResult
CTSapDBRow
CTSapDBServer
CTSAXParser	TSAXParser is a subclass of TXMLParser, it is a wraper class to libxml library
CTSecContext
CTSecContextCleanup
CTSelector	A TSelector object is used by the TTree::Draw, TTree::Scan, TTree::Process to navigate in a TTree and make selections
CTSelectorCint	This class is a special version of TSelector for user interpreted classes
CTSelectorDraw	A specialized TSelector for TTree::Draw
CTSelectorEntries	The class is derived from the ROOT class TSelector
CTSelectorList	A TList derived class that makes sure that objects added to it are not linked to the currently open file (like histograms, eventlists and trees)
CTSelectorScalar	Named scalar type, based on Long64_t, streamable, storable and mergable
CTSelEvent
CTSelEventGen
CTSelHandleDataSet
CTSelHist
CTSelVerifyDataSet
CTSemaphore
CTSeqCollection	Sequenceable collection abstract base class
CTServerSocket
CTSessionDescription
CTSessionFrame
CTSessionInputFrame
CTSessionLogView
CTSessionOutputFrame
CTSessionQueryFrame
CTSessionServerFrame
CTSessionViewer
CTShape	This is the base class for all geometry shapes
CTShutdownTimer
CTSignalHandler
CTSlave
CTSlaveInfo
CTSlaveLite
CTSlider	A specialized TPad including a TSliderBox object
CTSliderBox	The moving box in a TSlider
CTSocket
CTSortedList	A sorted doubly linked list
CTSpectrum	Advanced Spectra Processing
CTSpectrum2	Advanced 2-dimentional spectra processing
CTSpectrum2Fit	Advanced 2-dimentional spectra fitting functions
CTSpectrum2Painter
CTSpectrum2Transform	Advanced 2-dimentional orthogonal transform functions
CTSpectrum3	Advanced 3-dimentional spectra processing functions
CTSpectrumFit	Advanced 1-dimentional spectra fitting functions
CTSpectrumTransform	Advanced 1-dimentional orthogonal transform functions
CTSPHE	A Sphere
CTSpider	Spider class
CTSpiderEditor	The TSpider editor class
CTSpline	Base class for spline implementation containing the Draw/Paint methods //
CTSpline3
CTSpline5
CTSplinePoly
CTSplinePoly3
CTSplinePoly5
CTSPlot
CTSQLClassColumnInfo
CTSQLClassInfo	Contains information about tables specific to one class and version
CTSQLColumnData
CTSQLColumnInfo
CTSQLFile	Access an SQL db via the TFile interface
CTSQLiteResult
CTSQLiteRow
CTSQLiteServer
CTSQLiteStatement
CTSQLMonitoringWriter
CTSQLObjectData	TSQLObjectData is used in TBufferSQL2 class in reading procedure
CTSQLObjectDataPool	XML object keeper class
CTSQLObjectInfo	Info (classname, version) about object in database
CTSQLResult
CTSQLRow
CTSQLServer
CTSQLStatement
CTSQLStructure	This is hierarhical structure, which is created when data is written by TBufferSQL2
CTSQLTableData
CTSQLTableInfo
CTSSLSocket
CTStatistic	Statistical variable, defined by its mean and variance (RMS)
CTStatsFeedback
CTStatus
CTStdExceptionHandler
CTStopwatch	Stopwatch class
CTStorage	Storage manager
CTStreamerArtificial
CTStreamerBase
CTStreamerBasicPointer
CTStreamerBasicType
CTStreamerElement
►CTStreamerInfo	Describe Streamer information for one class version
CTCompInfo
CTPointerCollectionAdapter
CTStreamerLoop
CTStreamerObject
CTStreamerObjectAny
CTStreamerObjectAnyPointer
CTStreamerObjectPointer
CTStreamerSTL
CTStreamerSTLstring
CTStreamerString
►CTString	Basic string class
CLongStr_t
CRawStr_t
CRep_t
CShortStr_t
CUStr_t
CTStringLong	ATTENTION: this class is obsolete
CTStringToken	Provides iteration through tokens of a given string
CTStructNode
CTStructNodeEditor
CTStructNodeProperty
CTStructViewer
CTStructViewerGUI
CTStyle	TStyle objects may be created to define special styles
CTStyleDialog
CTStyleManager
CTStylePreview
CTSubString	A zero length substring is legal
CTSVDUnfold	SVD Approach to Data Unfolding
CTSVG	Interface to SVG
CTSynapse
CTSysEvtHandler	Abstract base class for handling system events
CTSystem	Abstract base class defining a generic interface to the underlying Operating System
CTSystemDirectory	Describes an Operating System directory for the browser
CTSystemFile	A TSystemFile describes an operating system file
CTTabCom
►CTTable
Citerator
Cpiterator
CTTable3Points
CTTableDescriptor
CTTableIter
CTTableMap
CTTablePadView3D
CTTablePoints
CTTableRange
CTTableSorter
CTTask	TTask is a base class that can be used to build a complex tree of Tasks
CTTeXDump	Interface to TeX
CTText	Base class for several text objects
CTTextEditor
►CTTF	Interface to the freetype 2 library
CTTGlyph	TTF helper class containing glyphs description
CTThread
CTThreadCleaner
CTThreadFactory
CTThreadImp
CTThreadPool
CTThreadPoolTask
CTThreadPoolTaskImp
CTThreadTimer
CTTime	Basic time type with millisecond precision
CTTimer	Handles synchronous and a-synchronous timer events
CTTimeStamp	The TTimeStamp encapsulates seconds and ns since EPOCH
CTToggle	This class defines toggling facility for both - object's method or variables
CTToggleGroup	This class defines check-box facility for TToggle objects It is used in context menu "selectors" for picking up a value
CTTRAP	A general trapezoid
CTTRD1	A trapezoid with the x dimension varying along z
CTTRD2	A trapezoid with both x and y dimensions varying along z
►CTTree	A TTree object has a header with a name and a title
CTClusterIterator	Helper class to iterate over cluster of baskets
CTFriendLock	Helper class to prevent infinite recursion in the usage of TTree Friends
CTTreeCache	A specialized TFileCacheRead object for a TTree
CTTreeCacheUnzip	Specialization of TTreeCache for parallel Unzipping
►CTTreeCloner	Class implementing or helping the various TTree cloning method
CCompareEntry
CCompareSeek
CTTreeDrawArgsParser	A class that parses all parameters for TTree::Draw()
CTTreeFormula	Used to pass a selection expression to the Tree drawing routine
CTTreeFormulaManager	Used to coordinate one or more TTreeFormula objects
CTTreeFriendLeafIter	Iterator on all the leaves in a TTree and its friend
CTTreeIndex	A Tree Index with majorname and minorname
CTTreeInput
CTTreePerfStats	TTree I/O performance measurement
CTTreePlayer	Implement some of the functionality of the class TTree requiring access to extra libraries (Histogram, display, etc)
►CTTreeReader	TTreeReader is a simple, robust and fast interface to read values from a TTree, TChain or TNtuple
CIterator_t
►CTTreeReaderArray	Extracts array data from a TTree
CIterator_t
CTTreeReaderValue	Extracts data from a TTree
CTTreeResult	Class defining interface to a TTree query result with the same interface as for SQL databases
CTTreeRow	Class defining interface to a row of a TTree query result
CTTreeSQL	Implement TTree for a SQL backend
CTTreeTableInterface	TTreeTableInterface is used to interface to data that is stored in a TTree
CTTreeViewer	A graphic user interface designed to handle ROOT trees and to take advantage of TTree class features
CTTUBE	A tube
CTTUBS	A segment of a tube
CTTVLVContainer	This class represent the list view container for the
CTTVLVEntry	This class represent entries that goes into the TreeViewer listview container
CTTVRecord	I/O classes for TreeViewer session handling
CTTVSession	I/O classes for TreeViewer session handling
CTUDPSocket
CTUnfold	TUnfold is used to decompose a measurement y into several sources x given the measurement uncertainties and a matrix of migrations A
CTUnfoldBinning	This class serves as a container of analysis bins analysis bins are specified by defining the axes of a distribution
CTUnfoldDensity
CTUnfoldSys	TUnfold is used to decompose a measurement y into several sources x given the measurement uncertainties and a matrix of migrations A
CTUnixSystem
CTUnuran	TUnuran class
CTUnuranBaseDist	TUnuranBaseDist, base class for Unuran distribution classees such as TUnuranContDist (for one-dimension) or TUnuranMultiContDist (multi-dimension)
CTUnuranContDist	TUnuranContDist class describing one dimensional continuous distribution
CTUnuranDiscrDist	TUnuranDiscrDist class for one dimensional discrete distribution
CTUnuranEmpDist	TUnuranEmpDist class for describing empiral distributions
CTUnuranMultiContDist	TUnuranMultiContDist class describing multi dimensional continuous distributions
CTUnuranSampler	TUnuranSampler class class implementing the ROOT::Math::DistSampler interface using the UNU.RAN package for sampling distributions
CTUploadDataSetDlg
CTUri	This class represents a RFC 3986 compatible URI
CTUrl	This class represents a WWW compatible URL
►CTUUID	This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier)
Cuuid_time_t
CTVector2
CTVector3
CTVectorT
CTVersionCheck
CTView	See TView3D
CTView3D	The 3D view class
CTViewer3DPad	Provides 3D viewer interface (TVirtualViewer3D) support on a pad
CTViewPubDataMembers	View implementing the TList interface and giving access all the TDictionary describing public data members in a class and all its base classes without caching any of the TDictionary pointers
CTViewPubDataMembersIter	Iterator of over the view's content
CTViewPubFunctions	View implementing the TList interface and giving access all the TFunction describing public methods in a class and all its base classes without caching any of the TFunction pointers
CTViewPubFunctionsIter	Iterator of over the view's content
CTViewTimer
CTVirtualArray	Wrapper 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
CTVirtualBranchBrowsable	TVirtualBranchBrowsable is a base class (not really abstract, but useless by itself) for helper objects that extend TBranch's browsing support
CTVirtualCollectionIterators	Small helper class to generically acquire and release iterators
►CTVirtualCollectionProxy
CTPushPop
►CTVirtualCollectionPtrIterators
CTInternalIterator
CTVirtualDragManager
CTVirtualFFT	TVirtualFFT is an interface class for Fast Fourier Transforms
CTVirtualFitter	Abstract Base Class for Fitting
CTVirtualGeoPainter
CTVirtualGeoTrack
CTVirtualGLManip
CTVirtualGLPainter
CTVirtualGraphPainter	Abstract interface to a histogram painter
CTVirtualHistPainter	Abstract interface to a histogram painter
CTVirtualIndex	Abstract interface for Tree Index
CTVirtualIsAProxy
CTVirtualMagField
CTVirtualMC
CTVirtualMCApplication
CTVirtualMCDecayer
CTVirtualMCGeometry
CTVirtualMCStack
CTVirtualMonitoringReader
CTVirtualMonitoringWriter
CTVirtualMutex	This class implements a mutex interface
CTVirtualObject	Wrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary
►CTVirtualPacketizer
CTVirtualSlaveStat
CTVirtualPad	TVirtualPad is an abstract base class for the Pad and Canvas classes
CTVirtualPadEditor	Abstract base class used by ROOT graphics editor
CTVirtualPadPainter	To make it possible to use GL for 2D graphic in a TPad/TCanvas
CTVirtualPerfStats	Provides the interface for the PROOF internal performance measurement and event tracing
CTVirtualProofPlayer
CTVirtualPS	TVirtualPS is an abstract interface to Postscript, PDF, SVG
CTVirtualRefProxy
CTVirtualStreamerInfo	Abstract Interface class describing Streamer information for one class
CTVirtualTableInterface
CTVirtualTreePlayer	Abstract base class defining the interface for the plugins that implement Draw, Scan, Process, MakeProxy, etc
CTVirtualVectorIterators
CTVirtualViewer3D	Abstract 3D shapes viewer
CTVirtualX	Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...)
CTVolume
CTVolumePosition
CTVolumeView
CTVolumeViewIter
CTWbox	A TBox with a bordersize and a bordermode
CTWebFile
CTWebSystem
CTWin32Condition
CTWin32Mutex
CTWin32SplashThread
CTWin32Thread
CTWin32ThreadCleanUp
CTWin32ThreadFactory
CTWinNTSystem
CTX11GLManager	The TX11GLManager is X11 implementation of TGLManager
CTXHandler
CTXMLAttr	TXMLAttribute is the attribute of an Element
CTXMLDocument	TXMLDocument contains a pointer to an xmlDoc structure, after the parser returns a tree built during the document analysis
CTXMLEngine
CTXMLFile
CTXMLNode	TXMLNode contains a pointer to xmlNode, which is a node under the DOM tree
CTXMLParser	TXMLParser is an abstract class which interfaces with Libxml2
CTXMLPlayer
CTXMLSetup
CTXNetFile
CTXNetFileStager
CTXNetSystem
CTXNetSystemConnectGuard
CTXProofMgr
CTXProofServ
CTXrdClientAdminWrapper
CTXSemaphoreGuard
CTXSlave
CTXSockBuf
CTXSocket
CTXSocketHandler
CTXSockPipe
CTXTRU	A poly-extrusion
CTXUnixSocket
CTZIPFile	Describes a ZIP archive file containing multiple sub-files
CTZIPMember	A ZIP archive consists of files compressed with the popular ZLIB compression algorithm; this class records the information about a single archive member
CUnuRanDist
CUnuranDistr	UnuranDistr Provides free function based on TF1 to be called by unuran
CUnuranDistrMulti	Free functions for multidimensional functions needed bby UNURAN
CUnuranRng	UnuranRng class for interface ROOT random generators to Unuran
CUserGroup_t
CVariableSelectionRule
CVectorMemoryHelper
CVecTrackD
CVecTVecDouble
CVecVecDouble
CWindowAttributes_t
CWrapperRooPdf
C<X11Drawable>
C<X11Window>
CXColor_t	Description of a X11 color
CXHandleErr_t
CXHandleIn_t
►CXMLReader
CAttributes
CXPClientArchiveRequest
CXPClientInterruptRequest
CXPClientLoginRequest
CXPClientProofRequest
CXPClientReadbufRequest
CXPClientRequest
CXPClientSendRcvRequest
CXpdAdminCpCmd
CXpdClientSessions
CXpdEnv
CXpdGroupEff_t
CXpdGroupGlobal_t
CXpdManagerCron_t
CXpdMsg
CXpdObject
CXpdObjectQ
CXpdSrvMgrCreateCnt
CXpdSrvMgrCreateGuard
CXrdClientCacheInterval
►CXrdClientConn
CSessionIDInfo
►CXrdClientConnectionMgr
CCndVarInfo
CXrdClientID
CXrdClientInputBuffer
CXrdClientLogConnection
CXrdClientMessage
CXrdClientPhyConnection
CXrdClientPhyConnLocker
CXrdClientReadCache
CXrdClientReadCacheItem
CXrdClientSock
CXrdClientSockConnectParms
►CXrdPoll
CPipeData
CXrdProofConn
CXrdProofdAdmin
CXrdProofdAux
CXrdProofdClient
CXrdProofdClientMgr
CXrdProofdConfig
CXrdProofdDirective
CXrdProofdDSInfo
CXrdProofdFile
CXrdProofdManager
CXrdProofdMultiStr
CXrdProofdMultiStrToken
CXrdProofdNetMgr
CXrdProofdPInfo
CXrdProofdPipe
CXrdProofdPriority
CXrdProofdPriorityMgr
CXrdProofdProofServ
CXrdProofdProofServMgr
CXrdProofdProtocol
CXrdProofdResponse
CXrdProofdSandbox
CXrdProofdSessionEntry
CXrdProofGI
CXrdProofGroup
CXrdProofGroupMember
CXrdProofGroupMgr
CXrdProofPhyConn
CXrdProofQuery
CXrdProofSched
CXrdProofSessionInfo
CXrdProofUI
CXrdProofWorker
CXrdROOT
CXrdROOTMgr
CXrdSrvBuffer
CXrdSysPriv
CXrdSysPrivGuard
CXShapeEvent