## Math Libraries

### MathCore

MathCore includes now classes which were previously contained in libCore, like `TMath`, `TComplex` and the `TRandom` classes. Furthermore, some of the algorithms implemented in the `TF1` class have been moved to MathCore. 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 done for the functions present in `TMath`. Some functions have been implemented using the STL algorithms, which have better performances in term of CPU time and a template interface has been also added. Some of the basic special mathematical 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 as well by the `ROOT::Math` functions. This implementation has been found to be more accurate and in some cases more efficient in term of CPU time. More detailed information on the new mathematical functions can be found in this presentation from M. Slawinska at a ROOT team meeting.

- define the functions as template functions instead of having the same re-definition for all the various basic types. This is done for `TMath::Mean`,`TMath::GeomMean`, `TMath::Median`, `TMath::KOrdStat`
- Use STL to implement the following algorithms:
  - `TMath::Sort` is re-implemented using `std::sort`.
  - `TMath::BinarySearch` is re-implemented using the STL algorithm `std::lower_bound`
  The STL algorithms have been found for these cases to be perform better in term of CPU time. For some other algorithms like `TMath::LocMin`, `TMath::LocMax` or `TMath::Permute` the original implementation is faster than STL and has been maintained.
- Add a generic iterator interface, 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 of a `std::vector<double> v`, one simply needs to call `TMath::Mean(v.begin(), v.end() )` .
- Various changes have been applied to the mathematical functions to remove duplications in the implementation with the special and statistical functions defined in `ROOT::Math`. The functions which have been changed and thus they 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, which is accurate at the required double precision level.
  - `TMath::Gamma(z)` is implemented with `ROOT::Math::tgamma`, which again uses Cephes.
  - The incomplete gamma function, `TMath::Gamma(a,x)` it is implemented using `ROOT::Math::inc_gamma` based on a corresponding Cephes function.
  - `TMath::Prob` (the upper chi2 probability) is implemented also using `ROOT::Math::chisquared_cdf_c` which uses `ROOT::Math::inc_gamma_c` based on a corresponding Cephes function. Now the implementation does not suffer anymore from large numerical error present when the result of `TMath::Prob` was approaching zero.
  - `TMath::LnGamma(z)` is 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.

#### Fit

Mathcore include now new classes for performing fits and minimization of multi-dimensional functions. The aim of these classes is to extend and improve the fitting functionality provided in ROOT via the `TVirtualFitter` classes and the fitting methods present in many data analysis object, such as `TH1::Fit`.
The fit data are decoupled from the fitter class and described by the dedicated fit data classes like 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, `ROOT::Fit::Fitter`, provides the functionality 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 then found by using the `ROOT::Math::Minimizer` interface class and the results are stored in the `ROOT::Fit::FitResult` class. Fit parameter can be configured individually using the `ROOT::Fit::FitParameterSettings` class.
Various implementation of the minimizer interface 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)

#### MathCore Numerical Algorithms

Classes implementing numerical methods which can be used by all the other ROOT library have been added in MathCore. These originate mainly from methods present previously in the implementation of the `TF1` class. Now they can be used also outside this class. In addition, in order to have a common entry point, interfaces classes for these numerical algorithms have been included. These interfaces are as well implemented by classes using the GSL library and located in the MathMore library. The library can be loaded automatically using the ROOT plug-in manager. In detail, the new classes containing implementations present previously in `TF1` are:

- `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 common class `ROOT::Math::IntegratorOneDim` providing the interfaces for numerical integration. New template methods have been also included in the common Integration class in order to be able to integrate automatically any C++ callable object.
- `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.
- `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 instantiate, via the common `ROOT::Math::RootFinder` class, all the various root finder algorithms. The `BrentRootFinder` class is used by `TF1::GetX` .
- A similar class, `BrentMinimizer1D`, provides the possibility to find the minimum of one-dimensional functions using the Brent algorithm. This class is used by `TF1::GetMinimum` or `TF1::GetMaximum` Use ROOT convention for all enumeration names defining the type of numerical algorithms (start with k, like kADAPTIVE for the integration type). This affects both MathCore and MathMore.

In addition we use now the ROOT convention for all enumeration names defining the type of numerical algorithms. The names start with `k`, like `kADAPTIVE` for the integration type. This change affects both MathCore and MathMore and it breaks backward compatibility.

#### MathCore Function interfaces

Mathcore provides as well interfaces for the evaluation of mathematical and parametric functions to be used in the the numerical methods. This release contains the following changes:

- The `ROOT::Math::IParamFunction`, `ROOT::Math::IParamMultiFunction` interfaces (used mainly for fitting) require now a pointer to the parameters (type `const double *`), when evaluating the function. The derived classes must implement now the const method `DoEvalPar` (and not `DoEval` as before). In addition the method `operator()(const double * x, const double * p)` is now const. This change makes the caching of parameter not hidden and the interface is now thread-safe.
- A similar change in the `ROOT::Math::IParamGradFunction`, `ROOT::Math::IParamMultiGradFunction` interfaces, where the parameter values are now required for calculating the partial derivatives with respect to the parameters. This changes the signature of the pure abstract method, `DoParameterDerivative(const double *x, const double * p,` , which takes also a pointer (type `const double *`) to the parameters. In addition, these classes do not inherit anymore from the function gradient interface (`ROOT::Math::IGradFunction` and `ROOT::Math::IMultiGradFunction`). They define only the parameter gradient which is needed for fitting and not the coordinate gradient. A derived class, like `ROOT::Math::Polynomial`, implementing both functionality (coordinate and parameter gradient) inherits then from both interfaces.

More detailed description of the current MathCore release can be found at this location.

### 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.
- Changes also in the class for the new enumeration names (all names start with k, like kADAPTIVE for the integration types).

More detailed description of the current MathMore 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. For this release the instantiation of some extra methods, in particular of the class `ROOT::Math::TRansform3D` have been added in the dictionary library. Due to a CINT limitation, the dictionary for explicit template constructors of the Rotation classes, taking as input any other type of rotation are missing. Therefore code like the following one will now work in CINT (or Python):

    ROOT::Math::Rotation3D r;
    ROOT::Math::EulerAngles eulerRot(r);

A possible solution is to use the operator=:

    ROOT::Math::EulerAngles eulerRot; eulerRot = r;

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`).
Detailed description of the current GenVector release can be found at this location.

### 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.
Detailed description of the current SMatrix 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.
- Use now `std::string` for storing parameter names. This removes the un-necessary limitation on the length of parameter name (10 characters) existing before. The method `Name()` of `MinuitParameter` (and of `MnUserParameterState` and `MnUserParameters`) still returns a `const char *` (for backward compatibility). A new method, `GetName()` has been added to return a `std::string`
- The`Minuit2Minimizer` class has been improved by having an option to always run Hesse if it was not done before during the minimization. Method to retrieve the correlation coefficients have been also added.

More detailed description of the current Minuit2 release can be found at this location.

### 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`.

Last modified: Tue Jun 24 17:22:42 CEST 2008