/shared/development/google_code/rssoft/libccsoft/lib/CC_SequentialDecoding_FA.h

Go to the documentation of this file.

/*
 Copyright 2013 Edouard Griffiths <f4exb at free dot fr>

 This file is part of CCSoft. A Convolutional Codes Soft Decoding library

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Boston, MA  02110-1301  USA

 Convolutional soft-decision sequential decoder generic (virtual) class
 Based on node+edge combination in the code tree

 */
#ifndef __CC_SEQUENTIAL_DECODING_FA_H__
#define __CC_SEQUENTIAL_DECODING_FA_H__

#include "CC_Encoding_FA.h"
#include "CC_ReliabilityMatrix.h"

#include <cmath>
#include <algorithm>
#include <iostream>



namespace ccsoft
{

class NodeEdgeOrdering
{
public:
        NodeEdgeOrdering(float _path_metric, unsigned int _node_id) :
        path_metric(_path_metric),
        node_id(_node_id)
    {}

    ~NodeEdgeOrdering()
    {}

    bool operator>(const NodeEdgeOrdering& other) const
    {
        if (path_metric == other.path_metric)
        {
            return node_id > other.node_id;
        }
        else
        {
            return path_metric > other.path_metric;
        }
    }

    float path_metric;
    unsigned int node_id;
};

template<typename T_NodeEdge>
bool node_edge_pointer_ordering(T_NodeEdge* n1, T_NodeEdge* n2)
{
    if (n1->get_path_metric() == n2->get_path_metric())
    {
        return n1->get_id() > n2->get_id();
    }
    else
    {
        return n1->get_path_metric() > n2->get_path_metric();
    }
}

template<typename T_Register, typename T_IOSymbol, unsigned int N_k>
class CC_SequentialDecoding_FA
{
public:
        CC_SequentialDecoding_FA(const std::vector<unsigned int>& constraints,
            const std::vector<std::vector<T_Register> >& genpoly_representations) :
                encoding(constraints, genpoly_representations),
                use_metric_limit(false),
                metric_limit(0.0),
                use_node_limit(false),
                node_limit(0),
                codeword_score(0.0),
                cur_depth(-1),
                max_depth(0),
                node_count(0),
                tail_zeros(true),
                edge_bias(0.0),
                verbosity(0)
        {}

        virtual ~CC_SequentialDecoding_FA()
        {
        }

    void set_node_limit(unsigned int _node_limit)
    {
        node_limit = _node_limit;
        use_node_limit = true;
    }

    void reset_node_limit()
    {
        use_node_limit = false;
    }

    void set_metric_limit(float _metric_limit)
    {
        metric_limit = _metric_limit;
        use_metric_limit = true;
    }

    void reset_metric_limit()
    {
        use_metric_limit = false;
    }

    void set_tail_zeros(bool _tail_zeros)
    {
        tail_zeros = _tail_zeros;
    }

    void reset()
    {
        node_count = 0;
        codeword_score = 0.0;
        cur_depth = -1;
        max_depth = 0;
        encoding.clear(); // clear encoder's registers
    }

    CC_Encoding_FA<T_Register, T_IOSymbol, N_k>& get_encoding()
    {
        return encoding;
    }

    float get_score() const
    {
        return codeword_score;
    }

    float get_score_db_sym() const
    {
        if (cur_depth > 0)
        {
            return (10.0*log(2.0)*codeword_score) / cur_depth;
        }
        else
        {
            return 0.0;
        }
    }

    unsigned int get_nb_nodes() const
    {
        return node_count;
    }

    unsigned int get_current_depth() const
    {
        return cur_depth;
    }

    unsigned int get_max_depth() const
    {
        return max_depth;
    }
    
    void set_edge_bias(float _edge_bias)
    {
        edge_bias = _edge_bias;
    }

    void set_verbosity(unsigned int _verbosity)
    {
        verbosity = _verbosity;
    }

    virtual void print_dot(std::ostream& os) = 0;
    
    virtual void print_stats(std::ostream& os, bool success) = 0;

    virtual bool decode(const CC_ReliabilityMatrix& relmat, std::vector<T_IOSymbol>& decoded_message) = 0;

protected:
    CC_Encoding_FA<T_Register, T_IOSymbol, N_k> encoding;   
    bool use_metric_limit;    
    float metric_limit;       
    bool use_node_limit;      
    unsigned int node_limit;  
    float codeword_score;     
    int cur_depth;            
    int max_depth;            
    unsigned int node_count;  
    bool tail_zeros;          
    float edge_bias;          
    unsigned int verbosity;   
};

} // namespace ccsoft


#endif // __CC_SEQUENTIAL_DECODING_FA_H__