Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, N, M >Struct to do a Cholesky decomposition
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 0, M >Struct to do a Cholesky decomposition (specialized, N = 0)
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 1, M >Struct to do a Cholesky decomposition (specialized, N = 1)
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 2, M >Struct to do a Cholesky decomposition (specialized, N = 2)
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 3, M >Struct to do a Cholesky decomposition (specialized, N = 3)
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 4, M >Struct to do a Cholesky decomposition (specialized, N = 4)
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 5, M >Struct to do a Cholesky decomposition (specialized, N = 5)
ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 6, M >Struct to do a Cholesky decomposition (specialized, N = 6)
ROOT::Math::CholeskyDecompHelpers::_inverter< F, N, M >Struct to obtain the inverse from a Cholesky decomposition
ROOT::Math::CholeskyDecompHelpers::_inverter< F, 0, M >Struct to obtain the inverse from a Cholesky decomposition (N = 0)
ROOT::Math::CholeskyDecompHelpers::_inverter< F, 1, M >Struct to obtain the inverse from a Cholesky decomposition (N = 1)
ROOT::Math::CholeskyDecompHelpers::_inverter< F, 2, M >Struct to obtain the inverse from a Cholesky decomposition (N = 2)
ROOT::Math::CholeskyDecompHelpers::_inverter< F, 3, M >Struct to obtain the inverse from a Cholesky decomposition (N = 3)
ROOT::Math::CholeskyDecompHelpers::_inverter< F, 4, M >Struct to obtain the inverse from a Cholesky decomposition (N = 4)
ROOT::Math::CholeskyDecompHelpers::_inverter< F, 5, M >Struct to obtain the inverse from a Cholesky decomposition (N = 5)
ROOT::Math::CholeskyDecompHelpers::_inverter< F, 6, M >Struct to obtain the inverse from a Cholesky decomposition (N = 6)
ROOT::Math::CholeskyDecompHelpers::_solver< F, N, V >Struct to solve a linear system using its Cholesky decomposition
ROOT::Math::CholeskyDecompHelpers::_solver< F, 0, V >Struct to solve a linear system using its Cholesky decomposition (N=0)
ROOT::Math::CholeskyDecompHelpers::_solver< F, 1, V >Struct to solve a linear system using its Cholesky decomposition (N=1)
ROOT::Math::CholeskyDecompHelpers::_solver< F, 2, V >Struct to solve a linear system using its Cholesky decomposition (N=2)
ROOT::Math::CholeskyDecompHelpers::_solver< F, 3, V >Struct to solve a linear system using its Cholesky decomposition (N=3)
ROOT::Math::CholeskyDecompHelpers::_solver< F, 4, V >Struct to solve a linear system using its Cholesky decomposition (N=4)
ROOT::Math::CholeskyDecompHelpers::_solver< F, 5, V >Struct to solve a linear system using its Cholesky decomposition (N=5)
ROOT::Math::CholeskyDecompHelpers::_solver< F, 6, V >Struct to solve a linear system using its Cholesky decomposition (N=6)
ROOT::Math::AdaptiveIntegratorMultiDimClass for adaptive quadrature integration in multi-dimensions Algorithm from A.C
ROOT::Math::AddOp< T >Addition Operation Class
ROOT::Math::AddPolicy< T, D1, D2, R1, R2 >Matrix addition policy
ROOT::Math::AddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > >
ROOT::Fit::AreaComparer
ROOT::Math::Assign< T, D1, D2, A, R1, R2 >Structure to assign from an expression based to general matrix to general matrix
ROOT::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
ROOT::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
ROOT::Math::AssignItr< T, D1, D2, R >Structure for assignment to a general matrix from iterator
ROOT::Math::AssignItr< T, D1, D2, MatRepSym< T, D1 > >Specialized structure for assignment to a symmetrix matrix from iterator
ROOT::Math::AssignSymForce Expression evaluation from general to symmetric
ROOT::Math::AxisAngleAxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis
ROOT::Math::BaseIntegratorOptionsBase class for Numerical integration options common in 1D and multi-dimension This is an internal class and is not supposed to be instantiated by the user
ROOT::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)
ROOT::Math::BinaryOp< Operator, LHS, RHS, T >BinaryOperation class A class representing binary operators in the parse tree
ROOT::Math::BinaryOpCopyL< Operator, LHS, RHS, T >Binary Operation class with value storage for the left argument
ROOT::Math::BinaryOpCopyR< Operator, LHS, RHS, T >Binary Operation class with value storage for the right argument
BinaryOpPolicy
ROOT::Fit::BinDataClass 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:
  • only coordinates and values (for binned likelihood fits) : kNoError
  • coordinate, values and error on values (for normal least square fits) : kValueError
  • coordinate, values, error on values and coordinates (for effective least square fits) : kCoordError
  • corrdinate, values, error on coordinates and asymmettric error on valyes : kAsymError
