MathCore
MathCore contains now the classes in the math directory, TMath, TComplex and the TRandom classes. This implies that all other ROOT library using one of these classes, such as libHist, have a direct dependency on the Mathcore library.
Linking with libMathCore is therefore required for running any major ROOT application. It has been added to the list of libraries obtained when doing root-config --libs.
N.B. users building ROOT applications and not using root-config MUST add libMathCore to their list of linking libraries.
Together with the libraries merge, many changes have been applied to both TMath and the other mathcore classes.
TMath
A major clean-up and re-structuring has been performed for the TMath functions. In particular some functions have been implemented using STL algorithms which have shown for these case better performances in term of CPU time. The file TMathImp.h contains the implementations for the template functions.
Some of the basic special functions of TMath, like the error function or the gamma and beta functions use now the Cephes implementation from Stephen L. Moshier, which is used by the ROOT::Math functions and it has been found to be more accurate and in some cases even faster.
- use template functions instead of having the same function for all the various basic types, for functions like TMath::Mean,TMath::GeomMean, TMath::Median, TMath::KOrdStat
- Use STL to implement the following TMath algorithms:
- TMath::Sort re-implemented using std::sort.
- TMath::BinarySearch re-implemented using the STL algorithm std::lower_bound
The STL algorithms were found in these cases to be more performant in term of CPU time. For some like TMath::LocMin, TMath::LocMax or TMath::Permute the original implementation has been left since it was found to be more performant than the generic one provided by STL.
- Add an interface working with generic iterators, similar to the STL algorithm interface, to the following TMath functions:
MinElement, MaxElemen, LocMin, LocMax, Mean, GeomMean, RMS,
BinarySearch. The iterator interface for sort is called
TMath::SortItr to avoid a compilation ambiguity. For example,
for finding the mean from an std::vector<double> v one simply needs to call TMath::Mean(v.begin(), v.end() )
- Various changes have been applied to the mathematical function to remove duplications with the special and statistical functions defined in ROOT::Math. In detailed the implementations which have been changed and can return a sightly different result than before are:
- TMath::Erf and TMath::Erfc call ROOT::Math::erf and ROOT::math::erfc which are implemented using the Cephes algorithms
- TMath::Gamma(z) is implemented with ROOT::Math::tgamma and the incomplete gamma function, TMath::Gamma(a,x) it is implemented using ROOT::Math::inc_gamma.
- TMath::Prob(z) (the upper chi2 probability) is implemented using ROOT::Math::chisquared_cdf_c which uses ROOT::Math::inc_gamma.
- TMath::LnGamma(z) is also implemented using ROOT::Math::lgamma. This affects also TMath::Beta which is implemented using the log of the gamma function.
- TMath::BetaIncomplete is implemented using ROOT::Math::beta_inc.
- TMath::GammaDist is implemented using ROOT::Math::gamma_pdf.
- TMath::LogNormal is implemented using ROOT::Math::lognormal_pdf.
- TMath::PoissonI: fixed a problem for large values and is implemented using directly TMath::Poisson with integer values.
More detailed information on the new mathematical functions can be found in this presentation from M. Slawinska.
Fit
Mathcore include now new classes for performing fits and minimization of multi-dimensional functions. These aim of these classes is to extend and improve the fitting functionality provided in ROOT via the TVirtualFitter classes and the Fit method present in many data analysis object, such as TH1.
The fit data are decoupled from the fitter class and described by the ROOT::Fit::BinData for bin data containing coordinate values of any dimensions, bin content values and optionally errors in coordinate and bin content, and ROOT::Fit::UnBinData classes for any dimension un-bin data.
The fitter class provides the support for fitting those data with any model function implementing the parametric function interface, ROOT::Math::IParamMultiFunction. Fit methods such as least square, bin and un-bin likelihood are supported. The fit solution is found by using the ROOT::Math::Minimizer class.
Various implementation can be used automatically using the ROOT plug-in manager mechanism, including the linear fitter for a fast and direct solution, in case of a linear least square model, or by using Minuit, Minuit2 or GSL minimization methods provided by the MathMore library.
Functions for filling the new ROOT::Fit::BinData classes with all the histogram and graph types have been added in the histogram library (libHist) and graph library:
- ROOT::Fit::FillData( BinData & , const TH1 *, TF1 * ) for histograms (in libHist)
- ROOT::Fit::FillData( BinData & , const TGraph2D *, TF1 * ) for 2D graphs (in libHist)
- ROOT::Fit::FillData( BinData & , const TGraph *, TF1 * ) for all 1D graphs (in libGraf)
- ROOT::Fit::FillData( BinData & , const TMultiGraph *, TF1 * ) for multi-graphs (in libGraf)
Additional MathCore changes
- New classes GaussIntegrator and GaussLegendreIntegrator for numerical integration of one-dimensional functions. The first class uses Gaussian 8 and 16 point quadrature approximation, it provides the translation of the CERNLIB algorithm
DGAUSS by Sigfried Kolbig, and it is used by the TF1::Integral method. The second one uses the Gauss Legendre quadrature formula. It is used by the TF1::IntegralFast method.
These classes implement both the same virtual interface as the adaptive integration methods provided by the MathMore library. They can all be created and used easily via the entry class ROOT::Math::IntegratorOneDim.
- New class ROOT::Math::RichardsonDerivator implementing numerical derivation using the Richardson's extrapolation formula (use 2 derivative estimates to compute a third, more accurate estimation). This is used by the TD1::Derivative method.
- New class BrentRootFinder for finding the root of one-dimensional function using the Brent algorithm. The class inherits from a virtual interface, which is also implemented by the MathMore root finder methods. The user can therefore by using the ROOT::Math::RootFinder class instantiates the various root finder algorithms. The BrentRootFinder class is used by TF1::GetX. A similar class, BrentMinimizer1D provides the possibility to find the minimum if a one-dimensional function using the Brent algorithm. This class is used by TF1::GetMinimum or TF1::GetMaximum
More detailed description of the current MathCore release can be found at this location.
GenVector
The new physics vector classes have been moved out from the MathCore library in a new library, libGenVector. The library contains as well the CINT dictionary including main instantiations for the template classes.
In addition the setter methods for the 2D,3D and 4D vector classes have been extended following a suggestion by G. Raven. Functions like SetX instead of returning a void return now a reference to the vector class itself (*this).
SMatrix
Fix a bug discovered by Harals Soleng in the addition of two matrix expressions. Remove also some compilation warning found on Windows when compiling matrices instantiated using float types.
MathMore
This new release contains:
- Modify and rename the class ROOT::Math::RootFinder to ROOT::Math::GSLRootFinder to distinguish from the main interface class which has been put in the Mathcore library and it can create the GSLRootFinder using the plug-in manager. Furthermore, the class ROOT::Math::GSLRootFinder is not anymore a template class on the algorithm. They type of root-finder algorithm can now be selected via an enumeration
- Fixed a bug in the ROOT::Math::GSLNLSMutiFi class.
More detailed description of the current MathMore release can be found at this location.
Minuit
Two new classes have been added:
- TMinuitMinimizer: implementation of the ROOT::Math::Minimizer interface with TMinuit. This class is used for example by the new Fitter class.
- TLinearMinimizer: implementation of the ROOT::Math::Minimizer interface with the TLinearFitter.
In addition, the method TLinearFitter::SetBasisFunction(TObjArray * f) has been added to set directly the linear terms of the fit function.
Minuit2
Various fixes have been applied to different problems discovered mainly by a test program from Alfio Lazzaro. In detail:
-
Fix a bug in MnMinos which was setting wrong initial values when the parameters were limited.
This was resulting in a much larger number of function calls used inside MnMinos.
- Improve MnHesse by returning in the final state the improved gradient step values used in HessianGradientCalculator. With this change same results are obtained from using Hesse in Minuit2 or TMinuit. In addition, the interface of MnHesse (MnHesse::operator() ) has been improved to use it from the FunctionMinimum object (similar to MnMinos) in order to be called after the minimization (Migrad). The API with a MnUserParameterState should not be used after minimization, because in that case the latest state information resulting from the minimum (gradient values and step sizes) is lost.
- Add support in MnMigrad and MnMinimize for user provided analytical gradient of the FCN function. One needs to pass an instance of a function implementing the ROOT::Minuit2::FcnGradientBase interface.
-
The Minuit2Minimizer class has been improved by having an option to always run Hesse if it was not done before during the minimization.
Unuran
A new version, 1.2.4, has been added to fix mainly some problems found in gcc 4.3. For the detailed changes of this new UNU.RAN version see the file $ROOTSYS/math/unuran/src/unuran-1.2.4-root/NEWS.