softoutdecoding.h

Go to the documentation of this file.

/*-*-c++-*-****************************************************************
                          softoutdecoding.h  -  description
                             -------------------
    begin                : Mit Mai 22 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef SOFTOUTDECODING_HEADER
#define SOFTOUTDECODING_HEADER

#include <iostream>
#include <string>
#include <complex>
#include <memory>


#include "trellis.h"
#include "misc.h"
#include "signals.h"
#include "trellissoftout.h"
#include "puncturing.h" 




namespace simthlib{

namespace softoutdecoding
{

inline void makeExtrinsic(const simth::LlrSeq& previousInfo,simth::LlrSeq* newInfo)
{
  if(DEBUG) {
    if(previousInfo.size() != newInfo->size()) {
      throw std::runtime_error("inline void makeExtrinsic(const simth::LlrSeq& previousInfo,"
                               "simth::LlrSeq newInfo) : Error 1");
    }
  }
  for(size_t pos = 0; pos < previousInfo.size(); pos++) {
    (*newInfo)[pos] -= previousInfo[pos];
  }
}

inline void addExtrinsic(const simth::LlrSeq& sysInfo, simth::LlrSeq* newInfo)
{
  if(DEBUG) {
    if(sysInfo.size() != newInfo->size()) {
      throw std::runtime_error("inline void addExtrinsic(const simth::LlrSeq& sysInfo,"
                               "simth::LlrSeq newInfo) : Error 1");
    }
  }
  for(size_t pos=0; pos< sysInfo.size(); pos++) {
    (*newInfo)[pos] += sysInfo[pos];
  }
}


void addAPriori(const simth::LlrSeq& inMain,
                const simth::LlrSeq& inAPriori,
                simth::LlrSeq* inNew);


}

class SoftoutDecoding
{

  protected:


  public:

    virtual ~SoftoutDecoding();

  //    virtual void setDecodedLength(int decodedLength) = 0;
  //  virtual int  getDecodedLength() const = 0;



    virtual void softout4InputBits(simth::LlrSeq &metr,
                                   simth::LlrSeq* softout,
                                   simth::LlrSeq* apri = NULL)=0;

    virtual void softout4OutputBits(const simth::LlrSeq &metr,
                                    simth::LlrSeq* softout,
                                    simth::LlrSeq* apri = NULL)=0;


    virtual void softout4InputBits(simth::LlvSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL)=0;

    virtual void softout4OutputBits(const simth::LlvSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL)=0;



    virtual void normalDecoding(const simth::LlrSeq &llr, simth::BitSeq& bsout)=0;

    virtual int getDataLength(int codedLength) const = 0;

    virtual int getCodeLength(int rawLength) const = 0;

    virtual void reset() = 0;

    virtual void print(std::ostream &os) const = 0;

};

class StreamSoftoutDecoding : public SoftoutDecoding
{

  public:

    StreamSoftoutDecoding();

    virtual ~StreamSoftoutDecoding();

    virtual int dataBitsPerStep() const = 0;
    virtual int codedBitsPerStep() const = 0;
   
};

class StreamSoftoutDecodingTailbits : public StreamSoftoutDecoding
{

  public:

    StreamSoftoutDecodingTailbits();

    virtual size_t numTailbits() const = 0;

};

class TrellisSoftoutDecoding : public StreamSoftoutDecodingTailbits
{
  private:

    TrellisSoftoutAlgorithm* usedAlgorithm;

  protected:

                     
  public:

    TrellisSoftoutDecoding(std::auto_ptr<TrellisSoftoutAlgorithm> algorithm_ptr);

    virtual void reset();

    virtual void softout4InputBits(simth::LlvSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

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



    virtual void softout4InputBits(simth::LlrSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

    virtual void softout4OutputBits(const simth::LlrSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

    /* Performs a maximum likelihood sequence estimation of the
    data sequence based on the log-likelihood ratios of the
    received modulation symbols (soft decision decoding without
    soft {\em out}put) This can be usefull in the last step of
    an iterative decoding procedure, when no soft-out information
    is needed.
     */
    virtual void normalDecoding(const simth::LlrSeq &llr, simth::BitSeq& bsout);

                   
    virtual ~TrellisSoftoutDecoding();

    virtual int getDataLength(int codedLength) const;

    /* Returns the length of the coded bit sequence which the
    coder generates from a data sequence of the given length.
    */
    virtual int getCodeLength(int rawLength) const;

    virtual int dataBitsPerStep() const {return usedAlgorithm->getTrellis()->numInbits();}
    virtual int codedBitsPerStep() const {return usedAlgorithm->getTrellis()->numOutbits();}

    size_t numTailbits() const {return usedAlgorithm->getTrellis()->numTailbits();}

    /* calculates log-likelihood ratios of the
    data sequence based on the log-likelihood values of received
    modulation symbols (soft in / soft out decoding) */

    virtual void print(std::ostream &os) const;
};

