convcode.h

Go to the documentation of this file.

#ifndef CONVCODE_H
#define CONVCODE_H

#include <itpp/base/vec.h>
#include <itpp/base/mat.h>
#include <itpp/base/array.h>
#include <itpp/base/binary.h>
#include <itpp/comm/channel_code.h>
#include <itpp/itexports.h>
#include <itpp/base/base_exports.h>

namespace itpp
{

enum CONVOLUTIONAL_CODE_TYPE {MFD, ODS};

enum CONVOLUTIONAL_CODE_METHOD {Trunc, Tail, Tailbite};


class ITPP_EXPORT Convolutional_Code : public Channel_Code
{
public:
  Convolutional_Code(void): K(0), start_state(0), cc_method(Tail) {
    set_code(MFD, 2, 7);
    init_encoder();
  }

  virtual ~Convolutional_Code(void) {}

  void set_method(const CONVOLUTIONAL_CODE_METHOD method) {
    cc_method = method;
  }

  void set_code(const CONVOLUTIONAL_CODE_TYPE type_of_code, int inverse_rate,
                int constraint_length);

  void set_generator_polynomials(const ivec &gen, int constraint_length);
  ivec get_generator_polynomials(void) const { return gen_pol; }

  void reset();



  virtual void encode(const bvec &input, bvec &output);
  virtual 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;
  }


  void encode_bit(const bin &input, bvec &output);
  bvec encode_bit(const bin &input) {
    bvec output;
    encode_bit(input, 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);


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


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


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


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


  virtual double get_rate(void) const { return rate; }


  void set_start_state(int state) {
    it_error_if((state < 0) || ((state >= (1 << m)) && m != 0),
                "Convolutional_Code::set_start_state(): Invalid start state");
    start_state = state;
  }

  void init_encoder() { encoder_state = start_state; }

  int get_encoder_state(void) const { return encoder_state; }


  void set_truncation_length(const int length) {
    it_error_if(length < K, "Convolutional_Code::set_truncation_length(): "
                "Truncation length shorter than K");
    trunc_length = length;
  }

  int get_truncation_length(void) const { return trunc_length; }


  bool catastrophic(void);


  bool inverse_tail(const bvec coded_sequence, bvec &input);


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

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

  int fast(Array<ivec> &spectrum, const int dfree, const int no_terms,
           const int Cdfree = 1000000, const bool test_catastrophic = false);

protected:
  int next_state(const int instate, const int input) {
    return ((instate >> 1) | (input << (m - 1)));
  }
  int previous_state(const int state, const int input) {
    return (((state << 1) | input) & ((1 << m) - 1));
  }
  void previous_state(const int state, int &S0, int &S1) {
    S0 = (state << 1) & (no_states - 1);
    S1 = S0 | 1;
  }
  int weight(const int state, const int input);
  void weight(const int state, int &w0, int &w1);
  int weight_reverse(const int state, const int input);
  void weight_reverse(const int state, int &w0, int &w1);
  bvec output_reverse(const int state, const int input);
  void output_reverse(const int state, bvec &zero_output, bvec &one_output);
  void output_reverse(const int state, int &zero_output, int &one_output);
  void calc_metric_reverse(const int state, const vec &rx_codeword,
                           double &zero_metric, double &one_metric);
  void calc_metric(const vec &rx_codeword, vec &delta_metrics);
  int get_input(const int state) { return (state >> (m - 1)); }

  int n;
  int K;
  int m;
  int no_states;
  ivec gen_pol;
  ivec gen_pol_rev;
  int encoder_state;
  int start_state;
  int trunc_length;
  double rate;
  bvec xor_int_table;
  imat output_reverse_int;
  CONVOLUTIONAL_CODE_METHOD cc_method;
  imat path_memory;
  Array<bool> visited_state;
  vec sum_metric;
  int trunc_ptr;
  int trunc_state;
};

// --------------- Some other functions that maybe should be moved -----------
ITPP_EXPORT int reverse_int(int length, int in);

ITPP_EXPORT int weight_int(int length, int in);

ITPP_EXPORT int compare_spectra(ivec v1, ivec v2);

ITPP_EXPORT int compare_spectra(ivec v1, ivec v2, vec weight_profile);

} // namespace itpp

#endif // #ifndef CONVCODE_H