ROOT::Fit::BinPointObsolete class, no more in use
ROOT::Math::Roots::BisectionRoots::Bisection Bisection algorithm, simplest algorithm for bracketing the roots of a function, but slowest one
ROOT::Math::GenVector_detail::BitReproducible
ROOT::Math::GenVector_detail::BitReproducibleException
ROOT::Math::BoostLorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix
ROOT::Math::BoostXClass representing a Lorentz Boost along the X axis, by beta
ROOT::Math::BoostYClass representing a Lorentz Boost along the Y axis, by beta
ROOT::Math::BoostZClass representing a Lorentz Boost along the Z axis, by beta
ROOT::Fit::Box
ROOT::Fit::BoxContainer
ROOT::Math::Roots::BrentBrent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information
ROOT::Math::BrentMinimizer1DUser class for performing function minimization
ROOT::Math::BrentRootFinderClass for finding the root of a one dimensional function using the Brent algorithm
ROOT::Math::Cartesian2D< T >Class describing a 2D cartesian coordinate system (x, y coordinates)
ROOT::Math::Cartesian3D< T >Class describing a 3D cartesian coordinate system (x, y, z coordinates)
ROOT::Math::CDFWrapper
ROOT::Math::ChebyshevClass describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials
ROOT::Fit::Chi2FCN< FunType >Chi2FCN class for binnned fits using the least square methods
ROOT::Math::CholeskyDecomp< F, N >Class to compute the Cholesky decomposition of a matrix
ROOT::Math::CholInverter< idim >
CompareAsc< T >
CompareDesc< T >
TKDTreeBinning::CompareDesc
ROOT::Math::CompileTimeChecker< bool >
ROOT::Math::CompileTimeChecker< false >
ROOT::Math::Constant< T >Constant expression class A class representing constant expressions (literals) in the parse tree
ROOT::Math::Cylindrical3D< T >Class describing a cylindrical coordinate system based on rho, z and phi
ROOT::Math::CylindricalEta3D< T >Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z
ROOT::Fit::DataOptionsDataOptions : simple structure holding the options on how the data are filled
ROOT::Fit::DataRangeClass describing the range in the coordinates it supports multiple range in a coordinate
ROOT::Fit::DataVectorClass holding the fit data points
ROOT::Fit::DataWrapperClass maintaining a pointer to external data Using this class avoids copying the data when performing a fit NOTE: this class is not thread-safe and should not be used in parallel fits
ROOT::Math::DefaultCoordinateSystemTagDefaultCoordinateSystemTag Default tag for identifying any coordinate system
ROOT::Math::DerivatorClass for computing numerical derivative of a function
ROOT::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
ROOT::Math::DisplacementVector2D< CoordSystem, Tag >Class describing a generic displacement vector in 2 dimensions
ROOT::Math::DisplacementVector3D< CoordSystem, Tag >Class describing a generic displacement vector in 3 dimensions
ROOT::Math::DistSamplerInterface class for generic sampling of a distribution, i.e
ROOT::Math::DistSamplerOptionsDistSampler options class
ROOT::Math::DivOp< T >Division (element-wise) Operation Class
ROOT::Math::gv_detail::ERROR_This_Rotation_Conversion_is_NOT_Supported
ROOT::Math::EulerAnglesEulerAngles class describing rotation as three angles (Euler Angles)
ROOT::Math::EvaluatorOneDim< MultiFuncType >
ROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
ROOT::Math::Expr< ExprType, T, D, D2, R1 >
ROOT::Math::Fabs< T >Unary abs Operation Class
ROOT::Math::FactoryFactory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager
ROOT::Math::Roots::FalsePosFalse Position algorithm based on linear interpolation
ROOT::Math::FastInverter< idim, n >Fast Matrix Inverter class Class to specialize calls to Dinv
ROOT::Math::FastInverter< 3 >3x3 direct matrix inversion using Cramer Rule use only for FastInverter
ROOT::Math::FastInverter< 4 >4x4 matrix inversion using Cramers rule
ROOT::Math::FastInverter< 5 >5x5 Matrix inversion using Cramers rule
ROOT::Fit::FcnAdapter
ROOT::Fit::FitConfigClass describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class
ROOT::Fit::FitDataBase class for all the fit data types
ROOT::Fit::FitResultClass containg the result of the fit and all the related information (fitted parameter values, error, covariance matrix and minimizer result information) Contains a pointer also to the fitted (model) function, modified with the fit parameter values
ROOT::Fit::FitterFitter class, entry point for performing all type of fits
ROOT::Math::FitTransformFunction
ROOT::Math::FunctorDocumentation for class Functor class
ROOT::Math::Functor1DFunctor1D class for one-dimensional functions
ROOT::Math::FunctorCintHandler< ParentFunctor >
ROOT::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)
ROOT::Math::FunctorHandler< ParentFunctor, Func >Functor Handler class is responsible for wrapping any other functor and pointer to free C functions
FunType
ROOT::Math::GaussIntegratorUser class for performing function integration
ROOT::Math::GaussLegendreIntegratorUser class for performing function integration
ROOT::Math::GenAlgoOptionsClass implementing generic options for a numerical algorithm Just store the otions in a maps of string-value pair
ROOT::Math::GenVector_exception
ROOT::Math::GlobalCoordinateSystemTagTag for identifying vectors based on a global coordinate system
ROOT::Math::GoFTest
ROOT::Math::GradFunctorGradFunctor class for Multidimensional gradient functions
ROOT::Math::GradFunctor1DGradFunctor1D class for one-dimensional gradient functions
ROOT::Math::GSL1DMinimizerWrapperWrapper class for gsl_min_fminimizer structure
ROOT::Math::GSLChebSeriesWrapper class for C struct gsl_cheb_series
ROOT::Math::GSLDerivatorClass for computing numerical derivative of a function based on the GSL numerical algorithm This class is implemented using the numerical derivatives algorithms provided by GSL (see GSL Online Manual )
ROOT::Math::GSLFunctionAdapter< UserFunc >Class for adapting any C++ functor class to C function pointers used by GSL
ROOT::Math::GSLFunctionDerivWrapperClass to wrap a gsl_function_fdf (with derivatives)
ROOT::Math::GSLFunctionWrapperWrapper class to the gsl_function C structure
ROOT::Math::GSLIntegrationWorkspace
ROOT::Math::GSLIntegratorClass for performing numerical integration of a function in one dimension
ROOT::Math::GSLInterpolatorInterpolation class based on GSL interpolation functions
ROOT::Math::GSLMCIntegrationWorkspace
ROOT::Math::GSLMCIntegratorClass for performing numerical integration of a multidimensional function
ROOT::Math::GSLMinimizerGSLMinimizer class
ROOT::Math::GSLMinimizer1DMinimizer for arbitrary one dimensional functions
ROOT::Math::GSLMiserIntegrationWorkspaceWorkspace for MISER
ROOT::Math::GSLMonteFunctionAdapter< UserFunc >
ROOT::Math::GSLMonteFunctionWrapperWrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm
ROOT::Math::GSLMultiFitGSLMultiFit, internal class for implementing GSL non linear least square GSL fitting
ROOT::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:
ROOT::Math::GSLMultiFitFunctionWrapperWrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
ROOT::Math::GSLMultiMinDerivFunctionWrapperWrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm
ROOT::Math::GSLMultiMinFunctionAdapter< UserFunc >Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms
ROOT::Math::GSLMultiMinFunctionWrapperWrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
ROOT::Math::GSLMultiMinimizerGSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives
ROOT::Math::GSLNLSMinimizerGSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting
ROOT::Math::GSLPlainIntegrationWorkspace
ROOT::Math::GSLRandomEngineGSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator
ROOT::Math::GSLRngCMRGCombined multiple recursive generator (L'Ecuyer) see here
ROOT::Math::GSLRngGFSR4Lagged Fibonacci generator by Ziff see here
ROOT::Math::GSLRngMinStdMINSTD generator (Park and Miller) see here
ROOT::Math::GSLRngMRG5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here
ROOT::Math::GSLRngMTMersenne-Twister generator gsl_rng_mt19937 from here
ROOT::Math::GSLRngRandBSD rand() generator gsl_rmg_rand from here
ROOT::Math::GSLRngRanLuxOld Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here
ROOT::Math::GSLRngRanLuxD1Double 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
ROOT::Math::GSLRngRanLuxD2Double 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
ROOT::Math::GSLRngRanLuxS1Second generation of Ranlux generator for single precision with luxury level of 1 (It throws away 202 values for every 12 used) see here
ROOT::Math::GSLRngRanLuxS2Second generation of Ranlux generator for Single precision with luxury level of 2 (It throws away 397 value for every 12 used) see here
ROOT::Math::GSLRngRanMarRANMAR generator see here
ROOT::Math::GSLRngTausTausworthe generator by L'Ecuyer see here
ROOT::Math::GSLRngWrapperGSLRngWrapper class to wrap gsl_rng structure
ROOT::Math::GSLRootFdFSolverRoot-Finder with derivatives implementation class using GSL
ROOT::Math::GSLRootFinderBase class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives
ROOT::Math::GSLRootFinderDerivBase class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives
ROOT::Math::GSLRootFSolverRoot-Finder implementation class using GSL
ROOT::Math::GSLSimAnFuncGSLSimAnFunc class description
ROOT::Math::GSLSimAnMinimizerGSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL
ROOT::Math::GSLSimAnnealingGSLSimAnnealing class for performing a simulated annealing search of a multidimensional function
ROOT::Math::GSLSimAnParamsStructure holding the simulated annealing parameters
ROOT::Math::GSLVegasIntegrationWorkspaceWorkspace for VEGAS
HelperOps
ROOT::Math::IBaseFunctionMultiDimDocumentation for the abstract class IBaseFunctionMultiDim
ROOT::Math::IBaseFunctionOneDimInterface (abstract class) for generic functions objects of one-dimension Provides a method to evaluate the function given a value (simple double) by implementing operator() (const double )
ROOT::Math::IBaseParamDocumentation for the abstract class IBaseParam
ROOT::Math::IGradientFunctionMultiDimInterface (abstract class) for multi-dimensional functions providing a gradient calculation
ROOT::Math::IGradientFunctionOneDimInterface (abstract class) for one-dimensional functions providing a gradient calculation
ROOT::Math::IGradientMultiDimGradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function
ROOT::Math::IGradientOneDimSpecialized Gradient interface(abstract class) for one dimensional functions It provides a method to evaluate the derivative of the function, Derivative and a method to evaluate at the same time the function and the derivative FdF
ROOT::Math::IMinimizer1DInterface class for numerical methods for one-dimensional minimization
ROOT::Fit::FitUtil::IntegralEvaluator< ParamFunc >
ROOT::Math::IntegrandTransformAuxillary inner class for mapping infinite and semi-infinite integrals
ROOT::Math::IntegratorMultiDimUser class for performing multidimensional integration
ROOT::Math::IntegratorMultiDimOptionsNumerical multi dimensional integration options
ROOT::Math::IntegratorOneDimUser Class for performing numerical integration of a function in one dimension
ROOT::Math::IntegratorOneDimOptionsNumerical one dimensional integration options
ROOT::Math::InterpolatorClass for performing function interpolation of points
ROOT::Math::Inverter< idim, n >Matrix Inverter class Class to specialize calls to Dinv
ROOT::Math::Inverter< 0 >Inverter<0>
ROOT::Math::Inverter< 1 >1x1 matrix inversion $a_{11} \to 1/a_{11}$
ROOT::Math::Inverter< 2 >2x2 matrix inversion using Cramers rule
ROOT::Math::IOptionsGeneric interface for defining configuration options of a numerical algorithm
ROOT::Math::IParametricFunctionMultiDimIParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam
ROOT::Math::IParametricFunctionOneDimSpecialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam
ROOT::Math::IParametricGradFunctionMultiDimInterface (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
ROOT::Math::IParametricGradFunctionOneDimInterface (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
ROOT::Math::IRootFinderMethodInterface for finding function roots of one-dimensional functions
ROOT::Math::KelvinFunctions
ROOT::Math::LocalCoordinateSystemTagTag for identifying vectors based on a local coordinate system
ROOT::Fit::LogLikelihoodFCN< FunType >LogLikelihoodFCN class for likelihood fits
ROOT::Math::LorentzRotationLorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix
ROOT::Math::LorentzVector< CoordSystem >Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part
ROOT::Math::LSResidualFuncLSResidualFunc class description
ROOT::Math::detail::manipulator< char_t >
ROOT::Math::MatRepStd< T, D1, D2 >MatRepStd Standard Matrix representation for a general D1 x D2 matrix
ROOT::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
ROOT::Math::MatrixMulOp< MatrixA, MatrixB, T, D >Class for Matrix-Matrix multiplication
ROOT::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
ROOT::Math::MemGradFunHandler< ParentFunctor, PointerToObj, PointerToMemFn, PointerToGradMemFn >Functor Handler to Wrap pointers to member functions for the evaluation of the function and the gradient
ROOT::Math::meta_col_dot< I >
ROOT::Math::meta_col_dot< 0 >
ROOT::Math::meta_dot< I >
ROOT::Math::meta_dot< 0 >
ROOT::Math::meta_mag< I >
ROOT::Math::meta_mag< 0 >
ROOT::Math::meta_matrix_dot< I >
ROOT::Math::meta_matrix_dot< 0 >
ROOT::Math::meta_row_dot< I >
ROOT::Math::meta_row_dot< 0 >
ROOT::Math::MinimizerAbstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc
ROOT::Math::MinimizerOptionsMinimizer options
ROOT::Math::MinimizerVariableMinimizerVariable class to perform a transformations on the variables to deal with fixed or limited variables
ROOT::Math::MinimizerVariableTransformationBase class for MinimizerVariable transformations defining the functions to deal with bounded parameters
ROOT::Math::MinimTransformFunctionMinimTransformFunction 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
ROOT::Math::MinOp< T >Subtraction Operation Class
ROOT::Math::Minus< T >Unary Minus Operation Class
ROOT::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 )
ROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Specialization for symmetrix -= general : NOT Allowed operation
ROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >Specialization for symmetric matrices
ROOT::Math::MiserParametersStructures collecting parameters for MISER multidimensional integration
ROOT::Fit::ModelFunctionTrait< FunType >
ROOT::Fit::ModelFunctionTrait< ROOT::Math::IMultiGradFunction >
ROOT::Math::MulOp< T >Multiplication (element-wise) Operation Class
ROOT::Math::MultiDimParamFunctionAdapterMultiDimParamFunctionAdapter 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
ROOT::Math::MultiDimParamGradFunctionAdapterMultiDimParamGradFunctionAdapter 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
ROOT::Math::MultiNumGradFunctionMultiNumGradFunction class to wrap a normal function in a gradient function using numerical gradient calculation provided by the class Derivator (based on GSL numerical derivation)
ROOT::Math::MultPolicy< T, R1, R2 >Matrix-matrix multiplication policy
ROOT::Math::Roots::NewtonNewton algorithm, which computes the derivative at each iteration See the GSL manual for more information
ROOT::Math::NullTypeFunc1D
ROOT::Fit::ObjFuncTrait< Func >
ROOT::Fit::ObjFuncTrait< ROOT::Math::FitMethodFunction >
ROOT::Fit::ObjFuncTrait< ROOT::Math::FitMethodGradFunction >
ROOT::Math::OneDimMultiFunctionAdapter< MultiFuncType >OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one
ROOT::Math::OneDimParamFunctionAdapter< ParamFuncType >OneDimParamFunctionAdapter class to wrap a multi-dim parameteric function in one dimensional one
ROOT::Math::IntegOptionsUtil::OptionTrait< OptionType >
ROOT::Math::IntegOptionsUtil::OptionTrait< IntegratorMultiDimOptions >
ROOT::Math::IntegOptionsUtil::OptionTrait< IntegratorOneDimOptions >
ROOT::Fit::FitUtil::ParamDerivFunc< GradFunc >
ROOT::Fit::ParameterSettingsClass, describing value, limits and step size of the parameters Provides functionality also to set/retrieve values, step sizes, limits and fix the parameters
ROOT::Math::ParamFunction< IPFType >Base template class for all Parametric Functions
ROOT::Math::ParamFunctionBaseClass defining the signature for multi-dim parametric functions
ROOT::Math::ParamFunctorParam Functor class for Multidimensional functions
ROOT::Math::ParamFunctorHandler< ParentFunctor, Func >ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions
ROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >ParamFunctor Handler to Wrap pointers to member functions
ROOT::Math::PDFIntegral
ROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, R1, R2 >
ROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
ROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
ROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, R1, R2 >Structure to deal when a submatrix is placed in a matrix
ROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
ROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
ROOT::Math::PlainParameters
ROOT::Math::Plane3DClass describing a geometrical plane in 3 dimensions
ROOT::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 )
ROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Specialization for symmetrix += general : NOT Allowed operation
ROOT::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 )
ROOT::Fit::PoissonLikelihoodFCN< FunType >Class evaluating the log likelihood for binned Poisson likelihood fits it is template to distinguish gradient and non-gradient case
ROOT::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)
ROOT::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)
ROOT::Math::PolynomialParametric Function class describing polynomials of order n
ROOT::Math::PositionVector2D< CoordSystem, Tag >Class describing a generic position vector (point) in 2 dimensions
ROOT::Math::PositionVector3D< CoordSystem, Tag >Class describing a generic position vector (point) in 3 dimensions
ROOT::Fit::ProxyListBox
ROOT::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 (-,-,-,+)
ROOT::Math::PtEtaPhiM4D< ScalarType >Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+)
ROOT::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)
ROOT::Math::PxPyPzM4D< ScalarType >Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M)
ROOT::Math::QuaternionRotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k)
ROOT::Math::Random< Engine >User class for MathMore random numbers template on the Engine type
ROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, R1, R2 >Structure for getting sub matrices We have different cases according to the matrix representations
ROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
ROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
ROOT::Math::RichardsonDerivatorUser class for calculating the derivatives of a function
ROOT::Math::RootFinderUser Class to find the Root of one dimensional functions
ROOT::Math::Rotation3DRotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
ROOT::Math::RotationXRotation class representing a 3D rotation about the X axis by the angle of rotation
ROOT::Math::RotationYRotation class representing a 3D rotation about the Y axis by the angle of rotation
ROOT::Math::RotationZRotation class representing a 3D rotation about the Z axis by the angle of rotation
ROOT::Math::RotationZYXRotation class with the (3D) rotation represented by angles describing first a rotation of an angle phi (yaw) about the Z axis, followed by a rotation of an angle theta (pitch) about the new Y' axis, followed by a third rotation of an angle psi (roll) about the final X'' axis
ROOT::Math::RowOffsets< D >Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix
ROOT::Math::RowOffsets< 1 >
ROOT::Math::RowOffsets< 10 >
ROOT::Math::RowOffsets< 2 >
ROOT::Math::RowOffsets< 3 >
ROOT::Math::RowOffsets< 4 >
ROOT::Math::RowOffsets< 5 >
ROOT::Math::RowOffsets< 6 >
ROOT::Math::RowOffsets< 7 >
ROOT::Math::RowOffsets< 8 >
ROOT::Math::RowOffsets< 9 >
ROOT::Math::SDeterminant< n, idim >Dsfact
ROOT::Math::Roots::SecantSecant algorithm, simplified version of Newton method, which does not require the derivative at every step
ROOT::Fit::FitUtil::SimpleGradientCalculator
ROOT::Math::SinVariableTransformationSin Transformation class for dealing with double bounded variables
ROOT::Math::SInverter< T, n, idim >Dsinv
ROOT::Math::SMatrix< T, D1, D2, R >SMatrix: a generic fixed size D1 x D2 Matrix class
ROOT::Math::SMatrixIdentity
ROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow
ROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const
ROOT::Fit::SparseData
ROOT::Math::Sqr< T >Unary Square Operation Class
ROOT::Math::Sqrt< T >Unary Square Root Operation Class
ROOT::Math::SqrtLowVariableTransformationSqrt Transformation class for dealing with lower bounded variables
ROOT::Math::SqrtUpVariableTransformationSqrt Transformation class for dealing with upper bounded variables
ROOT::Math::Roots::SteffensonSteffenson method, providing the fastes convergence
ROOT::Math::SVector< T, D >SVector: a generic fixed size Vector class
TComplex
ROOT::Math::TensorMulOp< Vector1, Vector2 >Class for Tensor Multiplication (outer product) of two vectors giving a matrix
TKDTree< Index, Value >
TKDTreeBinning
TRandom
TRandom1
TRandom2
TRandom3
ROOT::Math::Transform3DBasic 3D Transformation class describing a rotation and then a translation The internal data are a 3D rotation data (represented as a 3x3 matrix) and a 3D vector data
ROOT::Math::Translation3DClass describing a 3 dimensional translation
ROOT::Math::TransposeOp< Matrix, T, D1, D2 >Class for Transpose Operations
ROOT::Math::TranspPolicy< T, D1, D2, R >Matrix transpose policy
ROOT::Math::TranspPolicy< T, D1, D2, MatRepSym< T, D1 > >
TVirtualFitter
ROOT::Math::UnaryOp< Operator, RHS, T >UnaryOperation class A class representing unary operators in the parse tree
ROOT::Fit::UnBinDataClass describing the unbinned data sets (just x coordinates values) of any dimensions
ROOT::Math::VavilovBase class describing a Vavilov distribution
ROOT::Math::VavilovAccurateClass describing a Vavilov distribution
ROOT::Math::VavilovAccurateCdfClass describing the Vavilov cdf
ROOT::Math::VavilovAccuratePdfClass describing the Vavilov pdf
ROOT::Math::VavilovAccurateQuantileClass describing the Vavilov quantile function
ROOT::Math::VavilovFastClass describing a Vavilov distribution
ROOT::Math::VecExpr< ExprType, T, D >Expression wrapper class for Vector objects
ROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 >Class for Vector-Matrix multiplication
ROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 >
ROOT::Math::VegasParametersStructures collecting parameters for VEGAS multidimensional integration FOr implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
ROOT::Math::VirtualIntegratorAbstract class for all numerical integration methods (1D and multi-dim) Interface defining the common methods for the numerical integrator classes of one and multi dimensions The derived class VirtualIntegratorOneDim defines the methods for one-dimensional integration
ROOT::Math::VirtualIntegratorMultiDimInterface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator
ROOT::Math::VirtualIntegratorOneDimInterface (abstract) class for 1D numerical integration It must be implemented by the concrate Integrator classes like ROOT::Math::GSLIntegrator
ROOT::Math::WrappedFunction< Func >Template class to wrap any C++ callable object which takes one argument i.e
ROOT::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;
ROOT::Math::WrappedMemMultiFunction< FuncObj, MemFuncPtr >
ROOT::Math::WrappedMultiFunction< Func >Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface
ROOT::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
ROOT::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
Generated on Thu Dec 16 21:08:14 2010 for ROOT Mathematical Libraries by  doxygen 1.5.9