Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

CROOT::Math::CholeskyDecompHelpers::_decomposer< F, N, M >	Struct to do a Cholesky decomposition
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 0, M >	Struct to do a Cholesky decomposition (specialized, N = 0)
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 1, M >	Struct to do a Cholesky decomposition (specialized, N = 1)
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 2, M >	Struct to do a Cholesky decomposition (specialized, N = 2)
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 3, M >	Struct to do a Cholesky decomposition (specialized, N = 3)
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 4, M >	Struct to do a Cholesky decomposition (specialized, N = 4)
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 5, M >	Struct to do a Cholesky decomposition (specialized, N = 5)
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 6, M >	Struct to do a Cholesky decomposition (specialized, N = 6)
CROOT::Math::CholeskyDecompHelpers::_decomposerGenDim< F, M >	Struct to do a Cholesky decomposition (general dimensionality)
CROOT::Math::CholeskyDecompHelpers::_inverter< F, N, M >	Struct to obtain the inverse from a Cholesky decomposition
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 0, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 0)
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 1, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 1)
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 2, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 2)
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 3, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 3)
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 4, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 4)
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 5, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 5)
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 6, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 6)
CROOT::Math::CholeskyDecompHelpers::_inverterGenDim< F, M >	Struct to obtain the inverse from a Cholesky decomposition (general dimensionality)
CROOT::Math::CholeskyDecompHelpers::_solver< F, N, V >	Struct to solve a linear system using its Cholesky decomposition
CROOT::Math::CholeskyDecompHelpers::_solver< F, 0, V >	Struct to solve a linear system using its Cholesky decomposition (N=0)
CROOT::Math::CholeskyDecompHelpers::_solver< F, 1, V >	Struct to solve a linear system using its Cholesky decomposition (N=1)
CROOT::Math::CholeskyDecompHelpers::_solver< F, 2, V >	Struct to solve a linear system using its Cholesky decomposition (N=2)
CROOT::Math::CholeskyDecompHelpers::_solver< F, 3, V >	Struct to solve a linear system using its Cholesky decomposition (N=3)
CROOT::Math::CholeskyDecompHelpers::_solver< F, 4, V >	Struct to solve a linear system using its Cholesky decomposition (N=4)
CROOT::Math::CholeskyDecompHelpers::_solver< F, 5, V >	Struct to solve a linear system using its Cholesky decomposition (N=5)
CROOT::Math::CholeskyDecompHelpers::_solver< F, 6, V >	Struct to solve a linear system using its Cholesky decomposition (N=6)
CROOT::Math::CholeskyDecompHelpers::_solverGenDim< F, V >	Struct to solve a linear system using its Cholesky decomposition (generalised dimensionality)
CROOT::Minuit2::ABObj< mtype, M, T >
CROOT::Minuit2::ABObj< sym, LASymMatrix, double >
CROOT::Minuit2::ABObj< vec, LAVector, double >
CROOT::Minuit2::ABProd< M1, M2 >
CROOT::Minuit2::ABSum< M1, M2 >
CROOT::Math::AddOp< T >	Addition Operation Class
CROOT::Math::AddPolicy< T, D1, D2, R1, R2 >	Matrix addition policy
CROOT::Math::AddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > >
CROOT::Minuit2::AlgebraicProdType< A, B >
CROOT::Minuit2::AlgebraicProdType< gen, gen >
CROOT::Minuit2::AlgebraicProdType< gen, sym >
CROOT::Minuit2::AlgebraicProdType< gen, vec >
CROOT::Minuit2::AlgebraicProdType< sym, gen >
CROOT::Minuit2::AlgebraicProdType< sym, sym >
CROOT::Minuit2::AlgebraicProdType< sym, vec >
CROOT::Minuit2::AlgebraicProdType< T, T >
CROOT::Minuit2::AlgebraicProdType< vec, gen >
CROOT::Minuit2::AlgebraicProdType< vec, sym >
CROOT::Minuit2::AlgebraicSumType< A, B >
CROOT::Minuit2::AlgebraicSumType< gen, vec >
CROOT::Minuit2::AlgebraicSumType< sym, vec >
CROOT::Minuit2::AlgebraicSumType< T, T >
CROOT::Minuit2::AlgebraicSumType< vec, gen >
CROOT::Minuit2::AlgebraicSumType< vec, sym >
CROOT::Math::Assign< T, D1, D2, A, R1, R2 >	Structure to assign from an expression based to general matrix to general matrix
CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >	Dummy Structure which flags an error to avoid assigment from expression based on a general matrix to a symmetric matrix
CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >	Structure to assign from an expression based to symmetric matrix to symmetric matrix
CROOT::Math::AssignItr< T, D1, D2, R >	Structure for assignment to a general matrix from iterator
CROOT::Math::AssignItr< T, D1, D2, MatRepSym< T, D1 > >	Specialized structure for assignment to a symmetrix matrix from iterator
CROOT::Math::AssignSym	Force Expression evaluation from general to symmetric
CROOT::Math::AxisAngle	AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis
►CROOT::Math::BaseIntegratorOptions	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
CROOT::Math::IntegratorMultiDimOptions	Numerical multi dimensional integration options
CROOT::Math::IntegratorOneDimOptions	Numerical one dimensional integration options
►CROOT::Math::KDTree< _DataPoint >::BaseNode
►CROOT::Math::KDTree< _DataPoint >::BinNode
CROOT::Math::KDTree< _DataPoint >::TerminalNode
CROOT::Math::KDTree< _DataPoint >::HeadNode
CROOT::Math::KDTree< _DataPoint >::SplitNode
CROOT::Minuit2::BasicFunctionGradient
CROOT::Minuit2::BasicFunctionMinimum	Result of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum
CROOT::Minuit2::BasicMinimumError	Internal Class containing the error information on the estimated minimum : Error matrix + dcovar + additional flags for quality and validity checks
CROOT::Minuit2::BasicMinimumParameters
CROOT::Minuit2::BasicMinimumSeed
CROOT::Minuit2::BasicMinimumState
CROOT::Math::BinaryOp< Operator, LHS, RHS, T >	BinaryOperation class A class representing binary operators in the parse tree
CROOT::Math::BinaryOpCopyL< Operator, LHS, RHS, T >	Binary Operation class with value storage for the left argument
CROOT::Math::BinaryOpCopyR< Operator, LHS, RHS, T >	Binary Operation class with value storage for the right argument
CBinaryOpPolicy
CROOT::Math::GenVector_detail::BitReproducible
CROOT::Math::Boost	Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix
CROOT::Math::BoostX	Class representing a Lorentz Boost along the X axis, by beta
CROOT::Math::BoostY	Class representing a Lorentz Boost along the Y axis, by beta
CROOT::Math::BoostZ	Class representing a Lorentz Boost along the Z axis, by beta
CROOT::Math::Cartesian2D< T >	Class describing a 2D cartesian coordinate system (x, y coordinates)
CROOT::Math::Cartesian3D< T >	Class describing a 3D cartesian coordinate system (x, y, z coordinates)
CROOT::Math::Cartesian3D< Scalar >
CROOT::Math::ChebyshevApprox	Class describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials
CROOT::Math::ChebyshevPol
CROOT::Math::CholeskyDecomp< F, N >	Class to compute the Cholesky decomposition of a matrix
CROOT::Math::CholeskyDecompGenDim< F >	Class to compute the Cholesky decomposition of a matrix
CROOT::Math::CholInverter< idim >
CCompareAsc< T >
CCompareDesc< T >
CROOT::Math::KDTree< _DataPoint >::ComparePoints
CROOT::Math::CompileTimeChecker< bool >
CROOT::Math::CompileTimeChecker< false >
CROOT::Math::Constant< T >	Constant expression class A class representing constant expressions (literals) in the parse tree
CContDist	Free functions adapter needed by UNURAN for onedimensional continuous distributions
CROOT::Minuit2::ContoursError
CROOT::Minuit2::MnCross::CrossFcnLimit
CROOT::Minuit2::MnCross::CrossNewMin
CROOT::Minuit2::MnCross::CrossParLimit
CROOT::Math::KDTree< _DataPoint >::Cut
CROOT::Math::Cylindrical3D< T >	Class describing a cylindrical coordinate system based on rho, z and phi
CROOT::Math::CylindricalEta3D< T >	Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z
CROOT::Fit::DataOptions	DataOptions : simple structure holding the options on how the data are filled
CROOT::Fit::DataRange	Class describing the range in the coordinates it supports multiple range in a coordinate
CROOT::Math::GenVector_detail::BitReproducible::DB8
CROOT::Math::DefaultCoordinateSystemTag	DefaultCoordinateSystemTag Default tag for identifying any coordinate system
CROOT::Math::Delaunay2D	Class to generate a Delaunay triangulation of a 2D set of points
CROOT::Math::Derivator	Class for computing numerical derivative of a function
►CDerivFunType
►CROOT::Math::BasicFitMethodFunction< DerivFunType >
►CROOT::Fit::BasicFCN< DerivFunType, ModelFunType, BinData >
CROOT::Fit::Chi2FCN< DerivFunType, ModelFunType >	Chi2FCN class for binnned fits using the least square methods
CROOT::Fit::PoissonLikelihoodFCN< DerivFunType, ModelFunType >	Class evaluating the log likelihood for binned Poisson likelihood fits it is template to distinguish gradient and non-gradient case
►CROOT::Fit::BasicFCN< DerivFunType, ModelFunType, UnBinData >
CROOT::Fit::LogLikelihoodFCN< DerivFunType, ModelFunType >	LogLikelihoodFCN class for likelihood fits
CROOT::Fit::BasicFCN< DerivFunType, ModelFunType, DataType >	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
CROOT::Math::Determinant< n, idim >	Detrminant for a general squared matrix Function to compute the determinant from a square matrix ( \( \det(A)\)) of dimension idim and order n
CDiscrDist	Free functions adapter needed by UNURAN for one-dimensional discrete distribution
CROOT::Math::DisplacementVector2D< CoordSystem, Tag >	Class describing a generic displacement vector in 2 dimensions
CROOT::Math::DisplacementVector3D< CoordSystem, Tag >	Class describing a generic displacement vector in 3 dimensions
CROOT::Math::DisplacementVector3D< Cartesian3D< Scalar > >
CROOT::Math::DisplacementVector3D< Cartesian3D< T >, DefaultCoordinateSystemTag >
►CROOT::Math::DistSampler	Interface class for generic sampling of a distribution, i.e
CTFoamSampler	TFoamSampler class class implementing the ROOT::Math::DistSampler interface using FOAM for sampling arbitrary distributions
CTUnuranSampler	TUnuranSampler class class implementing the ROOT::Math::DistSampler interface using the UNU.RAN package for sampling distributions
CROOT::Math::DistSamplerOptions	DistSampler options class
CROOT::Math::DivOp< T >	Division (element-wise) Operation Class
CROOT::Fit::DummyDeleter< T >
CROOT::Math::gv_detail::ERROR_This_Rotation_Conversion_is_NOT_Supported
CROOT::Math::EulerAngles	EulerAngles class describing rotation as three angles (Euler Angles)
CROOT::Fit::FitUtil::Evaluate< T >
CROOT::Math::EvaluatorOneDim< MultiFuncType >
CROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
►Cstd::exception	STL class
CROOT::Math::GenVector_detail::BitReproducibleException
►Cstd::runtime_error	STL class
CROOT::Math::GenVector_exception
CROOT::Math::Expr< ExprType, T, D, D2, R1 >
CROOT::Math::Fabs< T >	Unary abs Operation Class
CROOT::Math::Factory	Factory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager
CROOT::Math::FastInverter< idim, n >	Fast Matrix Inverter class Class to specialize calls to Dinv
CROOT::Math::FastInverter< 3 >	3x3 direct matrix inversion using Cramer Rule use only for FastInverter
CROOT::Math::FastInverter< 4 >	4x4 matrix inversion using Cramers rule
CROOT::Math::FastInverter< 5 >	5x5 Matrix inversion using Cramers rule
CROOT::Fit::FitConfig	Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class
►CROOT::Fit::FitData	Base class for all the fit data types: Stores the coordinates and the DataOptions
CROOT::Fit::BinData	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:
CROOT::Fit::SparseData
CROOT::Fit::UnBinData	Class describing the unbinned data sets (just x coordinates values) of any dimensions
CROOT::Fit::FitResult	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
CROOT::Fit::Fitter	Fitter class, entry point for performing all type of fits
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F, T >
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *, T >
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *const, T >
CROOT::Minuit2::FunctionGradient
►CROOT::Minuit2::FunctionMinimizer	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
►CROOT::Minuit2::ModularFunctionMinimizer	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
CROOT::Minuit2::CombinedMinimizer	Combined minimizer: combination of Migrad and Simplex
CROOT::Minuit2::FumiliMinimizer	Instantiates the seed generator and Minimum builder for the Fumili minimization method
CROOT::Minuit2::ScanMinimizer	Class implementing the required methods for a minimization using SCAN API is provided in the upper ROOT::Minuit2::ModularFunctionMinimizer class
CROOT::Minuit2::SimplexMinimizer	Class implementing the required methods for a minimization using Simplex
CROOT::Minuit2::VariableMetricMinimizer	Instantiates the SeedGenerator and MinimumBuilder for Variable Metric Minimization method
CROOT::Minuit2::FunctionMinimum	Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum
CROOT::Minuit2::gen
►CROOT::Minuit2::GenericFunction	Class from which all the other classes, representing functions, inherit
►CROOT::Minuit2::FCNBase	Interface (abstract class) defining the function to be minimized, which has to be implemented by the user
CROOT::Minuit2::FCNAdapter< Function >	Template wrapped class for adapting to FCNBase signature
►CROOT::Minuit2::FCNGradientBase	Extension of the FCNBase for providing the analytical Gradient of the function
CROOT::Minuit2::FCNGradAdapter< Function >	Template wrapped class for adapting to FCNBase signature a IGradFunction
►CROOT::Minuit2::FumiliFCNBase	Extension of the FCNBase for the Fumili method
►CROOT::Minuit2::FumiliChi2FCN	Extension of the FCNBase for the Fumili method
CROOT::Minuit2::FumiliStandardChi2FCN	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
CROOT::Minuit2::FumiliFCNAdapter< Function >	Template wrapped class for adapting to FumiliFCNBase signature
►CROOT::Minuit2::FumiliMaximumLikelihoodFCN	Extension of the FCNBase for the Fumili method
CROOT::Minuit2::FumiliStandardMaximumLikelihoodFCN	Class implementing the Elements member function for the standard maximum likelihood method
CROOT::Minuit2::ParametricFunction	Function which has parameters
CROOT::Math::GeneticMinimizerParameters
CROOT::Math::GlobalCoordinateSystemTag	Tag for identifying vectors based on a global coordinate system
CROOT::Math::GoFTest
►CROOT::Minuit2::GradientCalculator	Interface class for gradient calculators
CROOT::Minuit2::AnalyticalGradientCalculator
CROOT::Minuit2::FumiliGradientCalculator
CROOT::Minuit2::HessianGradientCalculator	HessianGradientCalculator: class to calculate Gradient for Hessian
CROOT::Minuit2::InitialGradientCalculator	Class to calculate an initial estimate of the gradient
CROOT::Minuit2::Numerical2PGradientCalculator	Class performing the numerical gradient calculation
CROOT::Math::GSL1DMinimizerWrapper	Wrapper class for gsl_min_fminimizer structure
CROOT::Math::GSLChebSeries	Wrapper class for C struct gsl_cheb_series
CROOT::Math::GSLDerivator	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 )
CROOT::Math::GSLFunctionAdapter< UserFunc >	Class for adapting any C++ functor class to C function pointers used by GSL
CROOT::Math::GSLFunctionDerivWrapper	Class to wrap a gsl_function_fdf (with derivatives)
CROOT::Math::GSLFunctionWrapper	Wrapper class to the gsl_function C structure
CROOT::Math::GSLIntegrationWorkspace
CROOT::Math::GSLInterpolator	Interpolation class based on GSL interpolation functions
►CROOT::Math::GSLMCIntegrationWorkspace
CROOT::Math::GSLMiserIntegrationWorkspace	Workspace for MISER
CROOT::Math::GSLPlainIntegrationWorkspace
CROOT::Math::GSLVegasIntegrationWorkspace	Workspace for VEGAS
CROOT::Math::GSLMonteFunctionAdapter< UserFunc >
CROOT::Math::GSLMonteFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm
CROOT::Math::GSLMultiFit	GSLMultiFit, internal class for implementing GSL non linear least square GSL fitting
CROOT::Math::GSLMultiFitFunctionAdapter< FuncVector >	Class for adapting a C++ functor class to C function pointers used by GSL MultiFit Algorithm The templated C++ function class must implement:
CROOT::Math::GSLMultiFitFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
CROOT::Math::GSLMultiMinDerivFunctionWrapper	Wrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm
CROOT::Math::GSLMultiMinFunctionAdapter< UserFunc >	Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms
CROOT::Math::GSLMultiMinFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
CROOT::Math::GSLMultiMinimizer	GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives
►CROOT::Math::GSLMultiRootBaseSolver	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)
CROOT::Math::GSLMultiRootDerivSolver	GSLMultiRootDerivSolver, internal class for implementing GSL multi-root finders using derivatives
CROOT::Math::GSLMultiRootSolver	GSLMultiRootSolver, internal class for implementing GSL multi-root finders not using derivatives
CROOT::Math::GSLMultiRootDerivFunctionWrapper	Wrapper to a multi-dim function with derivatives for multi roots algorithm
CROOT::Math::GSLMultiRootFinder	Class for Multidimensional root finding algorithms bassed on GSL
CROOT::Math::GSLMultiRootFunctionAdapter< FuncVector >	Class for adapting a C++ functor class to C function pointers used by GSL MultiRoot Algorithm The templated C++ function class must implement:
CROOT::Math::GSLMultiRootFunctionWrapper	Wrapper to a multi-dim function without derivatives for multi roots algorithm
CROOT::Math::GSLQRngWrapper	GSLQRngWrapper class to wrap gsl_qrng structure
►CROOT::Math::GSLQuasiRandomEngine	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
CROOT::Math::GSLQRngNiederreiter2	Niederreiter generator gsl_qrng_niederreiter_2 from here
CROOT::Math::GSLQRngSobol	Sobol generator gsl_qrng_sobol from here
►CROOT::Math::GSLRandomEngine	GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator
CROOT::Math::GSLRngCMRG	Combined multiple recursive generator (L'Ecuyer) see here
CROOT::Math::GSLRngGFSR4	Lagged Fibonacci generator by Ziff see here
CROOT::Math::GSLRngMinStd	MINSTD generator (Park and Miller) see here
CROOT::Math::GSLRngMixMax	MixMax generator based on ROOT::Math::MixMaxEngine of N=240
CROOT::Math::GSLRngMRG	5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here
CROOT::Math::GSLRngMT	Mersenne-Twister generator gsl_rng_mt19937 from here
CROOT::Math::GSLRngRand	BSD rand() generator gsl_rmg_rand from here
CROOT::Math::GSLRngRanLux	Old Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here
CROOT::Math::GSLRngRanLuxD1	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
CROOT::Math::GSLRngRanLuxD2	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
CROOT::Math::GSLRngRanLuxS1	Second generation of Ranlux generator for single precision with luxury level of 1 (It throws away 202 values for every 12 used) see here
CROOT::Math::GSLRngRanLuxS2	Second generation of Ranlux generator for Single precision with luxury level of 2 (It throws away 397 value for every 12 used) see here
CROOT::Math::GSLRngRanMar	RANMAR generator see here
CROOT::Math::GSLRngTaus	Tausworthe generator by L'Ecuyer see here
CROOT::Math::GSLRngROOTWrapper< Engine >
CROOT::Math::GSLRngWrapper	GSLRngWrapper class to wrap gsl_rng structure
CROOT::Math::GSLRootFdFSolver	Root-Finder with derivatives implementation class using GSL
CROOT::Math::GSLRootFSolver	Root-Finder implementation class using GSL
CROOT::Math::GSLSimAnFunc	GSLSimAnFunc class description
CROOT::Math::GSLSimAnnealing	GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function
CROOT::Math::GSLSimAnParams	Structure holding the simulated annealing parameters
CHelperOps
►CIBaseFunc
CROOT::Math::FunctorImpl< IBaseFunc >	FunctorImpl is a base class for the functor handler implementation class
►CROOT::Math::IBaseFunctionMultiDimTempl< T >	Documentation for the abstract class IBaseFunctionMultiDim
►CROOT::Math::IParametricFunctionMultiDimTempl< double >
CROOT::Math::MultiDimParamFunctionAdapter	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
CROOT::Math::WrappedParamFunction< FuncPtr >	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
CROOT::Fit::FcnAdapter
CROOT::Math::Functor	Documentation for class Functor class
►CROOT::Math::IGradientFunctionMultiDimTempl< T >	Interface (abstract class) for multi-dimensional functions providing a gradient calculation
CROOT::Math::GradFunctor	GradFunctor class for Multidimensional gradient functions
CROOT::Math::LSResidualFunc	LSResidualFunc class description
CROOT::Math::MinimTransformFunction	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
CROOT::Math::MultiNumGradFunction	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)
►CROOT::Math::IParametricFunctionMultiDimTempl< T >	IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam
►CROOT::Math::IParametricGradFunctionMultiDimTempl< T >	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
CROOT::Math::MultiDimParamGradFunctionAdapter	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
CROOT::Math::WrappedParamFunctionGen< FuncPtr >	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
CROOT::Math::WrappedMemMultiFunction< FuncObj, MemFuncPtr >
CROOT::Math::WrappedMultiFunction< Func >	Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface
►CROOT::Math::IBaseFunctionOneDim	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 )
CROOT::Math::Functor1D	Functor1D class for one-dimensional functions
►CROOT::Math::IGradientFunctionOneDim	Interface (abstract class) for one-dimensional functions providing a gradient calculation
CROOT::Math::GradFunctor1D	GradFunctor1D class for one-dimensional gradient functions
CROOT::Math::IntegrandTransform	Auxiliary inner class for mapping infinite and semi-infinite integrals
►CROOT::Math::IParametricFunctionOneDim	Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam
►CROOT::Math::IParametricGradFunctionOneDim	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
►CROOT::Math::ParamFunction< IParamGradFunction >
CROOT::Math::Polynomial	Parametric Function class describing polynomials of order n
CROOT::Math::VavilovAccurateCdf	Class describing the Vavilov cdf
CROOT::Math::VavilovAccuratePdf	Class describing the Vavilov pdf
CROOT::Math::VavilovAccurateQuantile	Class describing the Vavilov quantile function
CROOT::Math::OneDimMultiFunctionAdapter< MultiFuncType >	OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one
CROOT::Math::OneDimParamFunctionAdapter< ParamFuncType >	OneDimParamFunctionAdapter class to wrap a multi-dim parameteric function in one dimensional one
CROOT::Math::WrappedFunction< Func >	Template class to wrap any C++ callable object which takes one argument i.e
CROOT::Math::WrappedMemFunction< FuncObj, MemFuncPtr >	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;
►CROOT::Math::IBaseParam	Documentation for the abstract class IBaseParam
CROOT::Math::IParametricFunctionMultiDimTempl< double >
CROOT::Math::IParametricFunctionMultiDimTempl< T >	IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam
CROOT::Math::IParametricFunctionOneDim	Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam
CROOT::Math::IParametricGradFunctionMultiDimTempl< T >	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
►CROOT::Math::IGradientMultiDimTempl< T >	Gradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function
CROOT::Math::IGradientFunctionMultiDimTempl< T >	Interface (abstract class) for multi-dimensional functions providing a gradient calculation
►CROOT::Math::IGradientOneDim	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
CROOT::Math::IGradientFunctionOneDim	Interface (abstract class) for one-dimensional functions providing a gradient calculation
CROOT::Math::Polynomial	Parametric Function class describing polynomials of order n
►CROOT::Math::IMinimizer1D	Interface class for numerical methods for one-dimensional minimization
CROOT::Math::BrentMinimizer1D	User class for performing function minimization
CROOT::Math::GSLMinimizer1D	Minimizer for arbitrary one dimensional functions
►CImpl
CROOT::Math::FunctorGradHandler< ParentFunctor, Func, GradFunc >	Functor Handler class for gradient functions where both callable objects are provided for the function evaluation (type Func) and for the gradient (type GradFunc)
CROOT::Math::FunctorHandler< ParentFunctor, Func >	Functor Handler class is responsible for wrapping any other functor and pointer to free C functions
CROOT::Math::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >	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
CROOT::Math::MemGradFunHandler< ParentFunctor, PointerToObj, PointerToMemFn, PointerToGradMemFn >	Functor Handler to Wrap pointers to member functions for the evaluation of the function and the gradient
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >	ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions
CROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >	ParamFunctor Handler to Wrap pointers to member functions
CROOT::Math::rowOffsetsUtils::indices<... >
CROOT::Fit::FitUtil::IntegralEvaluator< ParamFunc >
CROOT::Math::IntegratorMultiDim	User class for performing multidimensional integration
CROOT::Math::IntegratorOneDim	User Class for performing numerical integration of a function in one dimension
CROOT::Math::Interpolator	Class for performing function interpolation of points
CROOT::Math::Inverter< idim, n >	Matrix Inverter class Class to specialize calls to Dinv
CROOT::Math::Inverter< 0 >	Inverter<0>
CROOT::Math::Inverter< 1 >	1x1 matrix inversion \(a_{11} \to 1/a_{11}\)
CROOT::Math::Inverter< 2 >	2x2 matrix inversion using Cramers rule
►CROOT::Math::IOptions	Generic interface for defining configuration options of a numerical algorithm
CROOT::Math::GenAlgoOptions	Class implementing generic options for a numerical algorithm Just store the options in a map of string-value pairs
►CROOT::Math::IRootFinderMethod	Interface for finding function roots of one-dimensional functions
CROOT::Math::BrentRootFinder	Class for finding the root of a one dimensional function using the Brent algorithm
►CROOT::Math::GSLRootFinder	Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives
CROOT::Math::Roots::Bisection	Roots::Bisection Bisection algorithm, simplest algorithm for bracketing the roots of a function, but slowest one
CROOT::Math::Roots::Brent	Brent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information
CROOT::Math::Roots::FalsePos	False Position algorithm based on linear interpolation
►CROOT::Math::GSLRootFinderDeriv	Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives
CROOT::Math::Roots::Newton	Newton algorithm, which computes the derivative at each iteration See the GSL manual for more information
CROOT::Math::Roots::Secant	Secant algorithm, simplified version of Newton method, which does not require the derivative at every step
CROOT::Math::Roots::Steffenson	Steffenson method, providing the fastes convergence
CROOT::Math::KDTree< _DataPoint >::iterator
CROOT::Math::KahanSum< T >	The Kahan compensate summation algorithm significantly reduces the numerical error in the total obtained by adding a sequence of finite precision floating point numbers
CROOT::Math::KDTree< _DataPoint >
CROOT::Math::KelvinFunctions	This class calculates the Kelvin functions Ber(x), Bei(x), Ker(x), Kei(x), and their first derivatives
CROOT::Minuit2::LASymMatrix	Class describing a symmetric matrix of size n
CROOT::Minuit2::LAVector
CROOT::Fit::FitUtil::LikelihoodAux< T >
CROOT::Fit::FitUtil::LikelihoodAux< double >
CTMath::Limits< T >
CROOT::Math::LocalCoordinateSystemTag	Tag for identifying vectors based on a local coordinate system
CROOT::Math::LorentzRotation	Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix
CROOT::Math::LorentzVector< CoordSystem >	Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part
CROOT::Math::rowOffsetsUtils::make_indices_impl< I, IndexTuple, N >
►CROOT::Math::rowOffsetsUtils::make_indices_impl< 0, indices<>, N >
CROOT::Math::rowOffsetsUtils::make_indices< N >
CROOT::Math::rowOffsetsUtils::make_indices_impl< I, indices< Indices... >, N >
CROOT::Math::rowOffsetsUtils::make_indices_impl< N, indices< Indices... >, N >
CROOT::Math::detail::manipulator< char_t >
CROOT::Math::MathMoreLib
CROOT::Math::MatRepStd< T, D1, D2 >	Expression wrapper class for Matrix objects
CROOT::Math::MatRepSym< T, D >	MatRepSym Matrix storage representation for a symmetric matrix of dimension NxN This class is a template on the contained type and on the symmetric matrix size, N
CROOT::Minuit2::MatrixInverse< mtype, M, T >
CROOT::Minuit2::MatrixInverse< vec, M, T >
CROOT::Math::MatrixMulOp< MatrixA, MatrixB, T, D >	Class for Matrix-Matrix multiplication
CROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >::MemFuncEvaluator< PObj, F, T >
CROOT::Math::meta_col_dot< I >
CROOT::Math::meta_col_dot< 0 >
CROOT::Math::meta_dot< I >
CROOT::Math::meta_dot< 0 >
CROOT::Math::meta_mag< I >
CROOT::Math::meta_mag< 0 >
CROOT::Math::meta_matrix_dot< I >
CROOT::Math::meta_matrix_dot< 0 >
CROOT::Math::meta_row_dot< I >
CROOT::Math::meta_row_dot< 0 >
►CROOT::Math::Minimizer	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
►CROOT::Math::BasicMinimizer	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
CROOT::Math::GSLMinimizer	GSLMinimizer class
CROOT::Math::GSLNLSMinimizer	GSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting
CROOT::Math::GSLSimAnMinimizer	GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL
CROOT::Math::IpoptMinimizer	IpoptMinimizer class
CROOT::Math::RMinimizer	RMinimizer class
CROOT::Math::GeneticMinimizer	GeneticMinimizer
CROOT::Minuit2::Minuit2Minimizer	Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm
CTFumiliMinimizer	TFumiliMinimizer class: minimizer implementation based on TFumili
CTLinearMinimizer	TLinearMinimizer class: minimizer implementation based on TMinuit
CTMinuitMinimizer	TMinuitMinimizer class: ROOT::Math::Minimizer implementation based on TMinuit
CROOT::Math::MinimizerOptions	Minimizer options
►CROOT::Math::MinimizerVariableTransformation	Base class for MinimizerVariable transformations defining the functions to deal with bounded parameters
CROOT::Math::SinVariableTransformation	Sin Transformation class for dealing with double bounded variables
CROOT::Math::SqrtLowVariableTransformation	Sqrt Transformation class for dealing with lower bounded variables
CROOT::Math::SqrtUpVariableTransformation	Sqrt Transformation class for dealing with upper bounded variables
CROOT::Math::MinimTransformVariable	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
►CROOT::Minuit2::MinimumBuilder
CROOT::Minuit2::CombinedMinimumBuilder
CROOT::Minuit2::FumiliBuilder	Builds the FunctionMinimum using the Fumili method
CROOT::Minuit2::ScanBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CROOT::Minuit2::SimplexBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CROOT::Minuit2::VariableMetricBuilder	Build (find) function minimum using the Variable Metric method (MIGRAD)
CROOT::Minuit2::MinimumError	MinimumError keeps the inv
►CROOT::Minuit2::MinimumErrorUpdator
CROOT::Minuit2::DavidonErrorUpdator	Update of the covariance matrix for the Variable Metric minimizer (MIGRAD)
CROOT::Minuit2::FumiliErrorUpdator	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
CROOT::Minuit2::MinimumParameters
CROOT::Minuit2::MinimumSeed	MinimumSeed contains the starting values for the minimization produced by the SeedGenerator
►CROOT::Minuit2::MinimumSeedGenerator	Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization;
CROOT::Minuit2::MnSeedGenerator	Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer;
CROOT::Minuit2::SimplexSeedGenerator	Generate Simplex starting point (state)
CROOT::Minuit2::MinimumState	MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder)
CROOT::Math::MinOp< T >	Subtraction Operation Class
CROOT::Minuit2::MinosError	Class holding the result of Minos (lower and upper values) for a specific parameter
CROOT::Minuit2::MinuitParameter	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;
CROOT::Math::Minus< T >	Unary Minus Operation Class
CROOT::Math::MinusEquals< T, D1, D2, A, R1, R2 >	Evaluate the expression performing a -= operation Need to check whether creating a temporary object with the expression result (like in op: A -= A * B )
CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >	Specialization for symmetrix -= general : NOT Allowed operation
CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >	Specialization for symmetric matrices
CROOT::Math::MiserParameters	Structures collecting parameters for MISER multidimensional integration
CROOT::Math::MixMaxEngineImpl< N >
CROOT::Math::MixMaxEngineImpl< ROOT_MM_N >
CROOT::Minuit2::BasicFunctionMinimum::MnAboveMaxEdm
CROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm
►CROOT::Minuit2::MnApplication	Application interface class for minimizers (migrad, simplex, Minimize, Scan) User normally instantiates the derived class like ROOT::Minuit2::MnMigrad for using Migrad for minimization
CROOT::Minuit2::MnFumiliMinimize	API class for minimization using Fumili technology; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CROOT::Minuit2::MnMigrad	API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CROOT::Minuit2::MnMinimize	API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CROOT::Minuit2::MnScan	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
CROOT::Minuit2::MnSimplex	API class for minimization using the Simplex method, which does not need and use the derivatives of the function, but only function values
CROOT::Minuit2::MnContours	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;
CROOT::Minuit2::MnCovarianceSqueeze	Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index
CROOT::Minuit2::MnCross
CROOT::Minuit2::MnEigen	API class for calculating the eigenvalues of symmetric matrix
►CROOT::Minuit2::MnFcn	Wrapper class to FCNBase interface used internally by Minuit
CROOT::Minuit2::MnUserFcn	Wrapper used by Minuit of FCN interface containing a reference to the transformation object
CROOT::Minuit2::MnFunctionCross	MnFunctionCross
CROOT::Minuit2::MnGlobalCorrelationCoeff	Class for global correlation coefficient
CROOT::Minuit2::MnHesse	API class for calculating the numerical covariance matrix (== 2x Inverse Hessian == 2x Inverse 2nd derivative); can be used by the user or Minuit itself
CROOT::Minuit2::BasicMinimumError::MnHesseFailed
CROOT::Minuit2::MinimumError::MnHesseFailed
CROOT::Minuit2::BasicMinimumError::MnInvertFailed
CROOT::Minuit2::MinimumError::MnInvertFailed
CROOT::Minuit2::MnLineSearch	Implements a 1-dimensional minimization along a given direction (i.e
CROOT::Minuit2::MnMachinePrecision	Determines the relative floating point arithmetic precision
CROOT::Minuit2::BasicMinimumError::MnMadePosDef
CROOT::Minuit2::MinimumError::MnMadePosDef
CROOT::Minuit2::MnMinos	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;
CROOT::Minuit2::BasicMinimumError::MnNotPosDef
CROOT::Minuit2::MinimumError::MnNotPosDef
CROOT::Minuit2::MnParabola	This class defines a parabola of the form a*x*x + b*x + c
CROOT::Minuit2::MnParabolaFactory
CROOT::Minuit2::MnParabolaPoint	A point of a parabola
CROOT::Minuit2::MnParameterScan	Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found
CROOT::Minuit2::MnPlot	MnPlot produces a text-screen graphical output of (x,y) points, e.g
CROOT::Minuit2::MnPosDef	Force the covariance matrix to be positive defined by adding extra terms in the diagonal
CROOT::Minuit2::MnPrint
CROOT::Minuit2::BasicFunctionMinimum::MnReachedCallLimit
CROOT::Minuit2::FunctionMinimum::MnReachedCallLimit
CROOT::Minuit2::MnRefCountedPointer< T >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionGradient >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionMinimum >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumError >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumParameters >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumSeed >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumState >
CROOT::Minuit2::MnReferenceCounter
CROOT::Minuit2::MnStrategy	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)
CROOT::Minuit2::MnTiny
►CROOT::Minuit2::MnTraceObject
CTMinuit2TraceObject
CROOT::Minuit2::MnUserCovariance	Class containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide internal matrix representation to user
CROOT::Minuit2::MnUserParameters	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
CROOT::Minuit2::MnUserParameterState	Class which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand;
CROOT::Minuit2::MnUserTransformation	Class dealing with the transformation between user specified parameters (external) and internal parameters used for minimization
CROOT::Minuit2::MnVectorTransform
CROOT::Minuit2::MPIProcess
CROOT::Minuit2::MPITerminate
CROOT::Math::MulOp< T >	Multiplication (element-wise) Operation Class
CMultiDist	Free functions adapter needed by UNURAN for multidimensional cont distribution
CROOT::Math::MultPolicy< T, R1, R2 >	Matrix-matrix multiplication policy
CROOT::Minuit2::NegativeG2LineSearch	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
CROOT::Math::NullTypeFunc1D
CROOT::Math::CholeskyDecompHelpers::PackedArrayAdapter< G >	Adapter for packed arrays (to SMatrix indexing conventions)
CROOT::Fit::ParameterSettings	Class, describing value, limits and step size of the parameters Provides functionality also to set/retrieve values, step sizes, limits and fix the parameters
CROOT::Math::ParamFunctionBase< T >	Class defining the signature for multi-dim parametric functions
CROOT::Math::ParamFunctorTempl< T >	Param Functor class for Multidimensional functions
CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, R1, R2 >
CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, R1, R2 >	Structure to deal when a submatrix is placed in a matrix
CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CROOT::Math::PlainParameters
CROOT::Math::Impl::Plane3D< T >	Class describing a geometrical plane in 3 dimensions
CROOT::Math::PlusEquals< T, D1, D2, A, R1, R2 >	Evaluate the expression performing a += operation Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >	Specialization for symmetrix += general : NOT Allowed operation
CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >	Specialization for symmetric matrices Evaluate the expression performing a += operation for symmetric matrices Need to have a separate functions to avoid to modify two times the off-diagonal elements (i.e applying two times the expression) Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
CROOT::Math::Polar2D< T >	Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI)
CROOT::Math::Polar3D< T >	Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI)
CROOT::Math::PositionVector2D< CoordSystem, Tag >	Class describing a generic position vector (point) in 2 dimensions
CROOT::Math::PositionVector3D< CoordSystem, Tag >	Class describing a generic position vector (point) in 3 dimensions
CROOT::Math::PtEtaPhiE4D< ScalarType >	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+)
CROOT::Math::PtEtaPhiM4D< ScalarType >	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+)
CROOT::Math::PxPyPzE4D< ScalarType >	Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E)
CROOT::Math::PxPyPzM4D< ScalarType >	Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M)
CROOT::Math::QuasiRandom< Engine >	User class for MathMore random numbers template on the Engine type
CROOT::Math::Quaternion	Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k)
CROOT::Math::Random< Engine >	Documentation for the Random class
CROOT::Math::RandomFunctions< Engine, EngineBaseType >
►CROOT::Math::RandomFunctions< EngineType, DefaultEngineType >
CROOT::Math::RandomFunctions< EngineType, ROOT::Math::GSLRandomEngine >	Specialized implementation of the Random functions based on the GSL library
CROOT::Math::RandomFunctionsImpl< EngineBaseType >	Definition of the generic impelmentation class for the RandomFunctions
CROOT::Math::RandomFunctionsImpl< DefaultEngineType >
CROOT::Math::RandomFunctionsImpl< TRandomEngine >	Implementation class for the RandomFunction for all the engined that derives from TRandomEngine class, which defines an interface which has TRandomEngine::Rndm() In this way we can have a common implementation for the RandomFunctions
CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, R1, R2 >	Structure for getting sub matrices We have different cases according to the matrix representations
CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CROOT::Math::RichardsonDerivator	User class for calculating the derivatives of a function
Crng_state_st
CROOT::Math::RootFinder	User Class to find the Root of one dimensional functions
CROOT::Math::Rotation3D	Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
CROOT::Math::RotationX	Rotation class representing a 3D rotation about the X axis by the angle of rotation
CROOT::Math::RotationY	Rotation class representing a 3D rotation about the Y axis by the angle of rotation
CROOT::Math::RotationZ	Rotation class representing a 3D rotation about the Z axis by the angle of rotation
CROOT::Math::RotationZYX	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 Y axis, followed by a third rotation of an angle psi (roll) about the X axis
CROOT::Math::RowOffsets< D >	Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix
CROOT::Math::SDeterminant< n, idim >	Dsfact
CROOT::Minuit2::SimplexParameters	Class describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process
CROOT::Minuit2::SinParameterTransformation	Class for the transformation for double-limited parameter Using a sin function one goes from a double-limited parameter range to an unlimited one
CROOT::Math::SInverter< T, n, idim >	Dsinv
CROOT::Math::SkipFunction< SkipNumber >
CROOT::Math::SkipFunction< 0 >
CROOT::Math::SMatrix< T, D1, D2, R >	SMatrix: a generic fixed size D1 x D2 Matrix class
CROOT::Math::SMatrixIdentity
CROOT::Math::SMatrixNoInit
CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow
CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const
CROOT::Math::Sqr< T >	Unary Square Operation Class
CROOT::Math::Sqrt< T >	Unary Square Root Operation Class
CROOT::Minuit2::SqrtLowParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CROOT::Minuit2::SqrtUpParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CROOT::Minuit2::StackAllocator	StackAllocator controls the memory allocation/deallocation of Minuit
CROOT::Minuit2::StackAllocatorHolder
CROOT::Minuit2::StackError
CROOT::Minuit2::StackOverflow	Define stack allocator symbol
CROOT::Math::StdEngine< Generator >	Class to wrap engines fron the C++ standard random library in the ROOT Random interface
CROOT::Math::StdEngineType< Generator >
CROOT::Math::StdEngineType< std::knuth_b >
CROOT::Math::StdEngineType< std::minstd_rand >
CROOT::Math::StdEngineType< std::mt19937 >
CROOT::Math::StdEngineType< std::mt19937_64 >
CROOT::Math::StdEngineType< std::random_device >
CROOT::Math::StdEngineType< std::ranlux24 >
CROOT::Math::StdEngineType< std::ranlux48 >
CROOT::Math::StdRandomEngine
CROOT::Math::SVector< T, D >	SVector: a generic fixed size Vector class
CROOT::Minuit2::sym
CTComplex
CROOT::Math::TDataPoint< K, _val_type >
CROOT::Math::TDataPointN< _val_type >
CTElementActionT< Element >
CTElementPosActionT< Element >
CROOT::Math::TensorMulOp< Vector1, Vector2 >	Class for Tensor Multiplication (outer product) of two vectors giving a matrix
CROOT::Experimental::TFitResult
CROOT::Experimental::TFunction< DIMENSION >
CTLorentzRotation::TLorentzRotationRow
CTMatrixDEigen	TMatrixDEigen
CTMatrixDSymEigen	TMatrixDSymEigen
►CTMatrixTColumn_const< Element >
CTMatrixTColumn< Element >
►CTMatrixTDiag_const< Element >
CTMatrixTDiag< Element >
►CTMatrixTFlat_const< Element >
CTMatrixTFlat< Element >
►CTMatrixTRow_const< Element >
CTMatrixTRow< Element >
►CTMatrixTSparseDiag_const< Element >
CTMatrixTSparseDiag< Element >
►CTMatrixTSparseRow_const< Element >
CTMatrixTSparseRow< Element >
►CTMatrixTSub_const< Element >
CTMatrixTSub< Element >
►CTNamed
CTMinuit	Implementation in C++ of the Minuit package written by Fred James
CTMinuit2TraceObject
CTNeuron
►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
CTRandomGen< Engine >
►CTNLP
CROOT::Math::IpoptMinimizer::InternalTNLP	Internal class to create a TNLP object, required for Ipopt minimization in c++, every method is overloaded to pass the information to Ipopt solvers
►CTObject
►CTDecompBase	Decomposition Base class
CTDecompBK	The Bunch-Kaufman diagonal pivoting method decomposes a real symmetric matrix A using
CTDecompChol	Cholesky Decomposition class
CTDecompLU	LU Decomposition class
CTDecompQRH	QR Decomposition class
CTDecompSparse	Sparse Symmetric Decomposition class
CTDecompSVD	Single Value Decomposition class
CTFeldmanCousins	Class to calculate the CL upper limit using the Feldman-Cousins method as described in PRD V57 #7, p3873-3889
CTFoam
CTFoamCell
CTFoamIntegrand
CTFoamMaxwt
CTFoamVect
CTGenPhaseSpace	Utility class to generate n-body event, with constant cross-section (default) or with Fermi energy dependence (opt="Fermi")
CTKDTree< Index, Value >	Class implementing a kd-tree
CTKDTreeBinning	<- TKDTreeBinning - A class providing multidimensional binning ->
CTLorentzRotation	Describes Lorentz transformations including Lorentz boosts and rotations (see TRotation)
CTLorentzVector	TLorentzVector is a general four-vector class, which can be used either for the description of position and time (x,y,z,t) or momentum and energy (px,py,pz,E)
►CTMatrixTBase< Element >	Linear Algebra Package
CTMatrixT< Element >	TMatrixT
CTMatrixT< Double_t >
CTMatrixTSparse< Element >	TMatrixTSparse
CTMatrixTSparse< Double_t >
CTMatrixTSym< Element >	TMatrixTSym
CTMatrixTSym< Double_t >
►CTMatrixTLazy< Element >	Templates of Lazy Matrix classes
CTHaarMatrixT< Element >
CTHilbertMatrixT< Element >
►CTMatrixTSymLazy< Element >
CTHilbertMatrixTSym< Element >
CTMLPAnalyzer
CTMultiLayerPerceptron
►CTQpDataBase
CTQpDataDens
CTQpDataSparse
►CTQpLinSolverBase
CTQpLinSolverDens
CTQpLinSolverSparse
►CTQpProbBase
CTQpProbDens
CTQpProbSparse
CTQpResidual
►CTQpSolverBase
CTGondzioSolver
CTMehrotraSolver
CTQpVar
CTQuaternion	Quaternion is a 4-component mathematic object quite convenient when dealing with space rotation (or reference frame transformation)
CTRobustEstimator	Minimum Covariance Determinant Estimator - a Fast Algorithm invented by Peter J.Rousseeuw and Katrien Van Dreissen "A Fast Algorithm for the Minimum covariance Determinant Estimator" Technometrics, August 1999, Vol.41, NO.3
CTRolke	This class computes confidence intervals for the rate of a Poisson process in the presence of uncertain background and/or efficiency
CTRotation	Describes a rotation of objects of the TVector3 class
CTSPlot
CTStatistic	Statistical variable, defined by its mean and variance (RMS)
CTSynapse
CTVector2	TVector2 is a general two vector class, which can be used for the description of different vectors in 2D
CTVector3	TVector3 is a general three vector class, which can be used for the description of different vectors in 3D
CTVectorT< Element >	TVectorT
CTVectorT< Double_t >
►CROOT::Math::TRandomEngine
CROOT::Math::LCGEngine
CROOT::Math::MersenneTwisterEngine	Random number generator class based on M
CROOT::Math::MixMaxEngine< N, SkipNumber >	MixMaxEngine is a wrapper class for the MIXMAX Random number generator
CTRandom	This is the base class for the ROOT Random number generators
CTRandomEngine
CROOT::Math::Impl::Transform3D< T >	Basic 3D Transformation class describing a rotation and then a translation The internal data are a 3D rotation data (represented as a 3x3 matrix) and a 3D vector data
CROOT::Math::Impl::Translation3D< T >	Class describing a 3 dimensional translation
CROOT::Math::TransposeOp< Matrix, T, D1, D2 >	Class for Transpose Operations
CROOT::Math::TranspPolicy< T, D1, D2, R >	Matrix transpose policy
CROOT::Math::TranspPolicy< T, D1, D2, MatRepSym< T, D1 > >
CROOT::Math::Delaunay2D::Triangle
Ctriangulateio
CTRotation::TRotationRow
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
►CTVirtualFFT
CTFFTComplex
CTFFTComplexReal
CTFFTReal
CTFFTRealComplex
►CTVirtualFitter
CTFitter
CTFumili
CTLinearFitter	The Linear Fitter - For fitting functions that are LINEAR IN PARAMETERS
CROOT::Math::UnaryOp< Operator, RHS, T >	UnaryOperation class A class representing unary operators in the parse tree
CUnuranDistr< Function >	UnuranDistr Provides free function based on TF1 to be called by unuran
CUnuranDistrMulti< Function >	Free functions for multidimensional functions needed bby UNURAN
CUnuranRng< Random >	UnuranRng class for interface ROOT random generators to Unuran
CROOT::Minuit2::VariableMetricEDMEstimator
►CROOT::Math::Vavilov	Base class describing a Vavilov distribution
CROOT::Math::VavilovAccurate	Class describing a Vavilov distribution
CROOT::Math::VavilovFast	Class describing a Vavilov distribution
CROOT::Minuit2::vec
CROOT::Math::VecExpr< ExprType, T, D >	Expression wrapper class for Vector objects
CROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 >	Class for Vector-Matrix multiplication
CROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 >
CROOT::Minuit2::VectorOuterProduct< M, T >
CROOT::Math::VegasParameters	Structures collecting parameters for VEGAS multidimensional integration FOr implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
►CROOT::Math::VirtualIntegrator	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
►CROOT::Math::VirtualIntegratorMultiDim	Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator
CROOT::Math::AdaptiveIntegratorMultiDim	Class for adaptive quadrature integration in multi-dimensions using rectangular regions
CROOT::Math::GSLMCIntegrator
►CROOT::Math::VirtualIntegratorOneDim	Interface (abstract) class for 1D numerical integration It must be implemented by the concrate Integrator classes like ROOT::Math::GSLIntegrator
►CROOT::Math::GaussIntegrator	User class for performing function integration
CROOT::Math::GaussLegendreIntegrator	User class for performing function integration
CROOT::Math::GSLIntegrator	Class for performing numerical integration of a function in one dimension
►CFunctionType
CROOT::Math::BasicFitMethodFunction< FunctionType >	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)
►CIPFType
CROOT::Math::ParamFunction< IPFType >	Base template class for all Parametric Functions