signals.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   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 SIGNAL_HEADER
#define SIGNAL_HEADER


// Needed for windows DLLs
#ifndef DLLIMPORT
#  if defined(__declspec) | defined(IS_WIN32)
#    if BUILDING_SIMTHETICBASE_DLL
#      define DLLIMPORT __declspec (dllexport)
#    else     /* Not BUILDING_SIMTHETICBASE_DLL */
#      define DLLIMPORT __declspec (dllimport)
#    endif    /* Not BUILDING_SIMTHETICBASE_DLL */
#  else
#    define DLLIMPORT
#  endif    /* __declspec */
#endif  /* DLLIMPORT */


#include <iostream>
#include <vector>
#include <stdexcept>

#include <simthetic/misc.h>
#include <simthetic/array.h>
#include <simthetic/checkedvector.h>

namespace simth
{

const double HIGH_METRIC = 1e9; 
// std::numeric_limits<double>::max(); 
// -- don't use std::numeric_limits this here because many compilers don't have it.

enum SequenceType { LLV_SEQ, LLR_SEQ };

SequenceType string2SequenceType(const std::string& s);


/* ********************************************
 */
class NoAttributes;

template<class Val, class Attr, class Cont> class SignalSequenceStorage;
template<class Val, class Attr, class Cont> class SignalSequenceAccess;


template<class Val, class Attr, class Cont, class Stor, class Accs>
class SignalSequenceBase
{
  public:

    typedef Stor storage_type;
    typedef Accs access_type;

    typedef Val value_type;
    typedef Attr attributes_type;
    typedef Cont container_type;

    typedef typename container_type::iterator iterator;
    typedef typename container_type::const_iterator const_iterator;

    typedef typename container_type::reference reference;
    typedef typename container_type::const_reference const_reference;

    SignalSequenceBase(iterator iterStart, iterator iterEnd, storage_type &seq);

    SignalSequenceBase(storage_type &seq);


    virtual ~SignalSequenceBase()=0;


    SignalSequenceBase<value_type,attributes_type,container_type,storage_type,access_type>&
    operator=(const SignalSequenceBase<value_type,attributes_type,container_type,storage_type,access_type> &seq);


    reference operator[](size_t i);

    const_reference operator[](size_t i) const;

    size_t size() const { return size_; }

    size_t capacity() const {return capacity_;}


    virtual void resize(size_t i);


    void seek(iterator newStart, iterator newEnd);

    iterator begin();
    const_iterator begin() const;

    iterator end();
    const_iterator end() const;

    attributes_type& wAttributes() { return storage->wAttributes(); }  //Non-virtual is ok, though it will be overridden in derived classes!!

    const attributes_type& rAttributes() const        //Non-virtual is ok, though it will be overridden in derived classes!!
      { return storage->rAttributes(); };

    bool isAttributesLocked() const { return storage->isLocked(); };

  protected:

    SignalSequenceBase();

    void seek(iterator newStart, iterator newEnd, storage_type& storage);

  private:

    storage_type* storage;
    iterator iter1;
    iterator iter2;
    size_t size_;
    size_t capacity_;

    void invariante() const;
};

template<class Val, class Attr = NoAttributes,
class Cont = simth::checkedVector<Val> >
class SignalSequence :
      public SignalSequenceBase<Val, Attr, Cont,
      SignalSequenceStorage<Val,Attr,Cont>,
      SignalSequenceAccess<Val,Attr,Cont> >
{
  public:
    typedef class SignalSequenceStorage<Val,Attr,Cont> storage_type;
    typedef class SignalSequenceAccess<Val,Attr,Cont> access_type;

    typedef Val value_type;
    typedef Attr attributes_type;
    typedef Cont container_type;

    typedef typename container_type::iterator iterator;
    typedef typename container_type::const_iterator const_iterator;

    typedef typename container_type::reference reference;
    typedef typename container_type::const_reference const_reference;

    typedef class SignalSequenceBase<Val, Attr, Cont,
                    storage_type, access_type> base_type;


    SignalSequence(iterator iterStart, iterator iterEnd, storage_type &seq);

    SignalSequence(storage_type &seq);


    virtual ~SignalSequence()=0;

  protected:

    SignalSequence();

};


template<class Val, class Attr, class Cont>
class SignalSequenceAccess : public SignalSequence<Val,Attr,Cont>
{
  private:
    typedef class SignalSequence<Val,Attr,Cont> base_type;

  public:

    typedef typename base_type::value_type value_type;
    typedef typename base_type::attributes_type attributes_type;
    typedef typename base_type::container_type container_type;

