14#ifndef RooFit_Detail_MathFuncs_h
15#define RooFit_Detail_MathFuncs_h
34 if (
n < 0 || k < 0 ||
n < k)
39 int k1 = std::min(k,
n - k);
42 for (
double i = k1; i > 1.; --i) {
49template <
typename DoubleArray>
53 int degree = nCoefs - 1;
58 }
else if (degree == 0) {
60 }
else if (degree == 1) {
63 double a1 = coefs[1] - a0;
64 return a1 * xScaled + a0;
66 }
else if (degree == 2) {
69 double a1 = 2 * (coefs[1] - a0);
70 double a2 = coefs[2] - a1 - a0;
71 return (a2 * xScaled + a1) * xScaled + a0;
75 double s = 1. - xScaled;
77 double result = coefs[0] * s;
78 for (
int i = 1; i < degree; i++) {
82 result += t * coefs[degree];
90 const double arg =
x - mean;
91 const double sig =
sigma;
92 return std::exp(-0.5 * arg * arg / (sig * sig));
95template <
typename DoubleArray>
96double product(DoubleArray factors, std::size_t nFactors)
99 for (std::size_t i = 0; i < nFactors; ++i) {
106inline double ratio(
double numerator,
double denominator)
108 return numerator / denominator;
111inline double bifurGauss(
double x,
double mean,
double sigmaL,
double sigmaR)
120inline double efficiency(
double effFuncVal,
int catIndex,
int sigCatIndex)
123 effFuncVal = std::clamp(effFuncVal, 0.0, 1.0);
125 if (catIndex == sigCatIndex) {
128 return 1 - effFuncVal;
133template <
bool pdfMode = false,
typename DoubleArray>
134double polynomial(DoubleArray coeffs,
int nCoeffs,
int lowestOrder,
double x)
136 double retVal = coeffs[nCoeffs - 1];
137 for (
int i = nCoeffs - 2; i >= 0; i--) {
138 retVal = coeffs[i] +
x * retVal;
140 retVal = retVal * std::pow(
x, lowestOrder);
141 return retVal + (pdfMode && lowestOrder > 0 ? 1.0 : 0.0);
144template <
typename DoubleArray>
145double chebychev(DoubleArray coeffs,
unsigned int nCoeffs,
double x_in,
double xMin,
double xMax)
148 const double xPrime = (x_in - 0.5 * (xMax + xMin)) / (0.5 * (xMax - xMin));
153 double curr = xPrime;
154 double twox = 2 * xPrime;
156 double newval = twox * curr - last;
159 for (
unsigned int i = 0; nCoeffs != i; ++i) {
160 sum += last * coeffs[i];
161 newval = twox * curr - last;
169template <
typename DoubleArray>
180template <
typename DoubleArray>
184#if defined(__CLING__) && defined(R__HAS_CLAD)
185#pragma clad checkpoint loop
187 for (
unsigned int i = 0; i < compSize; i++) {
188 sum -= std::log(comp[i]);
193inline unsigned int uniformBinNumber(
double low,
double high,
double val,
unsigned int numBins,
double coef)
195 double binWidth = (high - low) / numBins;
196 return coef * (val >= high ? numBins - 1 : std::abs((val - low) / binWidth));
199template <
typename DoubleArray>
200unsigned int rawBinNumber(
double x, DoubleArray boundaries, std::size_t nBoundaries)
202 DoubleArray end = boundaries + nBoundaries;
203 DoubleArray it = std::lower_bound(boundaries, end,
x);
205 while (boundaries != it && (end == it || end == it + 1 ||
x < *it)) {
208 return it - boundaries;
211template <
typename DoubleArray>
212unsigned int binNumber(
double x,
double coef, DoubleArray boundaries,
unsigned int nBoundaries,
int nbins,
int blo)
215 int tmp = std::min(nbins, rawBin - blo);
216 return coef * std::max(0, tmp);
219template <
typename DoubleArray>
220double interpolate1d(
double low,
double high,
double val,
unsigned int numBins, DoubleArray vals)
222 double binWidth = (high - low) / numBins;
223 int idx = val >= high ? numBins - 1 : std::abs((val - low) / binWidth);
226 double central = low + (idx + 0.5) * binWidth;
227 if (val > low + 0.5 * binWidth && val < high - 0.5 * binWidth) {
230 slope = vals[idx] - vals[idx - 1];
232 slope = vals[idx + 1] - vals[idx];
234 return vals[idx] + slope * (val - central) / binWidth;
247 }
else if (
x == 0.0) {
248 return std::exp(-par);
251 return std::exp(out);
256 double paramVal,
double res)
261 return paramVal * (high - nominal);
263 return paramVal * (nominal - low);
265 }
else if (code == 1) {
268 return res * (std::pow(high / nominal, +paramVal) - 1);
270 return res * (std::pow(low / nominal, -paramVal) - 1);
272 }
else if (code == 2) {
274 double a = 0.5 * (high + low) - nominal;
275 double b = 0.5 * (high - low);
278 return (2 *
a +
b) * (paramVal - 1) + high - nominal;
279 }
else if (paramVal < -1) {
280 return -1 * (2 *
a -
b) * (paramVal + 1) + low - nominal;
282 return a * paramVal * paramVal +
b * paramVal +
c;
288 }
else if (code == 4 || code == 6) {
297 mod =
x * (high - nominal);
298 }
else if (
x <= -boundary) {
299 mod =
x * (nominal - low);
302 double t =
x / boundary;
303 double eps_plus = high - nominal;
304 double eps_minus = nominal - low;
305 double S = 0.5 * (eps_plus + eps_minus);
306 double A = 0.0625 * (eps_plus - eps_minus);
308 mod =
x * (S + t * A * (15 + t * t * (-10 + t * t * 3)));
317 }
else if (code == 5) {
321 mod = std::pow(high / nominal, +paramVal);
322 }
else if (
x <= -boundary) {
323 mod = std::pow(low / nominal, -paramVal);
326 double x0 = boundary;
332 double logHi = std::log(high);
333 double logLo = std::log(low);
334 double powUp = std::exp(x0 * logHi);
335 double powDown = std::exp(x0 * logLo);
336 double powUpLog = high <= 0.0 ? 0.0 : powUp * logHi;
337 double powDownLog = low <= 0.0 ? 0.0 : -powDown * logLo;
338 double powUpLog2 = high <= 0.0 ? 0.0 : powUpLog * logHi;
339 double powDownLog2 = low <= 0.0 ? 0.0 : -powDownLog * logLo;
341 double S0 = 0.5 * (powUp + powDown);
342 double A0 = 0.5 * (powUp - powDown);
343 double S1 = 0.5 * (powUpLog + powDownLog);
344 double A1 = 0.5 * (powUpLog - powDownLog);
345 double S2 = 0.5 * (powUpLog2 + powDownLog2);
346 double A2 = 0.5 * (powUpLog2 - powDownLog2);
350 double x0Sq = x0 * x0;
352 double a = 1. / (8 * x0) * (15 * A0 - 7 * x0 *
S1 + x0 * x0 * A2);
353 double b = 1. / (8 * x0Sq) * (-24 + 24 *
S0 - 9 * x0 * A1 + x0 * x0 * S2);
354 double c = 1. / (4 * x0Sq * x0) * (-5 * A0 + 5 * x0 *
S1 - x0 * x0 * A2);
355 double d = 1. / (4 * x0Sq * x0Sq) * (12 - 12 *
S0 + 7 * x0 * A1 - x0 * x0 * S2);
356 double e = 1. / (8 * x0Sq * x0Sq * x0) * (+3 * A0 - 3 * x0 *
S1 + x0 * x0 * A2);
357 double f = 1. / (8 * x0Sq * x0Sq * x0Sq) * (-8 + 8 *
S0 - 5 * x0 * A1 + x0 * x0 * S2);
363 return res * (mod - 1.0);
369template <
typename ParamsArray,
typename DoubleArray>
370double flexibleInterp(
unsigned int code, ParamsArray params,
unsigned int n, DoubleArray low, DoubleArray high,
371 double boundary,
double nominal,
int doCutoff)
373 double total = nominal;
374 for (std::size_t i = 0; i <
n; ++i) {
378 return doCutoff && total <= 0 ? TMath::Limits<double>::Min() :
total;
409 if (mu == 0.0 && weight == 0.0) {
413 return std::numeric_limits<double>::quiet_NaN();
415 const double diff = mu - weight;
416 return diff * diff / mu;
423 if (sigma2 == 0.0 && mu == 0.0 && weight == 0.0) {
427 return std::numeric_limits<double>::quiet_NaN();
429 const double diff = mu - weight;
430 return diff * diff / sigma2;
436inline double chi2Asymmetric(
double mu,
double weight,
double errLo,
double errHi)
438 const double diff = mu - weight;
439 const double err = diff > 0.0 ? errHi : errLo;
440 const double sigma2 = err * err;
441 if (sigma2 == 0.0 && mu == 0.0 && weight == 0.0) {
445 return std::numeric_limits<double>::quiet_NaN();
447 return diff * diff / sigma2;
450inline double nll(
double pdf,
double weight,
int binnedL,
int doBinOffset)
456 if (std::abs(pdf) < 1
e-10 && std::abs(weight) < 1
e-10) {
460 return pdf - weight - weight * (std::log(pdf) - std::log(weight));
464 return -weight * std::log(pdf);
468template <
typename DoubleArray>
473 for (
unsigned int i = 1; i <
n; ++i) {
482 double t = (
m - m0) /
sigma;
486 double absAlpha = std::abs(alpha);
488 if (t >= -absAlpha) {
489 return std::exp(-0.5 * t * t);
491 double r =
n / absAlpha;
492 double a = std::exp(-0.5 * absAlpha * absAlpha);
493 double b =
r - absAlpha;
495 return a * std::pow(
r / (
b - t),
n);
507 return std::erf(arg);
526 double scaledMin = 0.;
527 double scaledMax = 0.;
528 scaledMin = (xMin - mean) / xscale;
529 scaledMax = (xMax - mean) / xscale;
535 double ecmin = std::erfc(std::abs(scaledMin));
536 double ecmax = std::erfc(std::abs(scaledMax));
541 double prd = scaledMin * scaledMax;
543 cond = 2.0 - (ecmin + ecmax);
544 }
else if (scaledMax <= 0.0) {
545 cond = ecmax - ecmin;
547 cond = ecmin - ecmax;
549 return resultScale * cond;
557 const double resultScale = 0.5 * std::sqrt(
TMath::TwoPi());
560 return resultScale * (sigmaL * (std::erf((xMax - mean) / xscaleL) - std::erf((xMin - mean) / xscaleL)));
561 }
else if (xMin > mean) {
562 return resultScale * (sigmaR * (std::erf((xMax - mean) / xscaleR) - std::erf((xMin - mean) / xscaleR)));
564 return resultScale * (sigmaR * std::erf((xMax - mean) / xscaleR) - sigmaL * std::erf((xMin - mean) / xscaleL));
573 return x == 0.0 ? 1.0 : std::expm1(
x) /
x;
581 if (std::abs(
x) < 0.25) {
584 return 1. / 2 +
x * (1. / 3 +
x * (1. / 8 +
x * (1. / 30 +
x * (1. / 144 +
x * (1. / 840
585 +
x * (1. / 5760 +
x * (1. / 45360 +
x * (1. / 403200 +
x * (1. / 3991680 +
x * (1. / 43545600))))))))));
600 if (constant == 0.0) {
604 const double z = constant * (xMax - xMin);
606 return -std::exp(constant * xMax) * std::expm1(-z) / constant;
608 return std::exp(constant * xMin) * std::expm1(z) / constant;
618 const bool fromMin = constant * (xMax - xMin) <= 0.0;
619 const double a = fromMin ? xMin : xMax;
620 const double d = fromMin ? xMax - xMin : xMin - xMax;
621 const double w = constant *
d;
627template <
bool pdfMode = false,
typename DoubleArray>
630 int denom = lowestOrder + nCoeffs;
631 double min = coeffs[nCoeffs - 1] /
double(denom);
632 double max = coeffs[nCoeffs - 1] /
double(denom);
634 for (
int i = nCoeffs - 2; i >= 0; i--) {
636 min = (coeffs[i] /
double(denom)) + xMin * min;
637 max = (coeffs[i] /
double(denom)) + xMax * max;
640 max = max * std::pow(xMax, 1 + lowestOrder);
641 min = min * std::pow(xMin, 1 + lowestOrder);
643 return max - min + (pdfMode && lowestOrder > 0.0 ? xMax - xMin : 0.0);
649#if defined(FP_FAST_FMA)
650 return std::fma(
x,
y, z);
653#if defined(__clang__)
654#pragma STDC FP_CONTRACT ON
660template <
typename DoubleArray>
662chebychevIntegral(DoubleArray coeffs,
unsigned int nCoeffs,
double xMin,
double xMax,
double xMinFull,
double xMaxFull)
664 const double halfrange = .5 * (xMax - xMin);
665 const double mid = .5 * (xMax + xMin);
668 const double b = (xMaxFull - mid) / halfrange;
669 const double a = (xMinFull - mid) / halfrange;
676 const unsigned int iend = nCoeffs;
680 const double c = coeffs[0];
685 double btwox = 2 *
b;
689 double atwox = 2 *
a;
692 double newval = atwox * acurr - alast;
696 newval = btwox * bcurr - blast;
700 for (
unsigned int i = 1; iend != i; ++i) {
702 const double c = coeffs[i];
703 const double term2 = (blast - alast) / nminus1;
705 newval = atwox * acurr - alast;
709 newval = btwox * bcurr - blast;
714 const double term1 = (bcurr - acurr) / (nminus1 + 1.);
715 const double intTn = 0.5 * (term1 - term2);
723 return halfrange *
sum;
728poissonIntegral(
int code,
double mu,
double x,
double integrandMin,
double integrandMax,
unsigned int protectNegative)
730 if (protectNegative && mu < 0.0) {
731 return std::exp(-2.0 * mu);
737 integrandMin = std::max(0., integrandMin);
739 if (integrandMax < 0. || integrandMax < integrandMin) {
742 const double delta = 100.0 * std::sqrt(mu);
746 if (integrandMin < std::max(mu - delta, 0.0) && integrandMax > mu + delta) {
751 const unsigned int ixMin = integrandMin;
752 const unsigned int ixMax = std::min(integrandMax + 1, (
double)std::numeric_limits<unsigned int>::max());
770 const double ix = 1 +
x;
777 const double root2 = std::sqrt(2.);
779 double ln_k = std::abs(std::log(k));
780 double ret = 0.5 * (std::erf(std::log(xMax / m0) / (root2 * ln_k)) - std::erf(std::log(xMin / m0) / (root2 * ln_k)));
787 const double root2 = std::sqrt(2.);
789 double ln_k = std::abs(
sigma);
791 0.5 * (std::erf((std::log(xMax) - mu) / (root2 * ln_k)) - std::erf((std::log(xMin) - mu) / (root2 * ln_k)));
798 const double sqrtPiOver2 = 1.2533141373;
799 const double sqrt2 = 1.4142135624;
804 if (std::abs(
n - 1.0) < 1.0e-05)
807 double sig = std::abs(
sigma);
809 double tmin = (mMin - m0) / sig;
810 double tmax = (mMax - m0) / sig;
818 double absAlpha = std::abs(alpha);
820 if (tmin >= -absAlpha) {
822 }
else if (tmax <= -absAlpha) {
823 double r =
n / absAlpha;
824 double a =
r * std::exp(-0.5 * absAlpha * absAlpha);
825 double b =
r - absAlpha;
828 double log_b_tmin = std::log(
b - tmin);
829 double log_b_tmax = std::log(
b - tmax);
831 (log_b_tmin - log_b_tmax + 0.5 * (1.0 -
n) * (log_b_tmin * log_b_tmin - log_b_tmax * log_b_tmax));
833 result +=
a * sig / (1.0 -
n) * (std::pow(
r / (
b - tmin),
n - 1.0) - std::pow(
r / (
b - tmax),
n - 1.0));
836 double r =
n / absAlpha;
837 double a =
r * std::exp(-0.5 * absAlpha * absAlpha);
838 double b =
r - absAlpha;
842 double log_b_tmin = std::log(
b - tmin);
843 double log_r = std::log(
r);
844 term1 =
a * std::pow(
r,
n - 1) * sig *
845 (log_b_tmin - log_r + 0.5 * (1.0 -
n) * (log_b_tmin * log_b_tmin - log_r * log_r));
847 term1 =
a * sig / (1.0 -
n) * (std::pow(
r / (
b - tmin),
n - 1.0) - 1.0);
850 double term2 = sig * sqrtPiOver2 * (
approxErf(tmax / sqrt2) -
approxErf(-absAlpha / sqrt2));
860template <
typename DoubleArray>
866 int degree = nCoefs - 1;
869 for (
int i = 0; i <= degree; ++i) {
874 for (
int j = i; j <= degree; ++j) {
876 double oneOverJPlusOne = 1. / (j + 1.);
877 double powDiff = std::pow(xhiScaled, j + 1.) - std::pow(xloScaled, j + 1.);
878 temp += std::pow(-1., j - i) * binCoefs * powDiff * oneOverJPlusOne;
887template <
typename XArray,
typename MuArray,
typename CovArray>
893 for (
int i = 0; i <
n; ++i) {
894 for (
int j = 0; j <
n; ++j) {
895 result += (
x[i] - mu[i]) * covI[i *
n + j] * (
x[j] - mu[j]);
898 return std::exp(-0.5 *
result);
904template <
typename DoubleArray>
908 for (std::size_t i = 0; i < nBins; ++i) {
909 double a = boundaries[i];
910 double b = boundaries[i + 1];
911 out += coefs[i] * std::max(0.0, std::min(
b,
xmax) - std::max(
a,
xmin));
921template <
typename T,
typename U>
937template <
class... Types>
948template <
typename T,
typename>
953template <
typename DoubleArray,
class... Types>
977template <
typename T =
double>
984 double *d_xMax,
double *d_constant)
986 *d_xMin -= d_out * std::exp(constant * xMin);
987 *d_xMax += d_out * std::exp(constant * xMax);
991template <
typename T =
double>
997 -std::exp(constant * xMin) * d_xMin + std::exp(constant * xMax) * d_xMax +
static unsigned int total
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
double lognormal_pdf(double x, double m, double s, double x0=0)
Probability density function of the lognormal distribution.
double landau_pdf(double x, double xi=1, double x0=0)
Probability density function of the Landau distribution:
double inc_gamma_c(double a, double x)
Calculates the normalized (regularized) upper incomplete gamma function (upper integral)
double inc_gamma(double a, double x)
Calculates the normalized (regularized) lower incomplete gamma function (lower integral)
double exponentialIntegralDConstant(double xMin, double xMax, double constant)
Derivative of exponentialIntegral() with respect to the constant, i.e.
double polynomialIntegral(DoubleArray coeffs, int nCoeffs, int lowestOrder, double xMin, double xMax)
In pdfMode, a coefficient for the constant term of 1.0 is implied if lowestOrder > 0.
double logNormalIntegral(double xMin, double xMax, double m0, double k)
double gaussianIntegral(double xMin, double xMax, double mean, double sigma)
Function to calculate the integral of an un-normalized RooGaussian over x.
double flexibleInterp(unsigned int code, ParamsArray params, unsigned int n, DoubleArray low, DoubleArray high, double boundary, double nominal, int doCutoff)
double bifurGaussIntegral(double xMin, double xMax, double mean, double sigmaL, double sigmaR)
double bernstein(double x, double xmin, double xmax, DoubleArray coefs, int nCoefs)
The caller needs to make sure that there is at least one coefficient.
double constraintSum(DoubleArray comp, unsigned int compSize)
double cbShape(double m, double m0, double sigma, double alpha, double n)
double multipdf(int idx, DoubleArray pdfs)
double chebychevIntegral(DoubleArray coeffs, unsigned int nCoeffs, double xMin, double xMax, double xMinFull, double xMaxFull)
double recursiveFraction(DoubleArray a, unsigned int n)
double cbShapeIntegral(double mMin, double mMax, double m0, double sigma, double alpha, double n)
double polynomial(DoubleArray coeffs, int nCoeffs, int lowestOrder, double x)
In pdfMode, a coefficient for the constant term of 1.0 is implied if lowestOrder > 0.
double fast_fma(double x, double y, double z) noexcept
use fast FMA if available, fall back to normal arithmetic if not
double logNormalIntegralStandard(double xMin, double xMax, double mu, double sigma)
double interpolate1d(double low, double high, double val, unsigned int numBins, DoubleArray vals)
double landau(double x, double mu, double sigma)
double gaussian(double x, double mean, double sigma)
Function to evaluate an un-normalized RooGaussian.
double poisson(double x, double par)
double binomial(int n, int k)
Calculates the binomial coefficient n over k.
unsigned int uniformBinNumber(double low, double high, double val, unsigned int numBins, double coef)
double multiVarGaussian(int n, XArray x, MuArray mu, CovArray covI)
double flexibleInterpSingle(unsigned int code, double low, double high, double boundary, double nominal, double paramVal, double res)
double bernsteinIntegral(double xlo, double xhi, double xmin, double xmax, DoubleArray coefs, int nCoefs)
double chi2Asymmetric(double mu, double weight, double errLo, double errHi)
Chi-squared contribution of one bin with asymmetric (Poisson-style) data errors.
double chebychev(DoubleArray coeffs, unsigned int nCoeffs, double x_in, double xMin, double xMax)
double chi2Expected(double mu, double weight)
Chi-squared contribution of one bin with "expected" errors: .
double product(DoubleArray factors, std::size_t nFactors)
unsigned int rawBinNumber(double x, DoubleArray boundaries, std::size_t nBoundaries)
unsigned int binNumber(double x, double coef, DoubleArray boundaries, unsigned int nBoundaries, int nbins, int blo)
double chi2Symmetric(double mu, double weight, double sigma2)
Chi-squared contribution of one bin with a user-supplied symmetric error squared (e....
double logNormalStandard(double x, double sigma, double mu)
double bifurGauss(double x, double mean, double sigmaL, double sigmaR)
double ratio(double numerator, double denominator)
double expm1OverX(double x)
(exp(x) - 1) / x with the removable singularity at x = 0 filled in.
double approxErf(double arg)
double expm1OverXDerivative(double x)
Derivative of expm1OverX().
double effProd(double eff, double pdf)
double poissonIntegral(int code, double mu, double x, double integrandMin, double integrandMax, unsigned int protectNegative)
double logNormal(double x, double k, double m0)
double stepFunctionIntegral(double xmin, double xmax, std::size_t nBins, DoubleArray boundaries, DoubleArray coefs)
double nll(double pdf, double weight, int binnedL, int doBinOffset)
double efficiency(double effFuncVal, int catIndex, int sigCatIndex)
double exponentialIntegral(double xMin, double xMax, double constant)
Integral of exp(constant * x) from xMin to xMax.
Double_t QuietNaN()
Returns a quiet NaN as defined by IEEE 754.
constexpr Double_t Sqrt2()
Double_t LnGamma(Double_t z)
Computation of ln[gamma(z)] for all z.
Double_t SignalingNaN()
Returns a signaling NaN as defined by IEEE 754.
constexpr Double_t TwoPi()
ValueAndPushforwardOf< unsignedint, DoubleArray >::type binNumber_pushforward(double x, double coef, DoubleArray boundaries, unsigned int nBoundaries, int nbins, int blo, Types...)
void exponentialIntegral_pullback(double xMin, double xMax, double constant, double d_out, double *d_xMin, double *d_xMax, double *d_constant)
ValueAndPushforwardOf< double, T >::type expm1OverX_pushforward(double x, double d_x)
ValueAndPushforwardOf< double, T >::type exponentialIntegral_pushforward(double xMin, double xMax, double constant, double d_xMin, double d_xMax, double d_constant)
void binNumber_pullback(Types...)
void expm1OverX_pullback(double x, double d_out, double *d_x)
::clad::ValueAndPushforward< T, T > type
static uint64_t sum(uint64_t i)