convcode.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 __convcode_h
#define __convcode_h

#include <array.h>
#include <binary.h>
#include <vector.h>
#include <matrix.h>

using std::string;
namespace SPUC {
class Convolutional_Code {
public:
  Convolutional_Code(void) { trunc_length = 0; K = 0; m = 0; set_start_state(0); }
  virtual ~Convolutional_Code(void) {}
  void set_code(string type_of_code, int inverse_rate, int constraint_length);
  void set_generator_polynomials(const ivec &gen, int constraint_length);
  ivec get_generator_polynomials(void) { return gen_pol; }
  double get_rate(void) { return rate; }
  
  void encode(const bvec &input, bvec &output);
  bvec encode(const bvec &input) { bvec output; encode(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; }
  void init_encoder() { encoder_state = start_state; }
  
  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_tail(received_signal, output); return output; }
  
  void decode(const vec &received_signal, bvec &output);
  bvec decode(const vec &received_signal)
    { bvec output; decode(received_signal, output); return output; }
  
  bool inverse_tail(const bvec coded_sequence, bvec &input);
  void set_start_state(const int state)
    { 
          //it_error_if(state<0 || (state>=(1<<m) && m != 0), "Invalid start state"); 
          start_state = state; }
  int get_encoder_state(void) { return encoder_state; }
  
  void set_truncation_length(const int length) { 
          //      it_error_if(length<K, "Truncation length shorter than K"); 
          trunc_length = length; }
  int get_truncation_length(void) { return trunc_length; }
  
  bool catastrophic(void);
  
  void distance_profile(llvec &dist_prof, int dmax = 100000, bool reverse = false);
  void calculate_spectrum(Array<llvec> &spectrum, int dmax, int no_terms);
  int fast(Array<llvec> &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) ); }
  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 calc_metric_reverse(const int state, const vec &rx_codeword, double &zero_metric, double &one_metric);

  int get_input(const int state) { return (state >> (m-1)); }
  
  int n;
  int K;
  int m;
  ivec gen_pol;
  ivec gen_pol_rev;
  int encoder_state;
  int start_state;
  int trunc_length;
  double rate;
  bvec xor_int_table;
};

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

int weight_int(int length, int in);

int compare_spectra(llvec v1, llvec v2);

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

#endif // __convcode_h

---