inline int TrellisSoftoutDecoding::getCodeLength(int dataLength) const
{
  return usedAlgorithm->getTrellis()->getCodeLength(dataLength);
}


inline int TrellisSoftoutDecoding::getDataLength(int codeLength) const
{
  return usedAlgorithm->getTrellis()->getDataLength(codeLength);
}


class ConvSoftoutDecoding : public TrellisSoftoutDecoding
{
  public:
    ConvSoftoutDecoding(int mem, int inbits, int outbits, trellissoftout::softoutalgorithmmode soMode);

    ConvSoftoutDecoding(int inSymbolsPerStep, const simth::checkedVector<int>& polynome,
                       trellissoftout::softoutalgorithmmode soMode);

    ConvSoftoutDecoding(int inSymbolsPerStep, const simth::checkedVector<int>& polynome,
                       int recursivePolynomial, bool systematic, trellissoftout::softoutalgorithmmode soMode);

    ConvSoftoutDecoding(int inSymbolsPerStep, int bitsPerSymbol, simthlib::ConvCodeTrellis::StartingMode startingMode, simthlib::map_type mapMode,
                       const simth::checkedVector<int>& polynome, int recursivePolynomial,
                       trellissoftout::softoutalgorithmmode soMode);

    virtual ~ConvSoftoutDecoding();

    virtual void print(std::ostream &os) const {TrellisSoftoutDecoding::print(os);}
};



class SoftoutDAPSKDecoding : public StreamSoftoutDecodingTailbits
{
    ConvSoftoutDecoding* amplDecoding;
    ConvSoftoutDecoding* phaseDecoding;

    mutable int numInSize;
    mutable int numInAmplSize;
    mutable int numInPhaseSize;

    int bitsPerAmpl_;
    int bitsPerPhase_;

    template<class seqT_in, class seqT_out>
    void splitSequence(const seqT_in& inputBits,
                       seqT_out* amplSeq, seqT_out* phaseSeq) const;
    template<class T>
    void mergeSequences(const T& amplSeq, const T& phaseSeq, T* outSeq) const;

    int decodedLength_;

    void invariante() const;

  protected:

    int bitsPerAmpl() const {return bitsPerAmpl_;}
    int bitsPerPhase() const {return bitsPerPhase_;}

    void computeSplittedSizes(int numInSize, int* amplSize, int* phaseSize) const;

  public:

    SoftoutDAPSKDecoding(int inSymbolsPerStep, int bitsPerSymbol, simthlib::ConvCodeTrellis::StartingMode starting, 
                        simthlib::map_type mappMode,
                        const simth::checkedVector<int>& polynomials, const int recursivePolynomial,
                        trellissoftout::softoutalgorithmmode soMode);


    virtual ~SoftoutDAPSKDecoding();

    virtual void reset();

