punct_convcode.h

Go to the documentation of this file.

#ifndef PUNCT_CONVCODE_H
#define PUNCT_CONVCODE_H

#include <itpp/base/vec.h>
#include <itpp/base/mat.h>
#include <itpp/base/array.h>
#include <itpp/comm/convcode.h>
#include <itpp/itexports.h>

namespace itpp
{

class ITPP_EXPORT Punctured_Convolutional_Code : public Convolutional_Code
{
public:
  Punctured_Convolutional_Code(void) : Convolutional_Code() {}
  virtual ~Punctured_Convolutional_Code(void) {}

  void set_code(const CONVOLUTIONAL_CODE_TYPE type_of_code, int inverse_rate, int constraint_length)
  { Convolutional_Code::set_code(type_of_code, inverse_rate, constraint_length); }
  void set_generator_polynomials(const ivec &gen, int constraint_length)
  { Convolutional_Code::set_generator_polynomials(gen, constraint_length); }
  ivec get_generator_polynomials() const { return gen_pol; }

  virtual double get_rate() const { return rate; }

  void set_method(const CONVOLUTIONAL_CODE_METHOD method) { Convolutional_Code::set_method(method); }

  void set_puncture_matrix(const bmat &pmatrix); // add test of matrix size
  bmat get_puncture_matrix() const { return puncture_matrix; }
  int get_puncture_period() const { return Period; }

  void init_encoder() { encoder_state = start_state; }

  void encode(const bvec &input, bvec &output);
  bvec encode(const bvec &input) { bvec output; encode(input, output); return output; }

  void encode_trunc(const bvec &input, bvec &output);
  bvec encode_trunc(const bvec &input) { bvec output; encode_trunc(input, output); return output; }

  void encode_tail(const bvec &input, bvec &output);
  bvec encode_tail(const bvec &input) { bvec output; encode_tail(input, output); return output; }

  void encode_tailbite(const bvec &input, bvec &output);
  bvec encode_tailbite(const bvec &input)
  { bvec output; encode_tailbite(input, output); return output; }


  virtual void decode(const vec &received_signal, bvec &output);
  virtual bvec decode(const vec &received_signal) { bvec output; decode(received_signal, output); return output; }

  // ------------ Hard-decision decoding is not implemented -------------------
  virtual void decode(const bvec &coded_bits, bvec &decoded_bits);
  virtual bvec decode(const bvec &coded_bits);

  void decode_trunc(const vec &received_signal, bvec &output);
  bvec decode_trunc(const vec &received_signal) { bvec output; decode_trunc(received_signal, output); return output; }

  void decode_tail(const vec &received_signal, bvec &output);
  bvec decode_tail(const vec &received_signal) { bvec output; decode_tail(received_signal, output); return output; }

  void decode_tailbite(const vec &received_signal, bvec &output);
  bvec decode_tailbite(const vec &received_signal)
  { bvec output; decode_tailbite(received_signal, output); return output; }

  /*
    \brief Calculate the inverse sequence

    Assumes that encode_tail is used in the encoding process. Returns false if there is an error in the coded sequence
    (not a valid codeword).
  */
  bool inverse_tail(const bvec coded_sequence, bvec &input);

  bool catastrophic(void);

  void distance_profile(ivec &dist_prof, int time, int dmax = 100000, bool reverse = false);

  void calculate_spectrum(Array<ivec> &spectrum, int dmax, int no_terms);

  void calculate_spectrum(Array<ivec> &spectrum, int time, int dmax, int no_terms, int block_length = 0);

  int fast(Array<ivec> &spectrum, int time, int dfree, int no_terms, int d_best_so_far = 0, bool test_catastrophic = false);

protected:
  int weight(const int state, const int input, int time);
  void weight(const int state, int &w0, int &w1, int time);
  int weight_reverse(const int state, const int input, int time);
  void weight_reverse(const int state, int &w0, int &w1, int time);

  int Period;
  int total;
  bmat puncture_matrix;
};

} // namespace itpp

#endif // #ifndef PUNCT_CONVCODE_H