log_exp.h

Go to the documentation of this file.

#ifndef LOG_EXP_H
#define LOG_EXP_H

#include <itpp/base/help_functions.h>
#include <itpp/itexports.h>

namespace itpp
{


// ----------------------------------------------------------------------
// scalar functions
// ----------------------------------------------------------------------

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

inline int pow2i(int x) { return ((x < 0) ? 0 : (1 << 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, 0.1 * x); }

inline int int2bits(int n)
{
  it_assert(n >= 0, "int2bits(): Improper argument value");

  if (n == 0)
    return 1;

  int b = 0;
  while (n) {
    n >>= 1;
    ++b;
  }
  return b;
}

inline int levels2bits(int n)
{
  it_assert(n > 0, "levels2bits(): Improper argument value");
  return int2bits(--n);
}

const double log_double_max = std::log(std::numeric_limits<double>::max());
const double log_double_min = std::log(std::numeric_limits<double>::min());

inline double trunc_log(double x)
{
  if (std::numeric_limits<double>::is_iec559) {
    if (x == std::numeric_limits<double>::infinity())
      return log_double_max;
    if (x <= 0)
      return log_double_min;
  }
  return std::log(x);
}

inline double trunc_exp(double x)
{
  if (std::numeric_limits<double>::is_iec559
      && (x >= log_double_max))
    return std::numeric_limits<double>::max();
  return std::exp(x);
}


ITPP_EXPORT double log_add(double log_a, double log_b);


// ----------------------------------------------------------------------
// functions on vectors and matrices
// ----------------------------------------------------------------------

inline vec exp(const vec &x)
{
  return apply_function<double>(std::exp, x);
}
inline cvec exp(const cvec &x)
{
  return apply_function<std::complex<double> >(std::exp, x);
}
inline mat exp(const mat &m)
{
  return apply_function<double>(std::exp, m);
}
inline cmat exp(const cmat &m)
{
  return apply_function<std::complex<double> >(std::exp, m);
}

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

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

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

inline vec log(const vec &x)
{
  return apply_function<double>(std::log, x);
}
inline mat log(const mat &x)
{
  return apply_function<double>(std::log, x);
}
inline cvec log(const cvec &x)
{
  return apply_function<std::complex<double> >(std::log, x);
}
inline cmat log(const cmat &x)
{
  return apply_function<std::complex<double> >(std::log, x);
}

// Cygwin defines log2 macro conflicting with IT++ functions
#if defined(log2)
#  undef log2
#endif

ITPP_EXPORT vec log2(const vec &x);
ITPP_EXPORT mat log2(const mat &x);

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

inline vec logb(double b, const vec &x)
{
  return apply_function<double>(itpp::logb, b, x);
}
inline mat logb(double b, const mat &x)
{
  return apply_function<double>(itpp::logb, b, x);
}

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

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

inline ivec int2bits(const ivec& v)
{
  return apply_function<int>(int2bits, v);
}

inline ivec levels2bits(const ivec& v)
{
  return apply_function<int>(levels2bits, v);
}


} // namespace itpp

#endif // #ifndef LOG_EXP_H