    typedef typename base_type::iterator iterator;
    typedef typename base_type::const_iterator const_iterator;

    typedef typename base_type::reference reference;
    typedef typename base_type::const_reference const_reference;

    typedef typename base_type::storage_type storage_type;

    SignalSequenceAccess(iterator iterStart, iterator iterEnd, storage_type &seq)
        : base_type (iterStart, iterEnd, seq) {};

    SignalSequenceAccess(const SignalSequence<Val,Attr,Cont>& seq)
        : base_type (seq) {};

};

/* ************************************
 */


template<class Val, class Attr, class Cont>
class SignalSequenceStorage : public SignalSequence<Val,Attr,Cont>
{
  public:
    typedef typename Cont::iterator iterator;
    typedef typename Cont::const_iterator const_iterator;

    typedef typename Cont::reference reference;
    typedef typename Cont::const_reference const_reference;

    typedef Val value_type;
    typedef Attr attributes_type;
    typedef Cont container_type;

    SignalSequenceStorage();

    SignalSequenceStorage(size_t size, const value_type &val = value_type());

    SignalSequenceStorage(const SignalSequence<value_type,attributes_type,container_type> &seq);

    virtual ~SignalSequenceStorage();

    size_t capacity() const { return ownStorage.capacity(); }

    virtual void resize(size_t i);

    attributes_type& wAttributes();

    const attributes_type& rAttributes() const { return attributes_; }

    void lock() {lock_ = true;}

    void unlock() {lock_= false;}

    bool isLocked() const {return lock_;}

  private:
    container_type ownStorage; //must be created on the heap!
    attributes_type attributes_ ;
    bool lock_;

    void invariante() const;
  private:
    typedef class SignalSequence<Val,Attr,Cont> base_type;
};

/* ************************************
 */

template<class Val, class Attr, class Cont, class Stor, class Accs>
inline typename SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::reference
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::operator[](size_t pos)
{
#if DEBUG==1
  if(pos >= size()) {
    throw std::runtime_error("reference SignalSequence<Cont>::operator[](size_t i) : i > size()");
  }
  invariante();
#endif
  return *(iter1+pos);
}

template<class Val, class Attr, class Cont, class Stor, class Accs>
inline typename SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::const_reference
SignalSequenceBase<Val,Attr,Cont,Stor,Accs>::operator[](size_t pos) const
{
#if DEBUG==1
  if(pos >= size()) {
    throw std::runtime_error("SignalSequenceBase::operator[](size_t pos): pos >= size()");
  }
  invariante();
#endif
  return *(iter1+pos);
}



/* ************************************
 */

template<class Val, class Attr, class Cont, class Stor, class Accs>
std::ostream& operator<<(std::ostream &os, const SignalSequenceBase<Val,Attr,Cont,Stor,Accs>& seq)
{
  //save old format settings:
  std::ios::fmtflags oldSettings = os.flags();
  //formatting
  os.precision(2);
  size_t len = seq.size();
  for(int i = len-1;i >= 0 ; i--) {
    os<<" "<<seq[i]<<" ";
  }
  os<<" <- start";
  //rewrite old settings:
  os.flags(oldSettings);
  return os;
}


template<class T, class A, class Cont>
std::ostream& operator<<(std::ostream &os, const SignalSequenceStorage<T,A,Cont>& seq)
{
  //save old format settings:
  std::ios::fmtflags oldSettings = os.flags();
  //formatting
  os.precision(2);
  size_t len = seq.size();
  for(int i = len-1;i >= 0 ; i--) {
    os<<" "<<seq[i]<<" ";
  }
  os<<" <- start";
  //rewrite old settings:
  os.flags(oldSettings);
  return os;
}

/* ************************************
 */


class NoAttributes
{
  public:
    bool operator==(const NoAttributes& /*att*/) const {return true;}
    bool operator!=(const NoAttributes& /*att*/) const {return false;}
};





/* ****************************************************
 */


class DLLIMPORT TimeSignalAttributes
{

    double dT;

  public:

    TimeSignalAttributes();
    virtual ~TimeSignalAttributes();

    virtual double deltaT() const { return dT; }
    virtual void setDeltaT(double deltaTime);

    bool operator==(const TimeSignalAttributes& att) const;
    bool operator!=(const TimeSignalAttributes& att) const;

};


/* ******************************************
 */
inline bool TimeSignalAttributes::operator==(const TimeSignalAttributes& att) const
{
  return deltaT() == att.deltaT();
}

inline bool TimeSignalAttributes::operator!=(const TimeSignalAttributes& att) const
{
  return !operator==(att);
}





/* ****************************************************
 */

class DLLIMPORT FreqSignalAttributes
{

