mapalgorithm.h

Go to the documentation of this file.

/***************************************************************************
                          mapalgorithm.h  -  description
                             -------------------
    begin                : Die Aug 5 2003
    copyright            : (C) 2003 by Tobias Niemitz
    email                : tobias.niemitz@tu-harburg.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MAPALGORITHM_H
#define MAPALGORITHM_H


#include "trellissoftout.h"


namespace simthlib {

class LogMapAlgorithmAbstract : public TrellisSoftoutAlgorithm
{
  
  public:

        LogMapAlgorithmAbstract(std::auto_ptr<Trellis> usedTrellis);
        
        virtual ~LogMapAlgorithmAbstract();

        virtual void softout4Output(const simth::LlvSeq &metr, simth::LlrSeq *softout, const simth::LlrSeq *apri);

        virtual void softout4Input(const simth::LlvSeq &metr, simth::LlrSeq* softout, const simth::LlrSeq* apri);

        virtual void decode(const simth::LlvSeq &metr, simth::BitSeq* decodedData, const simth::LlrSeq* apri);

 
  protected:

        double sigma();

        void forwardrecursion(const simth::LlvSeq &channelMetr, const simth::LlrSeq* apri=NULL);

        std::vector<double> backwardrecursion(const int endState =0);

        void initialize_alpha( );

        void initialize_beta( );

        /* Initializes the last ms probabilities of the vector beta. The endState (default 0) as a
        secure event, the other as an impossible event. */
        //virtual std::vector<double> initialize_beta( );

        void set_gammas(simth::LlvSeq& metr, simth::LlrSeq* apri);

        virtual void set_alpha(const int index) = 0;


        virtual double set_beta(const int index) = 0;


    //the following is old and has to be replaced by new versions (ph 21.03.2003):

        virtual void calculate_llr(simth::LlrSeq *softout) = 0;


        virtual double calculate_gamma(double metricValue,int index,const simth::LlrSeq* apri) = 0;


        virtual double calculate_beta(const std::vector<double> *beta, const std::vector<double> *gamma,
                                    const int t, const int l, const int ms) = 0;




 protected:

    // alpha is a two-dimensional (ms,tau)-matrix
        simth::Array2d<double> alpha;           
        simth::Array2d<double> beta;
        simth::Array2d<double> gamma;


  private:

        void invariante() const;



       // sigma is the mean noise value
        double sigma_;

};

inline double LogMapAlgorithmAbstract::sigma()
{
  return sigma_;
}

inline void LogMapAlgorithmAbstract::invariante() const
{
  if(DEBUG){
  }
}


class MaxLogMap : public LogMapAlgorithmAbstract
{
  private:

        void invariante() const;

  protected:

        virtual void set_alpha(const int index) = 0;


    //        double calculate_alpha(const std::vector<double> *alpha, const std::vector<double> *gamma,
        //                            const int t, const int l, const int ms);

//double calculate_beta(const std::vector<double> *beta, const std::vector<double> *gamma,
//                                    const int t, const int l, const int ms);

//      double calculate_gamma(const int t, const int l1, const int l2, const double aprillr,
//                                        double dist);

//        void calculate_llr(simth::LlrSeq &softout, const std::vector<double> *alpha,
//                                        const std::vector<double> *beta, const std::vector<double> *gamma,
//                                        const int ms, const int tau);

  public:

        MaxLogMap(std::auto_ptr<Trellis> usedTrellis);

        virtual ~MaxLogMap();

//        virtual void reducedSoftout4Output(const simth::LlvSeq &metr, simth::LlrSeq* softout, const simth::LlrSeq* apri,
//                                      int startState, int endState);

};

inline void MaxLogMap::invariante() const
{
  if(DEBUG){
  }
}


class MaxLogMapReduced : public MaxLogMap
{
  private:

        void invariante() const;
        
  public:

    MaxLogMapReduced(std::auto_ptr<Trellis> usedTrellis);

    virtual ~MaxLogMapReduced();

    void reducedSoftout4Output(const simth::LlvSeq &metr, simth::LlrSeq* softout, const simth::LlrSeq* apri,
                                      int startState, int endState);

};

inline void MaxLogMapReduced::invariante() const
{
  if(DEBUG){
  }
}


/* class LogMap : public LogMapAlgorithmAbstract */
/* { */
/*   private: */

/*         void invariante() const; */

/*   protected: */

/*         double calculate_alpha(const std::vector<double> *alpha, const std::vector<double> *gamma, */
/*                                     const int t, const int l, const int ms); */

/*         double calculate_beta(const std::vector<double> *beta, const std::vector<double> *gamma, */
/*                                     const int t, const int l, const int ms); */

/*         double calculate_gamma(const int t, const int l1, const int l2, const double aprillr, */
/*                                         double dist); */

/*         void calculate_llr(simth::LlrSeq &softout, const std::vector<double> *alpha, */
/*                                         const std::vector<double> *beta, const std::vector<double> *gamma, */
/*                                         const int ms, const int tau); */

/*   public: */

/*         LogMap(std::auto_ptr<Trellis> usedTrellis); */

/*         virtual ~LogMap(); */

/*         virtual void reducedSoftout4Output(const simth::LlvSeq &metr, simth::LlrSeq* softout, const simth::LlrSeq* apri, */
/*                                       int startState, int endState); */
/* }; */

/* inline void LogMap::invariante() const */
/* { */
/*   if(DEBUG){ */
/*   } */
/* } */

/* class LogMapReduced : public LogMap */
/* { */
/*   private: */

/*         void invariante() const; */

/*   public: */

/*     LogMapReduced(std::auto_ptr<Trellis> usedTrellis); */

/*     virtual ~LogMapReduced(); */

/*     void reducedSoftout4Output(const simth::LlvSeq &metr, simth::LlrSeq* softout, const simth::LlrSeq* apri, */
/*                                       int startState, int endState); */

/* }; */

/* inline void LogMapReduced::invariante() const */
/* { */
/*   if(DEBUG){ */
/*   } */
/* } */
/* } */

}

#endif

---