<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<sect2 id="encoder"><title>Trellis Encoder</title>
-
<para>
The trellis.encoder_XX(FSM, ST) block instantiates an FSM encoder corresponding to the fsm FSM and having initial state ST. The input and output is a sequence of bytes, shorts or integers.
</para>
-
</sect2>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<sect2 id="decoder"><title>Viterbi Decoder</title>
+<para>
+The trellis.viterbi_X(FSM, K, S0, SK) block instantiates a Viterbi decoder
+for a sequence of K trellis steps generated by the given FSM and with initial and final states set to S0 and SK, respectively (S0 and/or SK are set to -1
+if the corresponding states are not fixed/known at the receiver side).
+The output of this block is a sequence of K bytes, shorts or integers representing the estimated input (i.e., uncoded) sequence.
+The input is a sequence of K x FSM.O( ) floats, where the k x K + i
+float represents the cost associated with the k-th
+step in the trellis and the i-th FSM output.
+Observe that these inputs are generated externally and thus the Viterbi block is not informed of their meaning (they can be genarated as soft or hard inputs, etc); the only requirement is that they represent additive costs.
+</para>
+</sect2>
+
+<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
+<sect2 id="metrics"><title>Metrics Calculator</title>
+<para>
+The trellis.metrics_X(O,D,TABLE,TYPE) block is responsible for
+transforming the channel output to the stream of metrics appropriate as
+inputs to the Viterbi block described above. For each D input bytes/shorts/integers/floats/complexes it produces O output floats
+
+</para>
<para>
-The trellis.viterbi_X(FSM, K, S0, SK) block instantiates a Viterbi decoder
-for an underlying ...
+
+The parameter TYPE dictates how these metrics are generated:
+
+<itemizedlist>
+<listitem><para>
+TRELLIS_EUCLIDEAN: for each D-dimensional vector
+r<subscript>k</subscript>=
+(r<subscript>k,1</subscript>,r<subscript>k,2</subscript>,...,r<subscript>k,D</subscript>)
+evaluates
+</para>
+<para>
+||r<subscript>k</subscript>-c<subscript>i</subscript>||<superscript>2</superscript> = sum<subscript>j=1</subscript><superscript>D</superscript> |r<subscript>k,j</subscript>-c<subscript>i,j</subscript>|<superscript>2</superscript>
</para>
+<para>
+for each of the O hypothesized ouput
+symbols c<subscript>i</subscript> = (c<subscript>i,1</subscript>,c<subscript>i,2</subscript>,...,c<subscript>i,D</subscript>) defined in the vector TABLE,
+where TABLE[i * D + j] = c<subscript>i,j</subscript>.
+</para></listitem>
+
+<listitem><para>
+TRELLIS_HARD_SYMBOL: for each D-dimensional vector
+r<subscript>k</subscript>=
+(r<subscript>k,1</subscript>,r<subscript>k,2</subscript>,...,r<subscript>k,D</subscript>)
+evaluates
+</para>
+<para>
+i<subscript>0</subscript>= argmax<subscript>i</subscript> ||r<subscript>k</subscript>-c<subscript>i</subscript>||<superscript>2</superscript> =
+argmax<subscript>i</subscript> sum<subscript>j=1</subscript><superscript>D</superscript> |r<subscript>k,j</subscript>-c<subscript>i,j</subscript>|<superscript>2</superscript>
+</para>
+<para>
+and outputs a sequence of O floats of the form (0,...,0,1,0,...,0), where the
+i<subscript>0</subscript> position is set to 1. This corresponds to generating hard inputs (based on the symbol-wise Hamming distance) to the Viterbi algorithm.
+</para></listitem>
+
+
+<listitem><para>
+TRELLIS_HARD_BIT (not yet implemented): for each D-dimensional vector
+r<subscript>k</subscript>=
+(r<subscript>k,1</subscript>,r<subscript>k,2</subscript>,...,r<subscript>k,D</subscript>)
+evaluates
+</para>
+<para>
+i<subscript>0</subscript>= argmax<subscript>i</subscript> ||r<subscript>k</subscript>-c<subscript>i</subscript>||<superscript>2</superscript> =
+argmax<subscript>i</subscript> sum<subscript>j=1</subscript><superscript>D</superscript> (r<subscript>k,j</subscript>-c<subscript>i,j</subscript>)<superscript>2</superscript>
+</para>
+<para>
+and outputs a sequence of O floats of the form (d<subscript>1</subscript>,d<subscript>2</subscript>,...,d<subscript>O</subscript>), where the
+d<subscript>i</subscript> is the bitwise Hamming distance between i and i<subscript>0</subscript>. This corresponds to generating hard inputs (based on the bit-wise Hamming distance) to the Viterbi algorithm.
+</para></listitem>
+
+
+</itemizedlist>
+
+
+</para>
</sect2>
+<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
+<sect2 id="viterbi_combined"><title>Combined Metrics Calculator and Viterbi Decoder</title>
+<para>
+Although the separation of metric calculation and Viterbi algorithm blocks
+is consistent with our goal of providing general blocks that can be easily
+reused, this separation might result in large input/output buffer sizes
+betwen blocks. Indeed for an FSM with a large output alphabet, the
+output of the metric block/input of the Viterbi block is FSM.O( ) floats for
+each trellis step. Sometimes this results in buffer overflow even for
+moderate sequence lengths.
+To overcome this problem we provide a block that incorporates the metric calculation and Viterbi algorithm into a single GNU Radio block, namely
+trellis.viterbi_combined_X( FSM, K, S0, SK, D, TABLE, TYPE) where the arguments are exactly those used in the aforementioned two blocks.
+</para>
+</sect2>
+
+
+
</sect1>
The FSM is first intantiated in "main" by
</para>
<programlisting>
- 62 f=trellis.fsm(fname) # get the FSM specification from a file (will hopefully be automated in the future...)
+ 62 f=trellis.fsm(fname) # get the FSM specification from a file
</programlisting>
<para>
-The FSM will produce K output symbols (remeber the FSM produces always one output symbol for each input symbol). Each of these symbols needs to be modulated. Since we are simulating the communication system, we need not simulate the actual waveforms. An M-ary, N-dimensional
-modulation is completely specified by a set of M, N-dimensional real vectors. In "fsm_utils.py" file we give a number of useful modulations with the following format: modulation = (N,constellation), where
-constellation=[c11,c12,...,c1N,c21,c22,...,c2N,...,cM1,cM2,...cMN].
+The FSM will produce K output symbols (remeber the FSM produces always one output symbol for each input symbol). Each of these symbols needs to be modulated. Since we are simulating the communication system, we need not simulate the actual waveforms. An M-ary, D-dimensional
+modulation is completely specified by a set of M, D-dimensional real vectors. In "fsm_utils.py" file we give a number of useful modulations with the following format: modulation = (D,constellation), where
+constellation=[c11,c12,...,c1D,c21,c22,...,c2D,...,cM1,cM2,...cMD].
The meaning of the above is that every constellation point c_i
-is an N-dimnsional vector c_i=(ci1,ci2,...,ciN)
+is an D-dimnsional vector c_i=(ci1,ci2,...,ciD)
For instance, 4-ary PAM is represented as
(1,[-3, -1, 1, 3]), while QPSK is represented as
(2,[1, 0, 0, 1, 0, -1, -1, 0]). In our example we choose QPSK modulation.
We now need to modulate the FSM output symbols.
The "chunks_to_symbols_sf" is essentially a memoryless mapper which
for each input symbol y_k
-outputs a sequence of N numbers ci1,ci2,...,ciN representing the
+outputs a sequence of D numbers ci1,ci2,...,ciD representing the
coordianates of the constellation symbol c_i with i=y_k.
</para>
<programlisting>
<para>
The channel is AWGN with appropriate noise variance.
-For each transmitted symbol c_k=(ck1,ck2,...,ckN) we receive a noisy version
-r_k=(rk1,rk2,...,rkN).
+For each transmitted symbol c_k=(ck1,ck2,...,ckD) we receive a noisy version
+r_k=(rk1,rk2,...,rkD).
</para>
<programlisting>
22 # CHANNEL
O such numbers (one for each possible output symbol y_k).
This is done
in "metrics_f". In particular, metrics_f is a memoryless device
-taking N inputs at a time and producing O outputs. The N inputs are
-rk1,rk2,...,rkN.
+taking D inputs at a time and producing O outputs. The D inputs are
+rk1,rk2,...,rkD.
The O outputs
-are the costs associated with observations rk1,rk2,...,rkN and
+are the costs associated with observations rk1,rk2,...,rkD and
hypothesized output symbols c_1,c_2,...,c_M. For instance,
if we choose to perform soft-input VA, we need to evaluate
the Euclidean distance between r_k and each of c_1,c_2,...,c_M,
<listitem>
<para>
-Optimize the VA code.
+Optimize the VA code if possible.
</para>
</listitem>
sys.exit (1)
# system parameters
- f=trellis.fsm(fname) # get the FSM specification from a file (will hopefully be automated in the future...)
+ f=trellis.fsm(fname) # get the FSM specification from a file
Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)
bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol
K=Kb/bitspersymbol # packet size in trellis steps
59 sys.exit (1)
60
61 # system parameters
- 62 f=trellis.fsm(fname) # get the FSM specification from a file (will hopefully be automated in the future...)
+ 62 f=trellis.fsm(fname) # get the FSM specification from a file
63 Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)
64 bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol
65 K=Kb/bitspersymbol # packet size in trellis steps
d_INTER[i]=i;
tmp[i] = rand();
}
- //quicksort_index <int> (tmp,d_INTER,0,d_K-1); got to resolve this...
+ //quicksort_index <int> (tmp,d_INTER,0,d_K-1); //got to resolve this...
quicksort_index1 (tmp,d_INTER,0,d_K-1);
// generate DEINTER table
#include <stdexcept>
#include "trellis_calc_metric.h"
-void calc_metric_s(int O, int D, const std::vector<short> &TABLE, const short *in, float *metric, trellis_metric_type_t type)
+
+
+void calc_metric(int O, int D, const std::vector<short> &TABLE, const short *in, float *metric, trellis_metric_type_t type)
{
float minm = FLT_MAX;
int minmi = 0;
}
-
-void calc_metric_i(int O, int D, const std::vector<int> &TABLE, const int *in, float *metric, trellis_metric_type_t type)
+void calc_metric(int O, int D, const std::vector<int> &TABLE, const int *in, float *metric, trellis_metric_type_t type)
{
float minm = FLT_MAX;
int minmi = 0;
-void calc_metric_f(int O, int D, const std::vector<float> &TABLE, const float *in, float *metric, trellis_metric_type_t type)
+void calc_metric(int O, int D, const std::vector<float> &TABLE, const float *in, float *metric, trellis_metric_type_t type)
{
float minm = FLT_MAX;
int minmi = 0;
}
-void calc_metric_c(int O, int D, const std::vector<gr_complex> &TABLE, const gr_complex *in, float *metric, trellis_metric_type_t type)
+void calc_metric(int O, int D, const std::vector<gr_complex> &TABLE, const gr_complex *in, float *metric, trellis_metric_type_t type)
{
float minm = FLT_MAX;
int minmi = 0;
throw std::runtime_error ("Invalid metric type.");
}
}
+
+
+/*
+template <class T> void calc_metric(int O, int D, const std::vector<T> &TABLE, const T *in, float *metric, trellis_metric_type_t type)
+{
+ float minm = FLT_MAX;
+ int minmi = 0;
+
+ switch (type){
+ case TRELLIS_EUCLIDEAN:
+ for(int o=0;o<O;o++) {
+ metric[o]=0.0;
+ for (int m=0;m<D;m++) {
+ T s=in[m]-TABLE[o*D+m];
+ gr_complex sc(1.0*s,0);
+ metric[o]+=(s*conj(s)).real();
+ }
+ }
+ break;
+ case TRELLIS_HARD_SYMBOL:
+ for(int o=0;o<O;o++) {
+ metric[o]=0.0;
+ for (int m=0;m<D;m++) {
+ T s=in[m]-TABLE[o*D+m];
+ gr_complex sc(1.0*s,0);
+ metric[o]+=(s*conj(s)).real();
+ }
+ if(metric[o]<minm) {
+ minm=metric[o];
+ minmi=o;
+ }
+ }
+ for(int o=0;o<O;o++) {
+ metric[o] = (o==minmi?0.0:1.0);
+ }
+ break;
+ case TRELLIS_HARD_BIT:
+ throw std::runtime_error ("Invalid metric type (not yet implemented).");
+ break;
+ default:
+ throw std::runtime_error ("Invalid metric type.");
+ }
+}
+*/
#include <gr_complex.h>
#include <trellis_metric_type.h>
-void calc_metric_s(int O, int D, const std::vector<short> &TABLE, const short *in, float *metric, trellis_metric_type_t type);
-void calc_metric_i(int O, int D, const std::vector<int> &TABLE, const int *in, float *metric, trellis_metric_type_t type);
+void calc_metric(int O, int D, const std::vector<short> &TABLE, const short *in, float *metric, trellis_metric_type_t type);
-void calc_metric_f(int O, int D, const std::vector<float> &TABLE, const float *in, float *metric, trellis_metric_type_t type);
+void calc_metric(int O, int D, const std::vector<int> &TABLE, const int *in, float *metric, trellis_metric_type_t type);
-void calc_metric_c(int O, int D, const std::vector<gr_complex> &TABLE, const gr_complex *in, float *metric, trellis_metric_type_t type);
+void calc_metric(int O, int D, const std::vector<float> &TABLE, const float *in, float *metric, trellis_metric_type_t type);
+
+void calc_metric(int O, int D, const std::vector<gr_complex> &TABLE, const gr_complex *in, float *metric, trellis_metric_type_t type);
+
+
+//template <class T> void calc_metric(int O, int D, const std::vector<T> &TABLE, const T *in, float *metric, trellis_metric_type_t type);
#endif
float *out = (float *) output_items[m];
for (int i = 0; i < noutput_items / d_O ; i++){
+/*
#if @IS_SHORT@
calc_metric_s(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#elif @IS_INT@
#elif @IS_COMPLEX@
calc_metric_c(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#endif
+*/
+ calc_metric(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
}
}
float *out = (float *) output_items[m];
for (int i = 0; i < noutput_items / d_O ; i++){
+/*
#if 0
calc_metric_s(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#elif 0
#elif 1
calc_metric_c(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#endif
+*/
+ calc_metric(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
}
}
float *out = (float *) output_items[m];
for (int i = 0; i < noutput_items / d_O ; i++){
+/*
#if 0
calc_metric_s(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#elif 0
#elif 0
calc_metric_c(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#endif
+*/
+ calc_metric(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
}
}
float *out = (float *) output_items[m];
for (int i = 0; i < noutput_items / d_O ; i++){
+/*
#if 0
calc_metric_s(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#elif 1
#elif 0
calc_metric_c(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#endif
+*/
+ calc_metric(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
}
}
float *out = (float *) output_items[m];
for (int i = 0; i < noutput_items / d_O ; i++){
+/*
#if 1
calc_metric_s(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#elif 0
#elif 0
calc_metric_c(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
#endif
+*/
+ calc_metric(d_O, d_D, d_TABLE,&(in[i*d_D]),&(out[i*d_O]), d_TYPE);
}
}
}
for(int k=0;k<K;k++) { // forward recursion
- calc_metric_f(O, D, TABLE, &(observations[k*D]), &(prioro[k*O]),TYPE); // calc metrics
+ calc_metric(O, D, TABLE, &(observations[k*D]), &(prioro[k*O]),TYPE); // calc metrics
norm=INF;
for(int j=0;j<S;j++) {
minm=INF;
alphai=0;
for(int k=0;k<K;k++) {
- calc_metric_f(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
+ calc_metric(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
norm=INF;
for(int j=0;j<S;j++) { // for each next state do ACS
minm=INF;
alphai=0;
for(int k=0;k<K;k++) {
- calc_metric_f(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
+ calc_metric(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
norm=INF;
for(int j=0;j<S;j++) { // for each next state do ACS
minm=INF;
alphai=0;
for(int k=0;k<K;k++) {
- calc_metric_f(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
+ calc_metric(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
norm=INF;
for(int j=0;j<S;j++) { // for each next state do ACS
minm=INF;
alphai=0;
for(int k=0;k<K;k++) {
- calc_metric_f(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
+ calc_metric(O, D, TABLE, &(in[k*D]), metric,TYPE); // calc metrics
norm=INF;
for(int j=0;j<S;j++) { // for each next state do ACS
minm=INF;
projects / debian / gnuradio / commitdiff