phbib.h

Go to the documentation of this file.

/***************************************************************************
                          phbib.h  -  description
                             -------------------
    begin                : Wed May 8 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 PHBIB_HEADER
#define PHBIB_HEADER


#include <string>
#include <vector>
#include <iostream>
#include <sstream>
#include <typeinfo>

#include <simthetic/misc.h>
#include <simthetic/exceptions.h>

// Note: These includes are added for backward compatibility. They may
// be removed sometime in the future.
#include <simthetic/parameterfile.h>


namespace simth
{

// Konvertiert einen Integer in einen String der C++ STD
std::string i2string(int value);
std::string oct2string(int value);
int oct2int(int oct);

std::string demangle(const char *symbol);



class BadConversion : public std::runtime_error
{
  public:
    BadConversion(const std::string& s)
        : std::runtime_error(s)
  { }}
;

template<typename T>
inline std::string stringify(const T& x)
{
  std::ostringstream o;
  if (!(o << x))
    throw BadConversion(std::string("stringify(")
                        + typeid(x).name() + ")");
  return o.str();
}

template<typename T>
inline T convertTo(const std::string& s,
                   bool failIfLeftoverChars = true)
{
  T x;
  convert(s, x, failIfLeftoverChars);
  return x;
}



double arg(const Complex& comp);

int inversePower2(int x);


inline double db2linearPowerRatio(double snr)
{
  return pow(10.0, snr/10.0);
}

inline double db2reciprocalLinearPowerRatio(double snr)
{
  return pow(10.0, -snr/10.0);
}


inline void computeSplittedSizes(size_t inSize, size_t inBits1, 
                 size_t inBits2, size_t& outSize1, 
                 size_t& outSize2);

template<class T>
void splitSequence(const T &in, T* out1, T* out2, size_t bits1, size_t bits2)
{

  if(DEBUG) {
    if(in.size() % (bits1+bits2) != 0) {
      throw std::runtime_error("void simth::splitSequence() "
                               ": bit size is not a multiplier of bitsPerSymbol");
    }
  }

  static size_t inSize = 0;
  static size_t outSize1 = 0;
  static size_t outSize2 = 0;

  if(inSize != in.size()) {
    inSize = in.size();
    computeSplittedSizes(inSize, bits1, bits2, outSize1, outSize2);
  }
  if(out1->size() != outSize1) {
    out1->resize(outSize1);
  }
  if(out2->size() != outSize2) {
    out2->resize(outSize2);
  }

  typename T::const_iterator iter = in.begin();
  typename T::iterator iterOut1 = out1->begin();
  typename T::iterator iterOut2 = out2->begin();
  while(iter != in.end()) {
    for(size_t a=0; a<bits1;a++) {
      (*iterOut1) = (*iter);
      iterOut1++;
      iter++;
    }
    for(size_t p=0; p<bits2;p++) {
      (*iterOut2) = (*iter);
      iterOut2++;
      iter++;
    }
  }
  if(DEBUG) {
    if(iter != in.end()) {
      throw std::logic_error("void splitSequence(const bitSeq &in, bitSeq* out1, bitSeq* out2) "
                             "const : error 1");
    }
    if(iterOut1 != out1->end()) {
      throw std::logic_error("void splitSequence(const bitSeq &in, bitSeq* out1, bitSeq* out2) "
                             "const : error 2");
    }
    if(iterOut2 != out2->end()) {
      throw std::logic_error("void splitSequence(const bitSeq &in, bitSeq* out1, bitSeq* out2) "
                             "const : error 3");
    }
  }
}


template<class T>
void mergeSequences(const T& out1, const T& out2,
                    size_t bits1, size_t bits2, T* outSeq)
{

  if(DEBUG) {
    if(out1.size()*bits2 != out2.size()*bits1) {
      throw std::runtime_error("inline void mergeSequences(const T& out1, const T& out2, size_t bits1, size_t bits2, "
                               "T* outSeq) : out1.size()*bits2 must equal  out2.size()*bits1");
    }
  }

  outSeq->resize(out1.size()+out2.size());

  typename T::const_iterator iterOut1 = out1.begin();
  typename T::const_iterator iterOut2 = out2.begin();
  typename T::iterator iter = outSeq->begin();
  while(iter != outSeq->end()) {
    for(size_t p=0; p<bits1;p++) {
      (*iter) = (*iterOut1);
      ++iterOut1;
      ++iter;
    }
    for(size_t a=0; a<bits2;a++) {
      (*iter) = (*iterOut2);
      ++iterOut2;
      ++iter;
    }
  }
  if(DEBUG) {
    if(iter != outSeq->end()) {
      throw std::logic_error("mergeSequence(const bitSeq &in, bitSeq* out1, bitSeq* out2) "
                             "const : error 1");
    }
    if(iterOut1 != out1.end()) {
      throw std::logic_error("void SoftOutDAPSKDecoder::mergeSequence(const bitSeq &in, bitSeq* out1, bitSeq* out2) "
                             "const : error 2");
    }
    if(iterOut2 != out2.end()) {
      throw std::logic_error("void SoftOutDAPSKDecoder::mergeSequence(const bitSeq &in, bitSeq* out1, bitSeq* out2) "
                             "const : error 3");
    }
  }
}

inline void computeSplittedSizes(size_t inSize, size_t inBits1, size_t inBits2, size_t& outSize1, size_t& outSize2)
{
  if(DEBUG) {
    if((inBits1+inBits2) == 0) {
      throw std::logic_error("void SoftOutDAPSKDecoder::computeSplittedSizes(const bitSeq &bsin, bitSeq* amplSeq, "
                             "bitSeq* phaseSeq) : error 1");
    }
  }

  size_t numSyms = inSize / (inBits1+inBits2);
  outSize1 = numSyms * inBits1;
  outSize2 = numSyms * inBits2;

  if(DEBUG) {
    if((outSize1 + outSize2) != inSize) {
      throw simth::ParameterErr("void computeSplittedSizes(size_t inSize, size_t inBits1, size_t inBits2, int* outSize1, "
                                "int* outSize2) : bit inSize is not a multiplier of inBits1+inBits2");
    }
  }
}

inline void computeSplittedSizes(size_t inSize,
                                 size_t inBits1, size_t inBits2,
                                 size_t* outSize1, size_t* outSize2)
{
  computeSplittedSizes(inSize, inBits1, inBits2, *outSize1, *outSize2);
}


} // namespace

#endif

---