ROOT  6.06/09
Reference Guide
Public Member Functions | Static Public Member Functions | Static Private Member Functions | List of all members
RooMath Class Reference

Definition at line 37 of file RooMath.h.

Public Member Functions

virtual ~RooMath ()
 

Static Public Member Functions

static std::complex< doublefaddeeva (std::complex< double > z)
 evaluate Faddeeva function for complex argument More...
 
static std::complex< doublefaddeeva_fast (std::complex< double > z)
 evaluate Faddeeva function for complex argument (fast version) More...
 
static std::complex< doubleerf (const std::complex< double > z)
 complex erf function More...
 
static std::complex< doubleerf_fast (const std::complex< double > z)
 complex erf function (fast version) More...
 
static std::complex< doubleerfc (const std::complex< double > z)
 complex erfc function More...
 
static std::complex< doubleerfc_fast (const std::complex< double > z)
 complex erfc function (fast version) More...
 
static Double_t interpolate (Double_t yArr[], Int_t nOrder, Double_t x)
 
static Double_t interpolate (Double_t xa[], Double_t ya[], Int_t n, Double_t x)
 
static Double_t erf (Double_t x)
 
static Double_t erfc (Double_t x)
 
static RooComplex ComplexErrFunc (Double_t re, Double_t im=0.)
 deprecated function More...
 
static RooComplex ComplexErrFunc (const RooComplex &zz)
 deprecated function More...
 
static RooComplex ComplexErrFuncFast (const RooComplex &zz)
 deprecated function More...
 
static Double_t ComplexErrFuncFastRe (const RooComplex &zz)
 deprecated function More...
 
static Double_t ComplexErrFuncFastIm (const RooComplex &zz)
 deprecated function More...
 
static RooComplex ITPComplexErrFuncFast (const RooComplex &zz, Int_t)
 deprecated function More...
 
static Double_t ITPComplexErrFuncFastRe (const RooComplex &zz, Int_t)
 deprecated function More...
 
static Double_t ITPComplexErrFuncFastIm (const RooComplex &zz, Int_t)
 deprecated function More...
 
static void cacheCERF (Bool_t)
 deprecated function More...
 
static void cleanup ()
 deprecated function More...
 
static void initFastCERF (Int_t, Double_t, Double_t, Int_t, Double_t, Double_t)
 deprecated function More...
 

Static Private Member Functions

static void warn (const char *oldfun, const char *newfun=0)
 

#include <RooMath.h>

Constructor & Destructor Documentation

virtual RooMath::~RooMath ( )
inlinevirtual

Definition at line 40 of file RooMath.h.

Member Function Documentation

static void RooMath::cacheCERF ( Bool_t  )
inlinestatic

deprecated function

Definition at line 216 of file RooMath.h.

static void RooMath::cleanup ( )
inlinestatic

deprecated function

Definition at line 218 of file RooMath.h.

static RooComplex RooMath::ComplexErrFunc ( Double_t  re,
Double_t  im = 0. 
)
inlinestatic

deprecated function

Definition at line 192 of file RooMath.h.

static RooComplex RooMath::ComplexErrFunc ( const RooComplex zz)
inlinestatic

deprecated function

Definition at line 195 of file RooMath.h.

static RooComplex RooMath::ComplexErrFuncFast ( const RooComplex zz)
inlinestatic

deprecated function

Definition at line 198 of file RooMath.h.

static Double_t RooMath::ComplexErrFuncFastIm ( const RooComplex zz)
inlinestatic

deprecated function

Definition at line 204 of file RooMath.h.

static Double_t RooMath::ComplexErrFuncFastRe ( const RooComplex zz)
inlinestatic

deprecated function

Definition at line 201 of file RooMath.h.

std::complex< double > RooMath::erf ( const std::complex< double z)
static
static Double_t RooMath::erf ( Double_t  x)
inlinestatic

Definition at line 185 of file RooMath.h.

std::complex< double > RooMath::erf_fast ( const std::complex< double z)
static

complex erf function (fast version)

Author
Manuel Schiller manue.nosp@m.l.sc.nosp@m.hille.nosp@m.r@ni.nosp@m.khef..nosp@m.nl
Date
2013-02-21

