elem_math.h

Go to the documentation of this file.

#ifndef ELEM_MATH_H
#define ELEM_MATH_H

#include <itpp/base/itcompat.h>
#include <itpp/base/help_functions.h>
#include <itpp/base/converters.h>
#include <cstdlib> // required by std::abs()


namespace itpp
{


// -------------------- sqr function --------------------

inline double sqr(double x) { return (x * x); }
inline double sqr(const std::complex<double>& x)
{
  return (x.real() * x.real() + x.imag() * x.imag());
}
inline vec sqr(const vec &x) { return apply_function<double>(sqr, x); }
inline mat sqr(const mat &x) { return apply_function<double>(sqr, x); }
vec sqr(const cvec &x);
mat sqr(const cmat &x);


// -------------------- abs function --------------------

inline vec abs(const vec &x) { return apply_function<double>(std::fabs, x); }
inline mat abs(const mat &x) { return apply_function<double>(std::fabs, x); }
inline ivec abs(const ivec &x) { return apply_function<int>(std::abs, x); }
inline imat abs(const imat &x) { return apply_function<int>(std::abs, x); }
vec abs(const cvec &x);
mat abs(const cmat &x);


// -------------------- sign/sgn functions --------------------

inline double sign(double x)
{
  return (x == 0.0 ? 0.0 : (x < 0.0 ? -1.0 : 1.0));
}
inline vec sign(const vec &x) { return apply_function<double>(sign, x); }
inline mat sign(const mat &x) { return apply_function<double>(sign, x); }

inline double sgn(double x) { return sign(x); }
inline vec sgn(const vec &x) { return apply_function<double>(sign, x); }
inline mat sgn(const mat &x) { return apply_function<double>(sign, x); }

inline int sign_i(int x)
{
  return (x == 0 ? 0 : (x < 0 ? -1 : 1));
}
inline ivec sign_i(const ivec &x) { return apply_function<int>(sign_i, x); }
inline imat sign_i(const imat &x) { return apply_function<int>(sign_i, x); }

inline int sgn_i(int x) { return sign_i(x); }
inline ivec sgn_i(const ivec &x) { return apply_function<int>(sign_i, x); }
inline imat sgn_i(const imat &x) { return apply_function<int>(sign_i, x); }

inline int sign_i(double x)
{
  return (x == 0.0 ? 0 : (x < 0.0 ? -1 : 1));
}

// -------------------- sqrt function --------------------

inline vec sqrt(const vec &x) { return apply_function<double>(std::sqrt, x); }
inline mat sqrt(const mat &x) { return apply_function<double>(std::sqrt, x); }


// -------------------- gamma function --------------------

inline double gamma(double x) { return tgamma(x); }
inline vec gamma(const vec &x) { return apply_function<double>(tgamma, x); }
inline mat gamma(const mat &x) { return apply_function<double>(tgamma, x); }


// -------------------- rem function --------------------

inline double rem(double x, double y) { return fmod(x, y); }
inline vec rem(const vec &x, double y)
{
  return apply_function<double>(rem, x, y);
}
inline vec rem(double x, const vec &y)
{
  return apply_function<double>(rem, x, y);
}
inline mat rem(const mat &x, double y)
{
  return apply_function<double>(rem, x, y);
}
inline mat rem(double x, const mat &y)
{
  return apply_function<double>(rem, x, y);
}

// -------------------- mod function --------------------

inline int mod(int k, int n)
{
  return (n == 0) ? k : (k - n * floor_i(static_cast<double>(k) / n));
}


// -------------------- factorial coefficient function --------------------

double fact(int index);


// -------------------- binomial coefficient function --------------------

double binom(int n, int k);

int binom_i(int n, int k);

double log_binom(int n, int k);


// -------------------- greatest common divisor function --------------------

int gcd(int a, int b);


// -------------------- complex related functions --------------------

vec real(const cvec &x);
mat real(const cmat &x);
vec imag(const cvec &x);
mat imag(const cmat &x);

vec arg(const cvec &x);
mat arg(const cmat &x);
inline vec angle(const cvec &x) { return arg(x); }
inline mat angle(const cmat &x) { return arg(x); }

// Added due to a failure in MSVC++ .NET 2005, which crashes on this
// code.
#ifndef _MSC_VER
inline cvec conj(const cvec &x)
{
  return apply_function<std::complex<double> >(std::conj, x);
}
inline cmat conj(const cmat &x)
{
  return apply_function<std::complex<double> >(std::conj, x);
}
#else
cvec conj(const cvec &x);

cmat conj(const cmat &x);
#endif


} // namespace itpp

#endif // #ifndef ELEM_MATH_H

---