Maths.h

// -*- C++ -*-
//
// Maths.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_Math_H
#define ThePEG_Math_H

#include <cmath>

namespace ThePEG {

namespace Math {

struct MathType {};

double gamma(double);

double lngamma(double);

double atanh(double);

double exp1m(double x);

double log1m(double);

double powi(double x, int p);

inline double pIntegrate(double p, double xl, double xu) {
  return p == -1.0? log(xu/xl): (pow(xu, p + 1.0) - pow(xl, p + 1.0))/(p + 1.0);
}

inline double pIntegrate(int p, double xl, double xu) {
  return p == -1? log(xu/xl): (powi(xu, p + 1) - powi(xl, p + 1))/double(p + 1);
}

inline double pXIntegrate(double e, double xl, double dx) {
  return e == 0.0? log1m(-dx/xl): -pow(xl, e)*exp1m(e*log1m(-dx/xl))/e;
}

inline double pGenerate(double p, double xl, double xu, double rnd) {
  return p == -1.0? xl*pow(xu/xl, rnd):
    pow((1.0 - rnd)*pow(xl, p + 1.0) + rnd*pow(xu, p + 1.0), 1.0/(1.0 + p));
}

inline double pGenerate(int p, double xl, double xu, double rnd) {
  return p == -1? xl*pow(xu/xl, rnd):
    pow((1.0 - rnd)*powi(xl, p + 1) + rnd*powi(xu, p + 1), 1.0/double(1 + p));
}

inline double pXGenerate(double e, double xl, double dx, double rnd) {
  return e == 0.0? -xl*exp1m(rnd*log1m(-dx/xl)):
    -exp1m(log1m(rnd*exp1m(e*log1m(-dx/xl)))/e)*xl;
}

template <typename FloatType>
inline double relativeError(FloatType x, FloatType y) {
  return ( x == y ? 0.0 : double((x - y)/(abs(x) + abs(y))) );
}

template <typename T>
inline T absmin(const T & x, const T & y) {
  return abs(x) < abs(y)? x: y;
}

template <typename T>
inline T absmax(const T & x, const T & y) {
  return abs(x) > abs(y)? x: y;
}

template <typename T, typename U>
inline T sign(T x, U y) {
  return y > U()? abs(x): -abs(x);
}

template <int N, bool Inv>
struct Power: public MathType {};

template <int N>
struct Power<N,false> {
  static double pow(double x) { return x*Power<N-1,false>::pow(x); }
};

template <int N>
struct Power<N,true> {
  static double pow(double x) { return Power<N+1,true>::pow(x)/x; }
};

template <>
struct Power<0,true> {
  static double pow(double) { return 1.0; }
};

template <>
struct Power<0,false> {
  static double pow(double) { return 1.0; }
};

template <int N>
inline double Pow(double x) { return Power<N, (N < 0)>::pow(x); }

namespace Functions {

template <int N>
struct PowX: public MathType {

  static double primitive(double x) { 
    return Pow<N+1>(x)/double(N+1); 
  }

  static double integrate(double x0, double x1) {
    return primitive(x1) - primitive(x0);
  }

  static double generate(double x0, double x1, double R) {
    return pow(primitive(x0) + R*integrate(x0, x1), 1.0/double(N+1));
  }

};

template <>
inline double PowX<1>::generate(double x0, double x1, double R) {
  return std::sqrt(x0*x0 + R*(x1*x1 - x0*x0));
}

template <>
inline double PowX<0>::generate(double x0, double x1, double R) {
  return x0 + R*(x1 - x0);
}

template<>
inline double PowX<-1>::primitive(double x) {
  return log(x);
}

template <>
inline double PowX<-1>::integrate(double x0, double x1) {
  return log(x1/x0);
}

template <>
inline double PowX<-1>::generate(double x0, double x1, double R) {
  return x0*pow(x1/x0, R);
}

template <>
inline double PowX<-2>::generate(double x0, double x1, double R) {
  return x0*x1/(x1 - R*(x1 - x0));
}

template <>
inline double PowX<-3>::generate(double x0, double x1, double R) {
  return x0*x1/std::sqrt(x1*x1 - R*(x1*x1 - x0*x0));
}

template <int N>
struct Pow1mX: public MathType {

  static double primitive(double x) {
    return -PowX<N>::primitive(1.0 - x);
  }

  static double integrate(double x0, double x1) {
    return PowX<N>::integrate(1.0 - x1, 1.0 - x0);
  }

  static double generate(double x0, double x1, double R) {
    return 1.0 - PowX<N>::generate(1.0 - x1, 1.0 - x0, R);
  }

};

struct InvX1mX: public MathType {

  static double primitive(double x) {
    return log(x/(1.0 - x));
  }

  static double integrate(double x0, double x1) {
    return log(x1*(1.0 - x0)/(x0*(1.0 - x1)));
  }

  static double generate(double x0, double x1, double R) {
    double r = pow(x1*(1.0 - x0)/(x0*(1.0 - x1)), R)*x0/(1.0 - x0);
    return r/(1.0 + r);
  }

};

struct ExpX: public MathType {

  static double primitive(double x) { 
    return exp(x);
  }

  static double integrate(double x0, double x1) {
    return exp(x1) - exp(x0);
  }

  static double generate(double x0, double x1, double R) {
    return log(exp(x0) + R*(exp(x1) - exp(x0)));
  }

};  

template <int N, int D>
struct FracPowX: public MathType {

  static double primitive(double x) {
    double r = double(N)/double(D) + 1.0;
    return pow(x, r)/r;
  }

  static double integrate(double x0, double x1) {
    return primitive(x1) - primitive(x0);
  }

  static double generate(double x0, double x1, double R) {
    double r = double(N)/double(D) + 1.0;
    return pow(primitive(x0) + R*integrate(x0, x1), 1.0/r);
  }

};

}

}

}

#endif /* ThePEG_Math_H */

---