    double dF;

  public:

    FreqSignalAttributes();
    virtual ~FreqSignalAttributes();

    virtual double deltaF() const { return dF; }
    virtual void setDeltaF(double deltaFreq);


    bool operator==(const FreqSignalAttributes& att) const;
    bool operator!=(const FreqSignalAttributes& att) const;

};


/* ******************************************
 */


inline bool FreqSignalAttributes::operator==(const FreqSignalAttributes& att) const
{
  return deltaF() == att.deltaF();
}

inline bool FreqSignalAttributes::operator!=(const FreqSignalAttributes& att) const
{
  return !operator==(att);
}


/* ******************************************
 */


typedef  SignalSequence<bool> BoolSeq;

typedef  SignalSequence<int> IntSeq;

typedef SignalSequence<double> DoubleSeq;

typedef  SignalSequence<Complex> ComplexSeq;

typedef  simth::Array<Complex> ComplexArray;





typedef  BoolSeq BitSeq;

typedef  IntSeq ModIndSeq;

typedef DoubleSeq PhaseSeq;

typedef  ComplexSeq ModSeq;

typedef  ComplexArray SignalSym;

typedef  SignalSequence<SignalSym> SymSeq;


typedef  double LlrType;


typedef  double LlvType;

typedef  simth::checkedVector<LlvType> Llv;

typedef  SignalSequence<LlrType> LlrSeq;

typedef SignalSequence<Complex,TimeSignalAttributes> TimeSignal;

typedef SignalSequence<Complex,FreqSignalAttributes> FreqSignal;



std::ostream& operator<<(std::ostream &os, const BitSeq &bits);


//Referenzen auf Eintraege in vector<bool> spezifizieren
//typedef std::vector<bool>::reference bit_reference;
//typedef std::vector<bool>::const_reference const_bit_reference;


/* ****************************************************
 */

class LlvSeqAttributes
{
    //friend class LlvSeqAccess;
    friend class LlvSeq;
    friend class LlvSeqStorage;

    unsigned bitsPerState_;
    size_t numStates_;
    void setBitsPerState(unsigned numBits);

    void invariante() const;
  public:
    LlvSeqAttributes();
    LlvSeqAttributes(unsigned bitsPerState);
    unsigned bitsPerState() const {return bitsPerState_;}
    size_t numStates() const { return numStates_;}

    bool operator==(const LlvSeqAttributes& att) const;
    bool operator!=(const LlvSeqAttributes& att) const;

};


class LlvSeqStorage;

class LlvSeqAccess;

class LlvSeq : public SignalSequenceBase<Llv, LlvSeqAttributes, simth::checkedVector<Llv>, LlvSeqStorage, LlvSeqAccess>
{
  public:

    typedef LlvSeqStorage storage_type;
    typedef LlvSeqAccess access_type;


    typedef Llv value_type;
    typedef LlvSeqAttributes attributes_type;
    typedef simth::checkedVector<value_type> container_type;

    typedef container_type::iterator iterator;
    typedef container_type::const_iterator const_iterator;

    typedef container_type::reference reference;
    typedef container_type::const_reference const_reference;


    LlvSeq(iterator iterStart,iterator iterEnd, storage_type& origStorage);

    LlvSeq(const LlvSeq& sig);

    virtual ~LlvSeq() = 0;

    LlvSeq& operator=(const LlvSeq& seq);

    void resize(size_t newLength, unsigned newBitsPerSymbol);
    void resize(size_t newLength);

  protected:

    LlvSeq( );

  private:
    typedef SignalSequenceBase<value_type, attributes_type, container_type, storage_type, access_type> base_type;
};


class LlvSeqStorage : public LlvSeq
{
  public:

    typedef LlvSeq::value_type value_type;
    typedef LlvSeq::attributes_type attributes_type;
    typedef LlvSeq::container_type container_type;
    typedef LlvSeq base_type;

    typedef container_type::iterator iterator;
    typedef container_type::const_iterator const_iterator;

    typedef container_type::reference reference;
    typedef container_type::const_reference const_reference;


    LlvSeqStorage(size_t size, unsigned bitsPerState);

    LlvSeqStorage(size_t size, const value_type& val = value_type());

    LlvSeqStorage(const LlvSeq& seq);

    virtual ~LlvSeqStorage();

