misc.h

Go to the documentation of this file.

#ifndef MATH_MISC_H
#define MATH_MISC_H

#include "math.h"

namespace Math {


int quadratic(double a, double b, double c, double& x1, double& x2);
int cubic(double a, double b, double c, double d, double x[3]);
double pythag(double a, double b);
double pythag_leg(double a,double c);
double Sinc(double x);
double Sinc_Dx(double x);
double dFactorial(unsigned int n);
double dLogFactorial(unsigned int n);
double dChoose(unsigned int n,unsigned int k);
double dLogChoose(unsigned int n,unsigned int k);
double TaylorCoeff(double x,unsigned int n);
double Gamma(double x);
double LogGamma(double x);
double GammaInv(double x);
double Beta(double a,double b);
double LogBeta(double a,double b);
double NormalizedIncompleteBeta(double a,double b,double x);
double Erf(double x);
double ErfComplimentary(double x);

inline int FuzzySign(double x,double eps=dEpsilon) { return (x>eps?1:(x<-eps?-1:0)); }
inline bool OpposingSigns_pos(double a,double b) { return (a<dZero) != (b<dZero); }
inline bool OpposingSigns_neg(double a,double b) { return (a<=dZero) != (b<=dZero); }


int quadratic(float a, float b, float c, float& x1, float& x2);
int cubic(float a, float b, float c, float d, float x[3]);
float pythag(float a, float b);
float pythag_leg(float a,float c);
float Sinc(float x);
float Sinc_Dx(float x);
float fFactorial(unsigned int n);
float fLogFactorial(unsigned int n);
float fChoose(unsigned int n,unsigned int k);
float fLogChoose(unsigned int n,unsigned int k);
float TaylorCoeff(float x,unsigned int n);
float Gamma(float x);
float LogGamma(float x);
float GammaInv(float x);
float Beta(float a,float b);
float LogBeta(float a,float b);
float NormalizedIncompleteBeta(float a,float b,float x);
float Erf(float x);
float ErfComplimentary(float x);

inline int FuzzySign(float x,float eps=fEpsilon) { return (x>eps?1:(x<-eps?-1:0)); }
inline bool OpposingSigns_pos(float a,float b) { return (a<fZero) != (b<fZero); }
inline bool OpposingSigns_neg(float a,float b) { return (a<=fZero) != (b<=fZero); }



template <class T>
T IntegerPower(const T x, int i)
{
  if(i<0) return 1.0/IntegerPower(x,-i);
  if(i==0) return 1;
  if(i&1)       //odd
    { T y=IntegerPower(x,(i-1)>>1); return x*y*y; }
  else //even
    { T y=IntegerPower(x,i>>1); return y*y; }
}

inline unsigned int Factorial(unsigned int n)
{
  //assert(n <= 12); //otherwise, it'll cause overflow with 32-bit arith
  int x=1;
  for(unsigned int i=1;i<=n;i++) x*=i;
  return x;
}
 
inline unsigned int FactorialTruncated(unsigned int n,unsigned int k)
{
  unsigned int fact=1;
  for(unsigned int j=0;j<k;j++) fact*=(n-j);
  return fact;
}

inline unsigned int Choose(unsigned int n,unsigned int k)
{
  if(2*k > n) return FactorialTruncated(n,n-k)/Factorial(n-k);
  else return FactorialTruncated(n,k)/Factorial(k);
}

inline Real rFactorial(unsigned int n) { return dFactorial(n); }
inline Real LogFactorial(unsigned int n) { return dLogFactorial(n); }
inline Real rChoose(unsigned int n,unsigned int k) { return dChoose(n,k); }
inline Real LogChoose(unsigned int n,unsigned int k) { return dLogChoose(n,k); }

} //namespace Math

#endif