    /* Returns the length of a data bit sequence which can be
    encoded into a coded bit sequence of the given length.

    */
    virtual int getDataLength(int codedLength) const;

    /* Returns the length of the coded bit sequence which the
    coder generates from a data sequence of the given length.
    */
    virtual int getCodeLength(int rawLength) const;



    virtual void softout4InputBits(simth::LlvSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

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



    virtual void softout4InputBits(simth::LlrSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

    virtual void softout4OutputBits(const simth::LlrSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

    /* Performs a maximum likelihood sequence estimation of the
    data sequence based on the log-likelihood ratios of the
    received modulation symbols (soft decision decoding without
    soft em out put) This can be usefull in the last step of
    an iterative decoding procedure, when no soft-out information
    is needed.

     */
    virtual void normalDecoding(const simth::LlrSeq &llr, simth::BitSeq& bsout);

    virtual int dataBitsPerStep() const {return (amplDecoding->dataBitsPerStep()+phaseDecoding->dataBitsPerStep());}
    virtual int codedBitsPerStep() const {return (amplDecoding->codedBitsPerStep()+phaseDecoding->codedBitsPerStep());}

    virtual void print(std::ostream &os) const;

    virtual size_t numTailbits() const {return (amplDecoding->numTailbits());} //just in order to make the file compiled. (Zhao)

};


inline void SoftoutDAPSKDecoding::invariante() const
{
  if(DEBUG) {
    if(numInAmplSize + numInPhaseSize != numInSize) {
      throw std::logic_error("void SoftoutDAPSKDecoding::invariante() const : error 1");
    }
  }
}


template<class seqT_in, class seqT_out>
inline void SoftoutDAPSKDecoding::splitSequence(const seqT_in &bsin,
    seqT_out* amplSeq,
    seqT_out* phaseSeq) const
{
  if(DEBUG) {
    if(bsin.size() % (bitsPerAmpl()+bitsPerPhase()) != 0) {
      throw std::runtime_error("void SoftoutDAPSKDecoding::splitSequence(const simth::BitSeq &bsin, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) "
                               "const : bit size is not a multiplier of bitsPerSymbol");
    }
  }
  if(numInSize != int(bsin.size())) {
    numInSize = bsin.size();
    computeSplittedSizes(numInSize, &numInAmplSize, &numInPhaseSize);
  }
  if(int(amplSeq->size()) != numInAmplSize) {
    amplSeq->resize(numInAmplSize);
  }
  if(int(phaseSeq->size()) != numInPhaseSize) {
    phaseSeq->resize(numInPhaseSize);
  }
  typename seqT_in::const_iterator iter = bsin.begin();
  typename seqT_out::iterator iterAmpl = amplSeq->begin();
  typename seqT_out::iterator iterPhase = phaseSeq->begin();
  while(iter != bsin.end()) {
    for(int p=0; p<bitsPerPhase();p++) {
      (*iterPhase) = (*iter);
      iterPhase++;
      iter++;
    }
    for(int a=0; a<bitsPerAmpl();a++) {
      (*iterAmpl) = (*iter);
      iterAmpl++;
      iter++;
    }
  }
  if(DEBUG) {
    if(iter != bsin.end()) {
      throw std::logic_error("void SoftoutDAPSKDecoding::splitSequence(const simth::BitSeq &bsin, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) "
                             "const : error 1");
    }
    if(iterAmpl != amplSeq->end()) {
      throw std::logic_error("void SoftoutDAPSKDecoding::splitSequence(const simth::BitSeq &bsin, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) "
                             "const : error 2");
    }
    if(iterPhase != phaseSeq->end()) {
      throw std::logic_error("void SoftoutDAPSKDecoding::splitSequence(const simth::BitSeq &bsin, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) "
                             "const : error 3");
    }
  }
  invariante();
}


template<class T>
inline void SoftoutDAPSKDecoding::mergeSequences(const T& amplSeq, const T& phaseSeq, T* outSeq) const
{
  if(DEBUG) {
    if(amplSeq.size()*bitsPerPhase() != phaseSeq.size()*bitsPerAmpl()) {
      throw std::logic_error("void SoftoutDAPSKDecoding::mergeSequences(const simth::BitSeq& amplSeq, const simth::BitSeq& phaseSeq, "
                             "simth::BitSeq* outSeq) const : error 1");
    }
  }
  outSeq->resize(amplSeq.size()+phaseSeq.size());

  typename T::const_iterator iterAmpl = amplSeq.begin();
  typename T::const_iterator iterPhase = phaseSeq.begin();
  typename T::iterator iter = outSeq->begin();
  while(iter != outSeq->end()) {
    for(int p=0; p<bitsPerPhase();p++) {
      (*iter) = (*iterPhase);
      iterPhase++;
      iter++;
    }
    for(int a=0; a<bitsPerAmpl();a++) {
      (*iter) = (*iterAmpl);
      iterAmpl++;
      iter++;
    }
  }
  if(DEBUG) {
    if(iter != outSeq->end()) {
      throw std::logic_error("void SoftoutDAPSKDecoding::mergeSequence(const simth::BitSeq &bsin, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) "
                             "const : error 1");
    }
    if(iterAmpl != amplSeq.end()) {
      throw std::logic_error("void SoftoutDAPSKDecoding::mergeSequence(const simth::BitSeq &bsin, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) "
                             "const : error 2");
    }
    if(iterPhase != phaseSeq.end()) {
      throw std::logic_error("void SoftoutDAPSKDecoding::mergeSequence(const simth::BitSeq &bsin, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) "
                             "const : error 3");
    }
  }
}




class PunctConvSoftoutDecoding : public ConvSoftoutDecoding
{
  private:

    simthlib::Puncturing* usedPuncturing;

  protected:


  public:
    PunctConvSoftoutDecoding(int codeRateNumerator,int codeRateDenumerator, 
                 int mem, int inbits, int outbits,
                 trellissoftout::softoutalgorithmmode soMode);


    PunctConvSoftoutDecoding(int codeRateNumerator,int codeRateDenumerator, int inbitsPerStep,
                            const simth::checkedVector<int>& polynome, int recursivePolynomial, bool systematic,
                            trellissoftout::softoutalgorithmmode soMode);

    PunctConvSoftoutDecoding(const std::string& puncturingPattern, int inbitsPerStep,
                            const simth::checkedVector<int>& polynome, int recursivePolynomial, bool systematic,
                            trellissoftout::softoutalgorithmmode soMode);

    ~PunctConvSoftoutDecoding();

  //virtual void updateInputLengths();
  //  virtual void updateOutputLengths();


    virtual void softout4InputBits(simth::LlvSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

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



    virtual void softout4InputBits(simth::LlrSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

    virtual void softout4OutputBits(const simth::LlrSeq &metr, simth::LlrSeq* softout, simth::LlrSeq* apri = NULL);

    /* Performs a maximum likelihood sequence estimation of the
    data sequence based on the log-likelihood ratios of the
    received modulation symbols (soft decision decoding without
    soft put) This can be usefull in the last step of
    an iterative decoding procedure when no soft-out information
    is needed.  -
    */
    virtual void normalDecoding(const simth::LlrSeq &llr, simth::BitSeq& bsout);

    /* Returns the length of a data bit sequence which can be
    encoded into a coded bit sequence of the given length.

    */
    virtual int getDataLength(int codedLength) const;

    /* Returns the length of the coded bit sequence which the
    coder generates from a data sequence of the given length.
    */
    virtual int getCodeLength(int rawLength) const;

    virtual int codedBitsPerStep() const {return ConvSoftoutDecoding::codedBitsPerStep();}

    void setPuncturing(const std::string& newPuncturePattern);
};




}


#endif

---