modulator_nd.h

Go to the documentation of this file.

#ifndef MODULATOR_ND_H
#define MODULATOR_ND_H

#include <itpp/base/vec.h>
#include <itpp/base/array.h>
#include <itpp/comm/llr.h>

namespace itpp
{

// ----------------------------------------------------------------------
// Modulator_ND
// ----------------------------------------------------------------------

class Modulator_ND
{
public:
  enum Soft_Demod_Method {
    FULL_ENUM_LOGMAP,
    ZF_LOGMAP
  };

  Modulator_ND(LLR_calc_unit llrcalc_in = LLR_calc_unit()):
      llrcalc(llrcalc_in) {}
  ~Modulator_ND() {}

  void set_llrcalc(LLR_calc_unit llrcalc_in) { llrcalc = llrcalc_in; };

  LLR_calc_unit get_llrcalc() const { return llrcalc; }

  int get_dim() const { return nt; }

  ivec get_k() const { return k; }

  ivec get_M() const { return M; }

protected:
  int nt;
  LLR_calc_unit llrcalc;
  ivec k;
  ivec M;
  Array<bmat> bitmap;
  Array<ivec> bits2symbols;

  QLLRvec probabilities(QLLR l); // some abuse of what QLLR stands for...

  Array<QLLRvec> probabilities(const QLLRvec &l);

  void update_LLR(const Array<QLLRvec> &logP_apriori, const ivec &s,
                  QLLR scaled_norm, QLLRvec &num, QLLRvec &denom);

  void update_LLR(const Array<QLLRvec> &logP_apriori, int s,
                  QLLR scaled_norm, int j, QLLRvec &num, QLLRvec &denom);
};


// ----------------------------------------------------------------------
// Modulator_NRD
// ----------------------------------------------------------------------

class Modulator_NRD : public Modulator_ND
{
public:
  Modulator_NRD() {}
  ~Modulator_NRD() {}

  Array<vec> get_symbols() const { return symbols; }

  void modulate_bits(const bvec &bits, vec &symbols) const;

  vec modulate_bits(const bvec &bits) const;

  void demodulate_soft_bits(const vec &y, const mat &H, double sigma2,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori,
                            Soft_Demod_Method method);

  QLLRvec demodulate_soft_bits(const vec &y, const mat &H, double sigma2,
                               const QLLRvec &LLR_apriori,
                               Soft_Demod_Method method);

  void demodulate_soft_bits(const vec &y, const mat &H, double sigma2,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori);

  void demodulate_soft_bits(const vec &y, const vec &h, double sigma2,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori);


  friend std::ostream &operator<<(std::ostream &os, const Modulator_NRD &m);

protected:
  Array<vec> symbols;

  void update_norm(double &norm, int k, int sold, int snew, const vec &ytH,
                   const mat &HtH, const ivec &s);
};

std::ostream &operator<<(std::ostream &os, const Modulator_NRD &m);


// ----------------------------------------------------------------------
// Modulator_NCD
// ----------------------------------------------------------------------

class Modulator_NCD : public Modulator_ND
{
public:
  Modulator_NCD() {}
  ~Modulator_NCD() {}

  Array<cvec> get_symbols() const { return symbols; }

  void modulate_bits(const bvec &bits, cvec &symbols) const;

  cvec modulate_bits(const bvec &bits) const;


  void demodulate_soft_bits(const cvec &y, const cmat &H, double sigma2,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori,
                            Soft_Demod_Method method);

  QLLRvec demodulate_soft_bits(const cvec &y, const cmat &H, double sigma2,
                               const QLLRvec &LLR_apriori,
                               Soft_Demod_Method method);

  void demodulate_soft_bits(const cvec &y, const cmat &H, double sigma2,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori);

  void demodulate_soft_bits(const cvec &y, const cvec &H, double sigma2,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori);

  friend std::ostream &operator<<(std::ostream &os, const Modulator_NCD &m);

protected:
  Array<cvec> symbols;

  void update_norm(double &norm, int k, int sold, int snew, const cvec &ytH,
                   const cmat &HtH, const ivec &s);
};

std::ostream &operator<<(std::ostream &os, const Modulator_NCD &m);


// ----------------------------------------------------------------------
// ND_UPAM
// ----------------------------------------------------------------------

class ND_UPAM : public Modulator_NRD
{
public:
  ND_UPAM(int nt = 1, int Mary = 2);
  ~ND_UPAM() {}

  void set_M(int nt = 1, int Mary = 2);

  void set_M(int nt = 1, ivec Mary = "2");

  int sphere_decoding(const vec &y, const mat &H, double rmin, double rmax,
                      double stepup, QLLRvec &detected_bits);

private:
  // Sphere decoding search with Schnorr Eucner strategy.
  int sphere_search_SE(const vec &y, const mat &H, const imat &zrange,
                       double r, ivec &zhat);

  vec spacing;  // spacing between the constellation points

  inline int sign_nozero_i(int a) { return (a > 0 ? 1 : -1); }
  inline int sign_nozero_i(double a) { return (a > 0.0 ? 1 : -1); }
};

// ----------------------------------------------------------------------
// ND_UQAM
// ----------------------------------------------------------------------

class ND_UQAM : public Modulator_NCD
{
public:
  ND_UQAM(int nt = 1, int Mary = 4);
  ~ND_UQAM() {}

  void set_M(int nt = 1, int Mary = 4);

  void set_M(int nt = 1, ivec Mary = "4");

protected:
  ivec L;  
};

// ----------------------------------------------------------------------
// ND_UPSK
// ----------------------------------------------------------------------

class ND_UPSK : public Modulator_NCD
{
public:
  ND_UPSK(int nt = 1, int Mary = 4);
  ~ND_UPSK() {}

  void set_M(int nt = 1, int Mary = 4);

  void set_M(int nt = 1, ivec Mary = "4");
};


} // namespace itpp

#endif // #ifndef MODULATOR_ND_H

---