base.h

Go to the documentation of this file.

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef SP_BASE_H
#define SP_BASE_H

namespace sp
{

const double PI   = 3.14159265358979323846; 
const double PI_2 = 6.28318530717958647692;

arma_inline double sinc(double x)
{
  if (x == 0.0)
    return 1.0;
  else
    return std::sin(PI * x) / (PI * x);
}

arma_inline arma::vec sinc(const arma::vec &x)
{
  arma::vec out;
  out.copy_size(x);
  for (unsigned int n = 0; n < out.size(); n++)
  {
    out(n) = sinc(x(n));
  }
  return out;
}

arma_inline double besseli0(double x)
{
  double y = 1.0, s = 1.0, x2 = x * x, n = 1.0;
  while (s > y * 1.0e-9)
  {
    s *= x2 / 4.0 / (n * n);
    y += s;
    n += 1;
  }
  return y;
}

template <typename T> double angle(const std::complex<T> &x)
{
  return std::arg(x);
}

arma_inline arma::vec angle(const arma::cx_vec &x)
{
  arma::vec P;
  P.copy_size(x);
  for (unsigned int r = 0; r < x.n_rows; r++)
    P(r) = std::arg(x(r));
  return P;
}

arma_inline arma::mat angle(const arma::cx_mat &x)
{
  arma::mat P;
  P.copy_size(x);
  for (unsigned int r = 0; r < x.n_rows; r++)
    for (unsigned int c = 0; c < x.n_cols; c++)
      P(r, c) = std::arg(x(r, c));
  return P;
}

arma_inline arma::vec unwrap(const arma::vec &x)
{
  arma::vec P;
  double pacc = 0, pdiff = 0;
  const double thr = PI * 170 / 180;
  P.copy_size(x);
  P(0) = x(0);
  for (unsigned int r = 1; r < x.n_rows; r++)
  {
    pdiff = x(r) - x(r - 1);
    if (pdiff >= thr)
      pacc += -PI_2;
    if (pdiff <= -thr)
      pacc += PI_2;
    P(r) = pacc + x(r);
  }
  return P;
}


arma_inline arma::vec timevec(const int N, const double Fs)
{
  return arma::regspace(0, N - 1.0) / Fs;
}

template <typename T> arma::Col<T> fftshift(const arma::Col<T> &Pxx)
{
  arma::Col<T> x(Pxx.n_elem);
  x = shift(Pxx, floor(Pxx.n_elem / 2));
  return x;
}

template <typename T> arma::Col<T> ifftshift(const arma::Col<T> &Pxx)
{
  arma::Col<T> x(Pxx.n_elem);
  x = shift(Pxx, -ceil(Pxx.n_elem / 2));
  return x;
}

template <typename T> arma::Mat<T> fftshift(const arma::Mat<T> &Pxx)
{
  arma::uword R = Pxx.n_rows;
  arma::uword C = Pxx.n_cols;
  arma::Mat<T> x(R, C);
  x = arma::shift(Pxx, static_cast<arma::sword>(floor(R / 2)), 0);
  x = arma::shift(x, static_cast<arma::sword>(floor(C / 2)), 1);
  return x;
}

template <typename T> arma::Mat<T> ifftshift(const arma::Mat<T> &Pxx)
{
  arma::uword R = Pxx.n_rows;
  arma::uword C = Pxx.n_cols;
  arma::Mat<T> x(R, C);
  x = shift(Pxx, -ceil(R / 2), 0);
  x = shift(x, -ceil(C / 2), 1);
  return x;
}



arma_inline std::string sp_version(void)
{
  return std::to_string(SP_VERSION_MAJOR) + "." +
         std::to_string(SP_VERSION_MINOR) + "." +
         std::to_string(SP_VERSION_PATCH);
}

// err_handler("Error string")
//      Prints an error message, waits for input and
//      then exits with error
#define err_handler(msg)                                                       \
  {                                                                            \
    std::cout << "SigPack Error [" << __FILE__ << "@" << __LINE__              \
              << "]: " << msg << std::endl;                                    \
    std::cin.get();                                                            \
    exit(EXIT_FAILURE);                                                        \
  }

// wrn_handler("Warning string")
//      Prints an warning message
#define wrn_handler(msg)                                                       \
  {                                                                            \
    std::cout << "SigPack warning [" << __FILE__ << "@" << __LINE__            \
              << "]: " << msg << std::endl;                                    \
  }

} // namespace sp
#endif