bitmapping.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          bitmapping.h  -  description
                             -------------------
    begin                : Mon May 26 2003
    copyright            : (C) 2003 by Peter Haase
    email                : p.haase@tuhh.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 BITMAPPING_H
#define BITMAPPING_H

#include <iostream>
#include <memory>

#include <simthetic/misc.h>
#include <simthetic/phbib.h>
#include <simthetic/containers.h>

namespace simthlib
{


enum map_type {
  GRAY,
  NATURAL,
  PARTITIONED
};
map_type string2map_type(const std::string& s);

class MappingScheme;
std::ostream& operator<<(std::ostream &os, const MappingScheme& mapping);



class Gray
{
  private:

    int grayMap[simth::MAX_STATES_PER_SYMBOL];

    int invGrayMap[simth::MAX_STATES_PER_SYMBOL];

    void check(int i);
  public:
    Gray();
    int toGray(int i);
    int inverseGray(int i);
};


class StaticGray
{
  private:
    static Gray helpGray;

  public:
    static int toGray(int i);

    static int inverseGray(int i);
};



// //////////////////////////////////////////////////////////


class MappingScheme
{
  protected:
    //Bits pro Symbol
    //im folgenden Beispiel gleich 2
    const int bitsPerSymbol;
    //Modulationswertigkeit
    //im folgenden Beispiel gleich 4
    const int modulationValency;

    //die Bits werden in einem 2 dimensionalen
    //Vektor geschrieben
    //Beispiel (gray mapping)
    //
    //Symbol-|
    //index  | 0 | 1 | 2 | 3
    //       ------------------------
    //Bit 1  | 0 | 0 | 1 | 1
    //Bit 2  | 0 | 1 | 1 | 0
    simth::boolVector2d bitArray;

    //wie oben, aber anstatt der Bits pro Symbol
    //wird der zugehoerige Integerwert eingetragen
    //Fuer das obige Beispiel (gray mapping) also:
    //Symbol-|
    //index  | 0 | 1 | 2 | 3
    //       ------------------------
    //Wert   | 0 | 1 | 3 | 2
    int mappedIndex[simth::MAX_STATES_PER_SYMBOL];
    //Wie mappedIndex aber Invertierung durch Vertauschen der Zeilen
    int mappedInteger[simth::MAX_STATES_PER_SYMBOL];

  public:
    MappingScheme(int bitsPerState);

    virtual ~MappingScheme(){};

    //eventuell auf fehler vor boolVector2d testen
    bool getBit(int symbIndex, int bitPos) const
      {return bitArray[symbIndex][bitPos];}

    int getDataValue(int symbolIndex) const ;


    int getSymbolIndex(int integerValue) const ;


    virtual void print(std::ostream &os, bool detailedPrint = false) const;

    static std::auto_ptr<simthlib::MappingScheme> 
    newMapping(int bitsPerSymbolPar, map_type mappMode);
    static std::auto_ptr<simthlib::MappingScheme> 
    new2DimMapping(int numBits1, int numBits2, map_type mappMode);
    static std::auto_ptr<simthlib::MappingScheme> 
    newApskMapping(int bitsPerState, map_type mappMode);
    static std::auto_ptr<simthlib::MappingScheme> 
    newQamMapping(int bitsPerState, map_type mappMode);
};



// ////////////////////////////////////////////////////////////


class NaturalMapping : public MappingScheme
{

  public:
    NaturalMapping(int bitsPerState);

    virtual ~NaturalMapping(){};

    virtual void print(std::ostream &os, bool detailedPrint = false) const;
};

class GrayMapping : public MappingScheme
{

  public:
    GrayMapping(int bitsPerState);
    virtual ~GrayMapping(){};
    virtual void print(std::ostream &os, bool detailedPrint = false) const;
};

class GrayMapping2Dimension : public MappingScheme
{
  public:
    GrayMapping2Dimension(int bitsPerAmplitude, int bitsPerPhase);
    virtual ~GrayMapping2Dimension(){};
    virtual void print(std::ostream &os, bool detailedPrint = false) const;
};

class PartitionedMappingRectangular : public MappingScheme
{
  private:
    int reBits;
    int imBits;
    void partitioningStep(int step);
  public:
    PartitionedMappingRectangular(int bitsPerSymbol);
    virtual ~PartitionedMappingRectangular(){};
    //virtual void print(std::ostream &os, bool detailedPrint = false) const;
};

// The factory classes MappingMaker have been removed in favor of
// static factory functions in the MappingScheme class and additionaly
// the usage of std::auto_ptr in the device classes. 


}

#endif

---