    LlvSeqStorage& operator=(const LlvSeqStorage& seq);

    size_t capacity() const { return ownStorage.capacity(); }

    void resize(size_t newLength, unsigned newBitsPerSymbol);
    void resize(size_t newLength);

    attributes_type& wAttributes();

    const attributes_type& rAttributes() const { return attributes_; }

    void lock() {lock_ = true;}

    void unlock() {lock_= false;}

    bool isLocked() const {return lock_;}

  private:
    container_type ownStorage; //must be created on the heap!
    attributes_type attributes_ ;
    bool lock_;

    void invariante() const {};


};

class LlvSeqAccess : public LlvSeq
{
  public:
    LlvSeqAccess(iterator iterStart,
                 iterator iterEnd, LlvSeqStorage &origStorage) ;

    LlvSeqAccess(const LlvSeq& sig);

    //LlvSeqAccess(LlvSeqStor& seq);

    virtual ~LlvSeqAccess() {};

    //LlvSeq& operator=(LlvSeq& seq);
    LlvSeqAccess& operator=(const LlvSeqAccess& seq);
};



/* ****************************************************
 */

unsigned bits2value(BitSeq::const_iterator first,
                    BitSeq::const_iterator behindLast);

inline bool value2bit(unsigned index, size_t bitPos)
{
#if DEBUG==1
  if(bitPos > MAX_BITS_PER_SYMBOL) {
    throw std::out_of_range("value2bit: bitPos > MAX_BITS_PER_SYMBOL");
  }
#endif

  return index & ( 0x1 << bitPos );
}

void value2bits(unsigned index,
                BitSeq::iterator first, BitSeq::iterator behindLast);

inline double llrValue2llvValue(LlrType llrValue, bool bitValue)
{
  if(bitValue == 0) {
    return  (llrValue/2.0);
  }
  else {
    return -(llrValue/2.0);  //negative llr Value <-> bit = 1!
  }
}

inline bool llrValue2bit(LlrType llrValue)
{
  if(llrValue > 0.0) {
    return 0;
  }
  else {
    return 1; //negative llr Value <-> bit = 1!
  }
}

inline LlvType bit2llvValue(bool bit, bool index)
{
  if(bit == index) {
    return 1.0;
  }
  else {
    return -1.0;
  }
}

inline LlrType bit2llrValue(bool bit)
{
  return bit==1? -2.0 : 2.0;  //i.e. bit2llvValue(bit,0)-bit2llvValue(1);
}


void bitSeq2llvSeq(const BitSeq& bits, LlvSeq& llv);
void bitSeq2llvSeq(const BitSeq& bits, LlvSeq* llv);

void llrSeq2bitLlvSeq(const LlrSeq& llr, LlvSeq& llv);
void llrSeq2bitLlvSeq(const LlrSeq& llr, LlvSeq* llv);

void llrSeq2bitSeq(const LlrSeq& from, BitSeq& bits);
void llrSeq2bitSeq(const LlrSeq& from, BitSeq* bits);

void llvSeq2bitLlvSeq(const LlvSeq& from, LlvSeq& bitLlv);
void llvSeq2bitLlvSeq(const LlvSeq& from, LlvSeq* bitLlv);

void llvSeq2llrSeq(const LlvSeq& from, LlrSeq& to,
                   size_t outputLength = 0);
void llvSeq2llrSeq(const LlvSeq& from, LlrSeq* to,
                   size_t outputLength = 0);

void bitLlvSeq2llvSeq(const LlvSeq& from, LlvSeq& to,
                      unsigned bitsPerState=0);
void bitLlvSeq2llvSeq(const LlvSeq& from, LlvSeq* to,
                      unsigned bitsPerState=0);
void bitSeq2IntSeq(const simth::BitSeq& bs, simth::checkedVector<int>& IntSeq, int numBits);


enum ConversionFlag {CUT, FILL, FIT};
size_t getSymSeqLength(size_t bitSeqLen, unsigned bitsPerSym,
                       ConversionFlag flag = FIT);



enum ModType {
  UNMOD,
  PSK_2,
  PSK_4,
  PSK_8,
  RAM_8,
  QAM_4,
  QAM_16,
  QAM_32,
  RAM_32,
  QAM_64,
  QAM_128,
  RAM_128,
  QAM_256
};

class LoadingInfo
{
  public:
    ModType modtype;
    double  amplification;
};

typedef simth::SignalSequence<LoadingInfo> LoadingInfoSeq;




} // namespace

#endif

---