/shared/development/google_code/rssoft/library/lib/FinalEvaluation.h

Go to the documentation of this file.

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

 This file is part of RSSoft. A Reed-Solomon 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

 Final evaluation of result polynomials to get possible codewords

 */
#ifndef __FINAL_EVALUATION_H__
#define __FINAL_EVALUATION_H__

#include "GFq.h"
#include "GFq_Element.h"
#include "GF_Utils.h"
#include <vector>
#include <map>

namespace rssoft
{
namespace gf
{
class GFq_Polynomial;
}

class EvaluationValues;
class ReliabilityMatrix;

class ProbabilityCodeword : public std::pair<float, std::vector<gf::GFq_Symbol> >
{
public:
    ProbabilityCodeword();
    
    ProbabilityCodeword(float probability, const std::vector<gf::GFq_Symbol>& codeword);
    
    ~ProbabilityCodeword();
    
    void add_symbol(const gf::GFq_Symbol& symbol)
    {
        second.push_back(symbol);
    }
    
    float get_probability_score() const
    {
        return first;
    }
    
    float& get_probability_score()
    {
        return first;
    }
    
    const std::vector<gf::GFq_Symbol>& get_codeword() const
    {
        return second;
    }
    
    std::vector<gf::GFq_Symbol>& get_codeword()
    {
        return second;
    }

    bool operator<(const ProbabilityCodeword& other) const
    {
        return first < other.first;
    }
    
    bool operator>(const ProbabilityCodeword& other) const
    {
        return first > other.first;
    }
    
    void print_codeword(std::ostream& os) const;
};

std::ostream& operator <<(std::ostream& os,     const ProbabilityCodeword& scored_codeword);


class FinalEvaluation
{
public:
    FinalEvaluation(const gf::GFq& _gf, unsigned int _k, const EvaluationValues& _evaluation_values);
        
    ~FinalEvaluation();
    
    void run(const std::vector<gf::GFq_Polynomial>& polynomials, const ReliabilityMatrix& relmat);

    const std::vector<gf::GFq_Symbol>& get_best_codeword() const
    {
        return codewords.begin()->get_codeword();
    }
     
    const std::vector<ProbabilityCodeword>& get_codewords() const
    {
        return codewords;
    }

    const std::vector<gf::GFq_Symbol>& get_best_message() const
    {
        return messages.begin()->get_codeword();
    }
     
    const std::vector<ProbabilityCodeword>& get_messages() const
    {
        return messages;
    }

    void print_codewords(std::ostream& os, const std::vector<ProbabilityCodeword>& words) const;

protected:
    const gf::GFq& gf; 
    unsigned int k; 
    const EvaluationValues& evaluation_values; 
    std::map<gf::GFq_Element, unsigned int> symbol_index; 
    std::vector<ProbabilityCodeword> codewords; 
    std::vector<ProbabilityCodeword> messages; 
};

} // namespace rssoft

#endif // __FINAL_EVALUATION_H__