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>
#include <itpp/itexports.h>
#include <itpp/base/base_exports.h>

namespace itpp
{

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

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

  Modulator_ND(LLR_calc_unit llrcalc_in = LLR_calc_unit()):
    llrcalc(llrcalc_in), demod_initialized(false) {}
  virtual ~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 bits_per_symbol() const {
    return k;
  }

  ivec get_M() const {
    return M;
  }

  Array<ivec> get_bits2symbols() const {
    return bits2symbols;
  }

  Array<bmat> get_bitmap() const {
    return bitmap;
  }

protected:
  int nt;
  int nb;
  LLR_calc_unit llrcalc;
  ivec k;
  ivec M;
  bool demod_initialized;
  Array<bmat> bitmap;
  Array<ivec> bits2symbols;
  double gaussnorm;  
  itpp::vec hnorms;
  itpp::QLLRvec Qnorms;
  itpp::QLLRvec llrapr;
  itpp::ivec bpos2cpos;
  itpp::ivec bitcumsum;
  itpp::Array<itpp::Vec<unsigned> > gray2dec;
  QLLRvec probabilities(QLLR l); // some abuse of what QLLR stands for...
  Array<QLLRvec> probabilities(const QLLRvec &l);
  void marginalize_bits(itpp::QLLRvec& llr, Soft_Demod_Method method) const;
  void demodllrbit0(itpp::QLLR& llr) const;
  void demodllrbit1(itpp::QLLR& llr) const;
  void demodllrbit2(itpp::QLLR& llr) const;
  void demodmaxbit0(itpp::QLLR& maxllr) const;
  void demodmaxbit1(itpp::QLLR& maxllr) const;
  void demodmaxbit2(itpp::QLLR& maxllr) const;

  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 ITPP_EXPORT Modulator_NRD : public Modulator_ND
{
public:
  Modulator_NRD() {}
  virtual ~Modulator_NRD() {}

  Array<vec> get_symbols() const;

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

  vec modulate_bits(const bvec &bits) const;

  void init_soft_demodulator(const itpp::mat& H, const double& sigma2);

        
  void demodulate_soft_bits(const vec &y,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori,
                            Soft_Demod_Method method = FULL_ENUM_LOGMAP);

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


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


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

  friend ITPP_EXPORT 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);

  void hxnormupdate(itpp::vec& Hx, unsigned& bitstring, unsigned& ind, unsigned bit);

  void yxnormupdate(double& yx, itpp::QLLR& lapr, unsigned& bitstring, unsigned& ind, unsigned bit);

        itpp::mat H;
        itpp::Array<itpp::Array<itpp::vec> > hspacings;
  itpp::Array<itpp::vec> yspacings;
};

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


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

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

  Array<cvec> get_symbols() const;

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

  cvec modulate_bits(const bvec &bits) const;

  void init_soft_demodulator(const itpp::cmat& H, const double& sigma2);

  void demodulate_soft_bits(const cvec &y,
                            const QLLRvec &LLR_apriori,
                            QLLRvec &LLR_aposteriori,
                            Soft_Demod_Method method = FULL_ENUM_LOGMAP);


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

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


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

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

protected:
  Array<cvec> symbols;
        itpp::cmat H;
        itpp::Array<itpp::Array<itpp::cvec> > hspacings;
  itpp::Array<itpp::vec> yspacings;
        void hxnormupdate(itpp::cvec& Hx, unsigned& bitstring, unsigned& ind, unsigned bit);
        void yxnormupdate(double& yx, itpp::QLLR& lapr, unsigned& bitstring, unsigned& ind, unsigned bit);
};

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


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

class ITPP_EXPORT ND_UPAM : public Modulator_NRD
{
public:
  ND_UPAM(int nt = 1, int Mary = 2);
  virtual ~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 ITPP_EXPORT ND_UQAM : public Modulator_NCD
{
public:
  ND_UQAM(int nt = 1, int Mary = 4);
  virtual ~ND_UQAM() {}

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

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

  void set_constellation_points(const int nth, const cvec& inConstellation, const ivec& in_bit2symbols);

protected:
  ivec L;  
};

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

class ITPP_EXPORT ND_UPSK : public Modulator_NCD
{
public:
  ND_UPSK(int nt = 1, int Mary = 4);
  virtual ~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