scalfunc.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------*
 *                                   IT++                                    *
 *---------------------------------------------------------------------------*
 * Copyright (c) 1995-2002 by Tony Ottosson, Thomas Eriksson, Pål Frenger,   *
 * Tobias Ringström, and Jonas Samuelsson.                                   *
 *                                                                           *
 * Permission to use, copy, modify, and distribute this software and its     *
 * documentation under the terms of the GNU General Public License is hereby *
 * granted. No representations are made about the suitability of this        *
 * software for any purpose. It is provided "as is" without expressed or     *
 * implied warranty. See the GNU General Public License for more details.    *
 *---------------------------------------------------------------------------*/

#ifndef __scalfunc_h
#define __scalfunc_h

#include <cmath>
#include <algorithm>
#include <cstdlib>

namespace SPUC {
#ifndef DOXYGEN_SHOULD_SKIP_THIS

#ifndef M_PI
#  define M_PI 3.14159265358979323846
#endif

#ifndef PI
const double PI=M_PI;
#endif

const float maxfloat=1.0E30F;

#ifndef M_LOG2E
#  define M_LOG2E       1.4426950408889634074
#endif
#ifndef M_SQRT2
#  define M_SQRT2       1.41421356237309504880
#endif

#endif //DOXYGEN_SHOULD_SKIP_THIS



// These functions are part of C99. But apparently not in Visual C++.
#ifdef _MSC_VER

double erf(double x);

double erfc(double x);
#endif

double Qfunc(double x);

double erfinv(double x);

double gamma(double x);

// Not supported on Visual C++
#ifdef _MSC_VER
double lgamma(double x);
extern int signgam;
double cbrt(double x);
#endif

#ifndef __CYGWIN__

inline double log2(double x) { return M_LOG2E*log(x); }
#endif 

inline double logb(double b, double x) { return log(x)/log(b); }

inline double sinc(double x) { return ( (x==0) ? 1 : (sin(PI*x)/PI/x) ); }



#ifdef _MSC_VER

inline double rint(double x) { return floor(x+0.5); }
#endif

inline int round_i(double x) { return int(rint(x)); }
inline int ceil_i(double x) { return int(ceil(x)); }
inline int floor_i(double x) { return int(floor(x)); }
inline double round(double x) { return rint(x); }

inline bool is_int(double x) { double dummy; return (modf(x, &dummy) == 0.0); }

inline bool is_even(int x) { return ((x&1) == 0); }



inline int needed_bits(int n)
{
    int b=0;
        //    it_assert(n>0,"needed_bits(n): n must be greater than zero!");
    n--; while (n) {    n>>=1; b++; }
    return b;
}

inline int needed_bits(double n) { 
        //      it_assert(n>0,"n_bits()"); 
        return int(ceil(log2(n))); }

#define pow2i(x) ((x)<0 ? 0 : (1<<(x)))

inline int pow2(int x) { return pow2i(x); }

inline double pow2(double x) { return pow(2.0, x); }
inline double pow10(double x) { return pow(10.0, x); }

inline double dB(double x) { return 10.0 * log10(x); }
inline double inv_dB(double x) { return pow(10.0, x/10.0); }



inline int gray_code(int x) { return x^(x>>1); }

double binom(int n, int k);

int binom_i(int n, int k);

double log_binom(int n, int k);

inline double rad_to_deg(double x) { return 180.0 / M_PI * x; }
inline double deg_to_rad(double x) { return M_PI / 180.0 * x; }

#if !defined(__GLIBC__) || __GLIBC__ < 2



double asinh(double x);
double acosh(double x);
double atanh(double x);

#endif



inline double sqr(double x) { return x*x; }
inline double rem(double x, double y) {return fmod(x,y);}
inline double sign(double x) { return x==0.0 ? 0.0 : (x<0.0 ? -1.0 : 1.0); }
inline double sgn(double x) { return x==0.0 ? 0.0 : (x<0.0 ? -1.0 : 1.0); }

inline signed char abs(signed char x) { return x>0 ? x : -x; }
inline short abs(short x) { return x>0 ? x : -x; }
#ifdef _MSC_VER // Included in cmath for gcc

inline double abs(double x) { return fabs(x); }
#endif

//double sigmoid(double x) { return 1.0/(1.0+exp(-x)); }

double fact(int index);

long mod(long k, long n);

long gcd(long a, long b);

double integrate(double (*f)(double), double A, double B, double tol=0.001);

}
#endif // __scalfunc_h

---