Calculate erf(z) for complex z. Use the code in faddeeva_fast to save some time.

Definition at line 596 of file RooMath.cxx.

std::complex< double > RooMath::erfc ( const std::complex< double z)
static

complex erfc function

Author
Manuel Schiller manue.nosp@m.l.sc.nosp@m.hille.nosp@m.r@ni.nosp@m.khef..nosp@m.nl
Date
2013-02-21

Calculate erfc(z) for complex z.

Definition at line 560 of file RooMath.cxx.

Referenced by RooGaussModel::analyticalIntegral(), RooGExpModel::calcDecayConv(), RooGExpModel::evalCerfRe(), RooGaussModel::evaluate(), and RooGExpModel::evaluate().

static Double_t RooMath::erfc ( Double_t  x)
inlinestatic

Definition at line 188 of file RooMath.h.

std::complex< double > RooMath::erfc_fast ( const std::complex< double z)
static

complex erfc function (fast version)

Author
Manuel Schiller manue.nosp@m.l.sc.nosp@m.hille.nosp@m.r@ni.nosp@m.khef..nosp@m.nl
Date
2013-02-21

Calculate erfc(z) for complex z. Use the code in faddeeva_fast to save some time.

Definition at line 572 of file RooMath.cxx.

std::complex< double > RooMath::faddeeva ( std::complex< double z)
static

evaluate Faddeeva function for complex argument

Author
Manuel Schiller manue.nosp@m.l.sc.nosp@m.hille.nosp@m.r@ni.nosp@m.khef..nosp@m.nl
Date
2013-02-21

Calculate the value of the Faddeeva function \(w(z) = \exp(-z^2) \mathrm{erfc}(-i z)\).

The method described in

S.M. Abrarov, B.M. Quine: "Efficient algotithmic implementation of Voigt/complex error function based on exponential series approximation" published in Applied Mathematics and Computation 218 (2011) 1894-1902 doi:10.1016/j.amc.2011.06.072

is used. At the heart of the method (equation (14) of the paper) is the following Fourier series based approximation:

\[ w(z) \approx \frac{i}{2\sqrt{\pi}}\left( \sum^N_{n=0} a_n \tau_m\left( \frac{1-e^{i(n\pi+\tau_m z)}}{n\pi + \tau_m z} - \frac{1-e^{i(-n\pi+\tau_m z)}}{n\pi - \tau_m z} \right) - a_0 \frac{1-e^{i \tau_m z}}{z} \right) \]

The coefficients \(a_b\) are given by:

\[ a_n=\frac{2\sqrt{\pi}}{\tau_m} \exp\left(-\frac{n^2\pi^2}{\tau_m^2}\right) \]

To achieve machine accuracy in double precision floating point arithmetic for most of the upper half of the complex plane, chose \(t_m=12\) and \(N=23\) as is done in the paper.

There are two complications: For Im(z) negative, the exponent in the equation above becomes so large that the roundoff in the rest of the calculation is amplified enough that the result cannot be trusted. Therefore, for Im(z) < 0, the symmetry of the erfc function under the transformation z –> -z is used to avoid accuracy issues for Im(z) < 0 by formulating the problem such that the calculation can be done for Im(z) > 0 where the accuracy of the method is fine, and some postprocessing then yields the desired final result.

Second, the denominators in the equation above become singular at \(z = n * pi / 12\) (for 0 <= n < 24). In a tiny disc around these points, Taylor expansions are used to overcome that difficulty.

This routine precomputes everything it can, and tries to write out complex operations to minimise subroutine calls, e.g. for the multiplication of complex numbers.

In the square -8 <= Re(z) <= 8, -8 <= Im(z) <= 8, the routine is accurate to better than 4e-13 relative, the average relative error is better than 7e-16. On a modern x86_64 machine, the routine is roughly three times as fast than the old CERNLIB implementation and offers better accuracy.

For large \(|z|\), the familiar continued fraction approximation

