modulator.h

Go to the documentation of this file.

// 
// SPUC - Signal processing using C++ - A DSP library
/*---------------------------------------------------------------------------*
 *                                   IT++                                    *
 *---------------------------------------------------------------------------*
 * Copyright (c) 1995-2002 by Tony Ottosson, Thomas Eriksson, Pål Frenger,   *
 * Tobias Ringström, and Jonas Samuelsson.                                   *
 *                                                                           *
 * Permission to use, copy, modify, and distribute this software and its     *
 * documentation under the terms of the GNU General Public License is hereby *
 * granted. No representations are made about the suitability of this        *
 * software for any purpose. It is provided "as is" without expressed or     *
 * implied warranty. See the GNU General Public License for more details.    *
 *---------------------------------------------------------------------------*/

#ifndef __modulator_h
#define __modulator_h

#include <iostream>
#include <vector.h>
#include <specmat.h>
namespace SPUC {
class Modulator_1d {
public:
    Modulator_1d(const vec &insymbols = "0", const ivec &inbitmap = "0");
    virtual ~Modulator_1d() { }
    virtual vec modulate(const ivec &symbolnumbers);
    virtual ivec demodulate(const vec &signal);

    virtual vec modulate_bits(const bvec &bits);
    virtual bvec demodulate_bits(const vec &signal);

    void set(const vec &insymbols, const ivec &inbitmap);

    vec get_symbols(void);
    ivec get_bitmap(void);
 protected:
    int k;
    int M;
    ivec bitmap;
    vec symbols;
};

class Modulator_2d {
 public:
  Modulator_2d(const cvec &insymbols = zeros_c(1), const ivec &inbitmap = "0");
  virtual ~Modulator_2d() {}
  virtual cvec modulate(const ivec &symbolnumbers);
  virtual ivec demodulate(const cvec &signal);
  
  virtual cvec modulate_bits(const bvec &bits);
  virtual bvec demodulate_bits(const cvec &signal);
  
  void demodulate_soft_bits(const cvec &rx_symbols, double N0, vec &soft_bits);
  
  void demodulate_soft_bits(const cvec &rx_symbols, const cvec &chan, double N0, vec &soft_bits);
  
  void demodulate_soft_bits_approx(const cvec &rx_symbols, double N0, vec &soft_bits);
  
  void demodulate_soft_bits_approx(const cvec &rx_symbols, const cvec &chan, double N0, vec &soft_bits);
  
  void set(const cvec &insymbols, const ivec &inbitmap);
  
  cvec get_symbols();
  ivec get_bitmap();

 protected:

  int k;
  int M;
  ivec bitmap;
  cvec symbols;
  
  void calculate_softbit_matricies(ivec inbitmap);
  
  imat S0;   
  imat S1;   
  bool soft_bit_mapping_matrices_calculated;
};

class MOD_BPSK {
public:
  MOD_BPSK() { }
    virtual ~MOD_BPSK() {}
    void modulate_bits(const bvec &bits, vec &out);
    vec modulate_bits(const bvec &bits);
    void modulate_bits(const bvec &bits, cvec &out);
    void demodulate_bits(const vec &signal, bvec &out);
    bvec demodulate_bits(const vec &signal);

    void demodulate_bits(const cvec &signal, bvec &out);

    void demodulate_soft_bits(const vec &rx_symbols, double N0, vec &soft_bits);

    void demodulate_soft_bits(const cvec &rx_symbols, const cvec &channel, double N0, vec &soft_bits);
};

class MOD_PAM {
public:
    MOD_PAM(int Mary) { set_M(Mary); }
    virtual ~MOD_PAM() { }
    void modulate_bits(const bvec &bits, vec &out);
    vec modulate_bits(const bvec &bits);
    void demodulate_bits(const vec &signal, bvec &out);
    bvec demodulate_bits(const vec &signal);
    void set_M(int Mary);

    //vec modulate(const svec &symbolnumbers);
    //svec demodulate(const vec &signal);

 protected:
    int k;
    int M;
    bmat bitmap; 
    ivec bits2symbols;
    vec symbols;
    double average_energy;
    double scaling_factor;
};

class MOD_QPSK {
 public:
  MOD_QPSK() {}
  virtual ~MOD_QPSK() {}
  void modulate_bits(const bvec &bits, cvec &out);
  cvec modulate_bits(const bvec &bits);
  void demodulate_bits(const cvec &signal, bvec &out);
  bvec demodulate_bits(const cvec &signal);
  void demodulate_soft_bits(const cvec &rx_symbols, double N0, vec &soft_bits);
  void demodulate_soft_bits(const cvec &rx_symbols, const cvec &channel, double N0, vec &soft_bits);
  
  //cvec modulate(const svec &symbolnumbers);
  //svec demodulate(const cvec &signal);
};

class MOD_PSK {
 public:
  MOD_PSK(int Mary) { set_M(Mary); }
  virtual ~MOD_PSK() { }
  void modulate_bits(const bvec &bits, cvec &out);
  cvec modulate_bits(const bvec &bits);
  void demodulate_bits(const cvec &signal, bvec &out);
  bvec demodulate_bits(const cvec &signal);

  void demodulate_soft_bits(const cvec &rx_symbols, double N0, vec &soft_bits);
  void demodulate_soft_bits(const cvec &rx_symbols, const cvec &channel, double N0, vec &soft_bits);

  void set_M(int Mary);

  //cvec modulate(const svec &symbolnumbers);
  //svec demodulate(const cvec &signal);

 protected:
  int k;
  int M;
  bmat bitmap; 
  ivec bits2symbols; 
  cvec symbols;
  double average_energy;
  imat S0; 
  imat S1; 
};

class MOD_QAM {
 public:
  MOD_QAM(int Mary) { set_M(Mary); }
  virtual ~MOD_QAM() { }
  void modulate_bits(const bvec &bits, cvec &out);
  cvec modulate_bits(const bvec &bits);
  void demodulate_bits(const cvec &signal, bvec &out);
  bvec demodulate_bits(const cvec &signal);

  void demodulate_soft_bits(const cvec &rx_symbols, double N0, vec &soft_bits);

  void demodulate_soft_bits(const cvec &rx_symbols, const cvec &channel, double N0, vec &soft_bits);

  void set_M(int Mary);
  cvec get_symbols() { return symbols; }
  ivec get_bitmap() { return bits2symbols; }

  //cvec modulate(const svec &symbolnumbers);
  //svec demodulate(const cvec &signal);

 protected:
  int k;
  int M;
  int L;
  bmat bitmap; 
  ivec bits2symbols; 
  cvec symbols;
  double average_energy;
  double scaling_factor;
  imat S0; 
  imat S1; 
};
}
#endif // __modulator_h

---