| ROOT::Minuit2::ABObj< mtype, M, T > | |
| ROOT::Minuit2::ABObj< sym, LASymMatrix, double > | |
| ROOT::Minuit2::ABObj< vec, LAVector, double > | |
| ROOT::Minuit2::ABProd< M1, M2 > | |
| ROOT::Minuit2::ABSum< M1, M2 > | |
| ROOT::Math::AdaptiveIntegratorMultiDim | Class 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::Minuit2::AlgebraicProdType< A, B > | |
| ROOT::Minuit2::AlgebraicProdType< gen, gen > | |
| ROOT::Minuit2::AlgebraicProdType< gen, sym > | |
| ROOT::Minuit2::AlgebraicProdType< gen, vec > | |
| ROOT::Minuit2::AlgebraicProdType< sym, gen > | |
| ROOT::Minuit2::AlgebraicProdType< sym, sym > | |
| ROOT::Minuit2::AlgebraicProdType< sym, vec > | |
| ROOT::Minuit2::AlgebraicProdType< T, T > | |
| ROOT::Minuit2::AlgebraicProdType< vec, gen > | |
| ROOT::Minuit2::AlgebraicProdType< vec, sym > | |
| ROOT::Minuit2::AlgebraicSumType< A, B > | |
| ROOT::Minuit2::AlgebraicSumType< gen, vec > | |
| ROOT::Minuit2::AlgebraicSumType< sym, vec > | |
| ROOT::Minuit2::AlgebraicSumType< T, T > | |
| ROOT::Minuit2::AlgebraicSumType< vec, gen > | |
| ROOT::Minuit2::AlgebraicSumType< vec, sym > | |
| ROOT::Minuit2::AnalyticalGradientCalculator | |
| 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::AssignSym | Force Expression evaluation from general to symmetric |
| ROOT::Math::AxisAngle | AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis |
| 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::Minuit2::BasicFunctionGradient | |
| ROOT::Minuit2::BasicFunctionMinimum | Result of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum |
| ROOT::Minuit2::BasicFunctionMinimum::MnAboveMaxEdm | |
| ROOT::Minuit2::BasicFunctionMinimum::MnReachedCallLimit | |
| ROOT::Minuit2::BasicMinimumError | Internal Class containing the error information on the estimated minimum : Error matrix + dcovar + additional flags for quality and validity checks |
| ROOT::Minuit2::BasicMinimumError::MnHesseFailed | |
| ROOT::Minuit2::BasicMinimumError::MnInvertFailed | |
| ROOT::Minuit2::BasicMinimumError::MnMadePosDef | |
| ROOT::Minuit2::BasicMinimumError::MnNotPosDef | |
| ROOT::Minuit2::BasicMinimumParameters | |
| ROOT::Minuit2::BasicMinimumSeed | |
| ROOT::Minuit2::BasicMinimumState | |
| 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 | - Author:
- Juan PALACIOS
|
| ROOT::Math::Roots::Bisection | Roots::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::Boost | Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix |
| ROOT::Math::BoostX | Class representing a Lorentz Boost along the X axis, by beta |
| ROOT::Math::BoostY | Class representing a Lorentz Boost along the Y axis, by beta |
| ROOT::Math::BoostZ | Class representing a Lorentz Boost along the Z axis, by beta |
| ROOT::Math::Roots::Brent | Brent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information |
| 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::Chebyshev | Class describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials |
| ROOT::Minuit2::CombinedMinimizer | Combined minimizer: combination of Migrad and Simplex |
| ROOT::Minuit2::CombinedMinimumBuilder | |
| ROOT::Math::CompileTimeError< true > | |
| ROOT::Math::Constant< T > | Constant expression class A class representing constant expressions (literals) in the parse tree |
| ROOT::Minuit2::ContoursError | |
| 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::Minuit2::DavidonErrorUpdator | Update of the covariance matrix for the Variable Metric minimizer (MIGRAD) |
| ROOT::Math::DefaultCoordinateSystemTag | DefaultCoordinateSystemTag Default tag for identifying any coordinate system |
| ROOT::Math::Derivator | Class 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 ( ) 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::DivOp< T > | Division (element-wise) Operation Class |
| ROOT::Math::EulerAngles | EulerAngles class describing rotation as three angles (Euler Angles) |
| ROOT::Math::Expr< ExprType, T, D, D2, R1 > | |
| ROOT::Math::Fabs< T > | Unary abs Operation Class |
| ROOT::Math::Factory | Factory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager |
| ROOT::Math::Roots::FalsePos | False Position algorithm based on linear interpolation |
| ROOT::Minuit2::FCNAdapter< Function > | Template wrapped class for adapting to FCNBase signature |
| ROOT::Minuit2::FCNBase | Interface (abstract class) defining the function to be minimized, which has to be implemented by the user |
| ROOT::Minuit2::FCNGradAdapter< Function > | Template wrapped class for adapting to FCNBase signature a IGradFunction |
| ROOT::Minuit2::FCNGradientBase | Extension of the FCNBase for providing the analytical Gradient of the function |
| ROOT::Minuit2::FumiliBuilder | Builds the FunctionMinimum using the Fumili method |
| ROOT::Minuit2::FumiliChi2FCN | Extension of the FCNBase for the Fumili method |
| ROOT::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 |
| ROOT::Minuit2::FumiliFCNAdapter< Function > | Template wrapped class for adapting to FumiliFCNBase signature |
| ROOT::Minuit2::FumiliFCNBase | Extension of the FCNBase for the Fumili method |
| ROOT::Minuit2::FumiliGradientCalculator | |
| ROOT::Minuit2::FumiliMaximumLikelihoodFCN | Extension of the FCNBase for the Fumili method |
| ROOT::Minuit2::FumiliMinimizer | Instantiates the seed generator and Minimum builder for the Fumili minimization method |
| ROOT::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 |
| ROOT::Minuit2::FumiliStandardMaximumLikelihoodFCN | Class implementing the Elements member function for the standard maximum likelihood method |
| ROOT::Minuit2::FunctionGradient | |
| ROOT::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 |
| ROOT::Minuit2::FunctionMinimum | Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum |
| ROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm | |
| ROOT::Minuit2::FunctionMinimum::MnReachedCallLimit | |
| ROOT::Math::Functor | Documentation for class Functor class |
| ROOT::Math::Functor1D | Functor1D 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 |
| ROOT::Minuit2::gen | |
| ROOT::Minuit2::GenericFunction | Class from which all the other classes, representing functions, inherit |
| ROOT::Math::GenVector_exception | |
| ROOT::Math::GlobalCoordinateSystemTag | Tag for identifying vectors based on a global coordinate system |
| ROOT::Math::GradFunctor | GradFunctor class for Multidimensional gradient functions |
| ROOT::Math::GradFunctor1D | GradFunctor1D class for one-dimensional gradient functions |
| ROOT::Minuit2::GradientCalculator | Interface class for gradient calculators |
| ROOT::Math::GSL1DMinimizer | Wrapper class for gsl_min_fminimizer structure |
| ROOT::Math::GSLChebSeries | Wrapper class for C struct gsl_cheb_series |
| ROOT::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 ) |
| ROOT::Math::GSLFunctionAdapter< UserFunc > | Class for adapting any C++ functor class to C function pointers used by GSL |
| ROOT::Math::GSLFunctionDerivWrapper | Class to wrap a gsl_function_fdf (with derivatives) |
| ROOT::Math::GSLFunctionWrapper | Wrapper class to the gsl_function C structure |
| ROOT::Math::GSLIntegrationWorkspace | |
| ROOT::Math::GSLIntegrator | Class for performing numerical integration of a function in one dimension |
| ROOT::Math::GSLInterpolator | Interpolation class based on GSL interpolation functions |
| ROOT::Math::GSLMCIntegrationWorkspace | |
| ROOT::Math::GSLMCIntegrator | Class for performing numerical integration of a multidimensional function |
| ROOT::Math::GSLMinimizer | GSLMinimizer class |
| ROOT::Math::GSLMiserIntegrationWorkspace | |
| ROOT::Math::GSLMonteFunctionAdapter< UserFunc > | |
| ROOT::Math::GSLMonteFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm |
| ROOT::Math::GSLMultiFit | GSLMultiFit, internal class for implementing GSL non linear least square GSL fitting |
| ROOT::Math::GSLMultiFitFunctionAdapter< FuncIterator > | 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::GSLMultiFitFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm |
| ROOT::Math::GSLMultiMinDerivFunctionWrapper | Wrapper for a multi-dimensional funciton 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::GSLMultiMinFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm |
| ROOT::Math::GSLMultiMinimizer | GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives |
| ROOT::Math::GSLNLSMinimizer | GSLNLSMinimizer 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::GSLRandomEngine | GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator |
| ROOT::Math::GSLRngCMRG | Combined multiple recursive generator (L'Ecuyer) see here |
| ROOT::Math::GSLRngGFSR4 | Lagged Fibonacci generator by Ziff see here |
| ROOT::Math::GSLRngMinStd | MINSTD generator (Park and Miller) see here |
| ROOT::Math::GSLRngMRG | 5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here |
| ROOT::Math::GSLRngMT | Mersenne-Twister generator gsl_rng_mt19937 from here |
| ROOT::Math::GSLRngRand | BSD rand() generator gsl_rmg_rand from here |
| ROOT::Math::GSLRngRanLux | Ranlux generator (James, Luscher) (defaul luxury) see here |
| ROOT::Math::GSLRngRanLux2 | Second generation of Ranlux generator (with luxury level of 2) see here |
| ROOT::Math::GSLRngRanLux48 | 48 bits version of Second generation of Ranlux generator (with luxury level of 2) see here |
| ROOT::Math::GSLRngRanMar | RANMAR generator see here |
| ROOT::Math::GSLRngTaus | Tausworthe generator by L'Ecuyer see here |
| ROOT::Math::GSLRngWrapper | GSLRngWrapper class to wrap gsl_rng structure |
| ROOT::Math::GSLRootFdFSolver | Root-Finder with derivatives implementation class using GSL |
| ROOT::Math::GSLRootFinder | Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives |
| ROOT::Math::GSLRootFinderDeriv | Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives |
| ROOT::Math::GSLRootFSolver | Root-Finder implementation class using GSL |
| ROOT::Math::GSLSimAnFunc | GSLSimAnFunc class description |
| ROOT::Math::GSLSimAnMinimizer | GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL |
| ROOT::Math::GSLSimAnnealing | GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function |
| ROOT::Math::GSLSimAnParams | Structure holding the simulated annealing parameters |
| ROOT::Math::GSLVegasIntegrationWorkspace | |
| HelperOps | - Author:
- Juan PALACIOS
|
| ROOT::Minuit2::HessianGradientCalculator | HessianGradientCalculator: class to calculate Gradient for Hessian |
| ROOT::Math::IBaseFunctionMultiDim | Documentation for the abstract class IBaseFunctionMultiDim |
| ROOT::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 ) |
| ROOT::Math::IBaseParam | Documentation for the abstract class IBaseParam |
| ROOT::Math::IGradientFunctionMultiDim | Interface (abstract class) for multi-dimensional functions providing a gradient calculation |
| ROOT::Math::IGradientFunctionOneDim | Interface (abstract class) for one-dimensional functions providing a gradient calculation |
| ROOT::Math::IGradientMultiDim | Gradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function |
| ROOT::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 |
| ROOT::Minuit2::InitialGradientCalculator | Class to calculate an initial estimate of the gradient |
| ROOT::Math::IntegratorMultiDim | User class for performing multidimensional integration |
| ROOT::Math::IntegratorOneDim | User Class for performing numerical integration of a function in one dimension |
| ROOT::Math::Interpolator | Class for performing function interpolation of points |
| ROOT::Math::Inverter< idim, n > | Matrix Inverter class (generic class used for matrix sizes larger than 6x6) Class to specialize calls to Dinv |
| ROOT::Math::Inverter< 0 > | Inverter<0> |
| ROOT::Math::Inverter< 1 > | 1x1 matrix inversion  |
| ROOT::Math::Inverter< 2 > | 2x2 matrix inversion using Cramers rule |
| ROOT::Math::Inverter< 3 > | 3x3 direct matrix inversion |
| ROOT::Math::Inverter< 4 > | 4x4 matrix inversion using Cramers rule |
| ROOT::Math::Inverter< 5 > | 5x5 Matrix inversion using Cramers rule |
| ROOT::Math::IParametricFunctionMultiDim | IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam |
| ROOT::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 |
| ROOT::Math::IParametricGradFunctionMultiDim | Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition to function evaluation and gradient with respect the coordinates also the gradient with respect to the parameters, via the method ParameterGradient |
| ROOT::Math::IParametricGradFunctionOneDim | Interface (abstract class) for parametric one-dimensional gradient functions providing in addition to function evaluation and derivative with respect the coordinates also the gradient with respect to the parameters, via the method ParameterGradient |
| ROOT::Math::KelvinFunctions | |
| ROOT::Minuit2::LASymMatrix | Class describing a symmetric matrix of size n |
| ROOT::Minuit2::LAVector | |
| ROOT::Math::LocalCoordinateSystemTag | Tag for identifying vectors based on a local coordinate system |
| ROOT::Math::LorentzRotation | Lorentz 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::LSResidualFunc | LSResidualFunc 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::Minuit2::MatrixInverse< mtype, M, T > | |
| ROOT::Minuit2::MatrixInverse< vec, M, T > | |
| 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::Minimizer | Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc |
| ROOT::Math::Minimizer1D | Minimizer for arbitrary one dimensional functions |
| ROOT::Minuit2::MinimumBuilder | |
| ROOT::Minuit2::MinimumError | MinimumError keeps the inv |
| ROOT::Minuit2::MinimumError::MnHesseFailed | |
| ROOT::Minuit2::MinimumError::MnInvertFailed | |
| ROOT::Minuit2::MinimumError::MnMadePosDef | |
| ROOT::Minuit2::MinimumError::MnNotPosDef | |
| ROOT::Minuit2::MinimumErrorUpdator | |
| ROOT::Minuit2::MinimumParameters | |
| ROOT::Minuit2::MinimumSeed | MinimumSeed contains the starting values for the minimization produced by the SeedGenerator |
| ROOT::Minuit2::MinimumSeedGenerator | Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization; |
| ROOT::Minuit2::MinimumState | MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder) |
| ROOT::Math::MinOp< T > | Subtraction Operation Class |
| ROOT::Minuit2::MinosError | Class holding the result of Minos (lower and upper values) for a specific parameter |
| ROOT::Minuit2::Minuit2Minimizer | Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm |
| ROOT::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; |
| 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::MiserParameters | Structures collecting parameters for MISER multidimensional integration |
| ROOT::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 |
| ROOT::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; |
| ROOT::Minuit2::MnCovarianceSqueeze | Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index |
| ROOT::Minuit2::MnCross | |
| ROOT::Minuit2::MnCross::CrossFcnLimit | |
| ROOT::Minuit2::MnCross::CrossNewMin | |
| ROOT::Minuit2::MnCross::CrossParLimit | |
| ROOT::Minuit2::MnEigen | API class for calculating the eigenvalues of symmetric matrix |
| ROOT::Minuit2::MnFcn | Wrapper class to FCNBase interface used internally by Minuit |
| ROOT::Minuit2::MnFumiliMinimize | API class for minimization using Fumili technology; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc |
| ROOT::Minuit2::MnFunctionCross | MnFunctionCross |
| ROOT::Minuit2::MnGlobalCorrelationCoeff | Class for global correlation coefficient |
| ROOT::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 |
| ROOT::Minuit2::MnLineSearch | Implements a 1-dimensional minimization along a given direction (i.e |
| ROOT::Minuit2::MnMachinePrecision | Determines the relative floating point arithmetic precision |
| ROOT::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 |
| ROOT::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 |
| ROOT::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; |
| ROOT::Minuit2::MnParabola | This class defines a parabola of the form a*x*x + b*x + c |
| ROOT::Minuit2::MnParabolaFactory | |
| ROOT::Minuit2::MnParabolaPoint | A point of a parabola |
| ROOT::Minuit2::MnParameterScan | Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found |
| ROOT::Minuit2::MnParStr | |
| ROOT::Minuit2::MnPlot | MnPlot produces a text-screen graphical output of (x,y) points, e.g |
| ROOT::Minuit2::MnPosDef | Force the covariance matrix to be positive defined by adding extra terms in the diagonal |
| ROOT::Minuit2::MnRefCountedPointer< T > | |
| ROOT::Minuit2::MnReferenceCounter | |
| ROOT::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 |
| ROOT::Minuit2::MnSeedGenerator | Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer; |
| ROOT::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 |
| ROOT::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) |
| ROOT::Minuit2::MnTiny | |
| ROOT::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 |
| ROOT::Minuit2::MnUserFcn | Wrapper used by Minuit of FCN interface containing a reference to the transformation object |
| ROOT::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 |
| ROOT::Minuit2::MnUserParameterState | Class which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand; |
| ROOT::Minuit2::MnUserTransformation | Knows how to transform between user specified parameters (external) and internal parameters used for minimization |
| ROOT::Minuit2::MnVectorTransform | |
| ROOT::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 |
| ROOT::Math::MulOp< T > | Multiplication (element-wise) Operation Class |
| ROOT::Math::MultiNumGradFunction | NumGradMultiFunction class to wrap a normal function in a gradient function using numerical gradient calculation |
| ROOT::Math::MultPolicy< T, R1, R2 > | Matrix-matrix multiplication policy |
| ROOT::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 |
| ROOT::Math::Roots::Newton | Newton algorithm, which computes the derivative at each iteration See the GSL manual for more information |
| ROOT::Math::NullTypeFunc1D | |
| ROOT::Minuit2::Numerical2PGradientCalculator | Class performing the numerical gradient calculation |
| 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::Minuit2::ParametricFunction | Function which has parameters |
| ROOT::Math::ParamFunction | Base class for 1 Dimensional Parametric Functions |
| 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::Plane3D | Class 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::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::Polynomial | Parametric 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::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::Quaternion | Rotation 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::RootFinder< SolverClass > | Class to find the Root of one dimensional functions |
| ROOT::Math::Rotation3D | Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix |
| ROOT::Math::RotationX | Rotation class representing a 3D rotation about the X axis by the angle of rotation |
| ROOT::Math::RotationY | Rotation class representing a 3D rotation about the Y axis by the angle of rotation |
| ROOT::Math::RotationZ | Rotation class representing a 3D rotation about the Z axis by the angle of rotation |
| ROOT::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 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::Minuit2::ScanBuilder | Performs a minimization using the simplex method of Nelder and Mead (ref |
| ROOT::Minuit2::ScanMinimizer | Class implementing the required methods for a minimization using SCAN API is provided in the upper ROOT::Minuit2::ModularFunctionMinimizer class |
| ROOT::Math::SDeterminant< n, idim > | Dsfact |
| ROOT::Math::Roots::Secant | Secant algorithm, simplified version of Newton method, which does not require the derivative at every step |
| ROOT::Minuit2::SimplexBuilder | Performs a minimization using the simplex method of Nelder and Mead (ref |
| ROOT::Minuit2::SimplexMinimizer | Class implementing the required methods for a minimization using Simplex |
| ROOT::Minuit2::SimplexParameters | Class describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process |
| ROOT::Minuit2::SimplexSeedGenerator | Generate Simplex starting point (state) |
| ROOT::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 |
| 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::Sqr< T > | Unary Square Operation Class |
| ROOT::Math::Sqrt< T > | Unary Square Root Operation Class |
| ROOT::Minuit2::SqrtLowParameterTransformation | Transformation from external to internal Parameter based on sqrt(1 + x**2) |
| ROOT::Minuit2::SqrtUpParameterTransformation | Transformation from external to internal Parameter based on sqrt(1 + x**2) |
| ROOT::Minuit2::StackAllocator | StackAllocator controls the memory allocation/deallocation of Minuit |
| ROOT::Minuit2::StackAllocatorHolder | |
| ROOT::Minuit2::StackError | |
| ROOT::Minuit2::StackOverflow | Define stack allocator symbol |
| ROOT::Math::Roots::Steffenson | Steffenson method, providing the fastes convergence |
| ROOT::Math::SVector< T, D > | SVector: a generic fixed size Vector class |
| ROOT::Minuit2::sym | |
| TBinLikelihoodFCN | Class implementing the standard Chi2 objective function |
| TChi2ExtendedFCN | Extended Chi2 Fit method |
| TChi2ExtendedFitData | Class holding the data of the fit |
| TChi2FCN | Class implementing the standard Chi2 objective function |
| TChi2FitData | Class holding the data of the fit |
| ROOT::Math::TensorMulOp< Vector1, Vector2 > | Class for Tensor Multiplication (outer product) of two vectors giving a matrix |
| TFcnAdapter | |
| TFitterFumili | TVirtualFitter implementation for new Fumili |
| TFitterMinuit | |
| TFumiliBinLikelihoodFCN | Fumili interface for binned (Poisson) likelihood functions |
| TFumiliChi2FCN | |
| TFumiliFCN | Base Class for implementing Fumili interface |
| TFumiliUnbinLikelihoodFCN | Fumili interface for Unbinned likelihood functions |
| ROOT::Math::Transform3D | 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 |
| ROOT::Math::Translation3D | Class 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 > > | |
| ROOT::Math::UnaryOp< Operator, RHS, T > | UnaryOperation class A class representing unary operators in the parse tree |
| ROOT::Minuit2::VariableMetricBuilder | Build (find) function minimum using the Variable Metric method (MIGRAD) |
| ROOT::Minuit2::VariableMetricEDMEstimator | |
| ROOT::Minuit2::VariableMetricMinimizer | Instantiates the SeedGenerator and MinimumBuilder for Variable Metric Minimization method |
| ROOT::Minuit2::vec | |
| 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::Minuit2::VectorOuterProduct< M, T > | |
| ROOT::Math::VegasParameters | Structures collecting parameters for VEGAS multidimensional integration |
| ROOT::Math::VirtualIntegrator | VirtualIntegrator abstract class |
| ROOT::Math::VirtualIntegratorMultiDim | Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator |
| ROOT::Math::VirtualIntegratorOneDim | Interface (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::WrappedMultiFunction< Func > | Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface |
| ROOT::Math::WrappedMultiTF1 | Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of multi-dimensions to be used in the ROOT::Math numerical algorithm The parameter are stored in the WrappedFunction so we don't rely on the TF1 state values |
| ROOT::Math::WrappedParamFunction< FuncPtr > | WrappedParamFunction class to wrap any multi-dimensional parameteric function implementing an operator()(const double * , const double *) in an interface-like IParamFunction |
| 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 |
| ROOT::Math::WrappedTF1 | Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of one dimensions to be used in the ROOT::Math numerical algorithms The parameter are stored in the WrappedFunction so we don't rely on the TF1 state values |
1.5.3