\[ w(z)=\frac{-iz/\sqrt{\pi}}{-z^2+\frac{1/2}{1+\frac{2/2}{-z^2 + \frac{3/2}{1+\frac{4/2}{-z^2+\frac{5/2}{1+\frac{6/2}{-z^2+\frac{7/2 }{1+\frac{8/2}{-z^2+\frac{9/2}{1+\ldots}}}}}}}}}} \]

is used, truncated at the ellipsis ("...") in the formula; for \(|z| > 12\), \(Im(z)>0\) it will give full double precision at a smaller computational cost than the method described above. (For \(|z|>12\), \(Im(z)<0\), the symmetry property \(w(x-iy)=2e^{-(x+iy)^2-w(x+iy)}\) is used.

Definition at line 546 of file RooMath.cxx.

Referenced by ComplexErrFunc(), and RooVoigtian::evaluate().

std::complex< double > RooMath::faddeeva_fast ( std::complex< double z)
static

evaluate Faddeeva function for complex argument (fast version)

Author
Manuel Schiller manue.nosp@m.l.sc.nosp@m.hille.nosp@m.r@ni.nosp@m.khef..nosp@m.nl
Date
2013-02-21

Calculate the value of the Faddeeva function \(w(z) = \exp(-z^2) \mathrm{erfc}(-i z)\).

This is the "fast" version of the faddeeva routine above. Fast means that is takes roughly half the amount of CPU of the slow version of the routine, but is a little less accurate.

To be fast, chose \(t_m=8\) and \(N=11\) which should give accuracies around 1e-7.

In the square -8 <= Re(z) <= 8, -8 <= Im(z) <= 8, the routine is accurate to better than 4e-7 relative, the average relative error is better than 5e-9. On a modern x86_64 machine, the routine is roughly five times as fast than the old CERNLIB implementation, or about 30% faster than the interpolation/lookup table based fast method used previously in RooFit, and offers better accuracy than the latter (the relative error is roughly a factor 280 smaller than the old interpolation/table lookup routine).

For large \(|z|\), the familiar continued fraction approximation

\[ w(z)=\frac{-iz/\sqrt{\pi}}{-z^2+\frac{1/2}{1+\frac{2/2}{-z^2 + \frac{3/2}{1+\ldots}}}} \]

is used, truncated at the ellipsis ("...") in the formula; for \(|z| > 8\), \(Im(z)>0\) it will give full float precision at a smaller computational cost than the method described above. (For \(|z|>8\), \(Im(z)<0\), the symmetry property \(w(x-iy)=2e^{-(x+iy)^2-w(x+iy)}\) is used.

Definition at line 553 of file RooMath.cxx.

Referenced by ComplexErrFuncFast(), ComplexErrFuncFastIm(), ComplexErrFuncFastRe(), RooGaussModel::evalCerf(), RooGExpModel::evalCerf(), RooVoigtian::evaluate(), ITPComplexErrFuncFast(), ITPComplexErrFuncFastIm(), and ITPComplexErrFuncFastRe().

static void RooMath::initFastCERF ( Int_t  ,
Double_t  ,
Double_t  ,
Int_t  ,
Double_t  ,
Double_t   
)
inlinestatic

deprecated function

Definition at line 220 of file RooMath.h.

Double_t RooMath::interpolate ( Double_t  yArr[],
Int_t  nOrder,
Double_t  x 
)
static
Double_t RooMath::interpolate ( Double_t  xa[],
Double_t  ya[],
Int_t  n,
Double_t  x 
)
static

Definition at line 645 of file RooMath.cxx.

static RooComplex RooMath::ITPComplexErrFuncFast ( const RooComplex zz,
Int_t   
)
inlinestatic

deprecated function

Definition at line 207 of file RooMath.h.

static Double_t RooMath::ITPComplexErrFuncFastIm ( const RooComplex zz,
Int_t   
)
inlinestatic

deprecated function

Definition at line 213 of file RooMath.h.

static Double_t RooMath::ITPComplexErrFuncFastRe ( const RooComplex zz,
Int_t   
)
inlinestatic

deprecated function

Definition at line 210 of file RooMath.h.

void RooMath::warn ( const char *  oldfun,
const char *  newfun = 0 
)
staticprivate

The documentation for this class was generated from the following files: