inet::physicallayer::ConvolutionalCoder Class Reference

#include <ConvolutionalCoder.h>

Inheritance diagram for inet::physicallayer::ConvolutionalCoder:

Classes
class	TrellisGraphNode

Public Types
typedef std::vector< std::vector< ShortBitVector > >	ShortBitVectorMatrix
Public Types inherited from inet::physicallayer::IPrintableObject
enum	PrintLevel {   PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO,   PRINT_LEVEL_COMPLETE = INT_MIN }

Public Member Functions
	ConvolutionalCoder (const ConvolutionalCode *convolutionalCode)
	~ConvolutionalCoder ()
BitVector	encode (const BitVector &informationBits) const override
std::pair< BitVector, bool >	decode (const BitVector &encodedBits) const override
const ConvolutionalCode *	getForwardErrorCorrection () const override
unsigned int	getMemorySizeSum () const
const std::vector< int > &	getConstraintLengthVector () const
const ShortBitVectorMatrix &	getTransferFunctionMatrix () const
const std::vector< ShortBitVector > &	getPuncturingMatrix () const
int	getNumberOfStates () const
int	getNumberOfOutputSymbols () const
int	getNumberOfInputSymbols () const
const int **	getStateTransitionTable () const
const int **	getOutputTable () const
std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...
Public Member Functions inherited from inet::physicallayer::IPrintableObject
virtual	~IPrintableObject ()
virtual std::string	getInfoStringRepresentation () const
virtual std::string	getDetailStringRepresentation () const
virtual std::string	getDebugStringRepresentation () const
virtual std::string	getTraceStringRepresentation () const
virtual std::string	getCompleteStringRepresentation () const

Protected Member Functions
bool	eXOR (bool alpha, bool beta) const
void	setTransferFunctionMatrix (std::vector< std::vector< int > > &transferFMatrix)
ShortBitVector	inputSymbolToOutputSymbol (const ShortBitVector &state, const ShortBitVector &inputSymbol) const
bool	modulo2Adder (const ShortBitVector &shiftRegisters, const ShortBitVector &generatorPolynomial) const
ShortBitVector	giveNextOutputSymbol (const BitVector &encodedBits, int decodedLength, const BitVector &isPunctured, ShortBitVector &excludedFromHammingDistance) const
BitVector	puncturing (const BitVector &informationBits) const
BitVector	depuncturing (const BitVector &decodedBits, BitVector &isPunctured) const
BitVector	getPuncturedIndices (unsigned int length) const
unsigned int	computeHammingDistance (const ShortBitVector &u, const ShortBitVector &excludedBits, const ShortBitVector &w) const
void	updateTrellisGraph (TrellisGraphNode **trellisGraph, unsigned int time, const ShortBitVector &outputSymbol, const ShortBitVector &excludedFromHammingDistance) const
bool	isCompletelyDecoded (unsigned int encodedLength, unsigned int decodedLength) const
void	initParameters ()
void	memoryAllocations ()
void	computeHammingDistanceLookupTable ()
void	computeMemorySizes ()
void	computeMemorySizeSum ()
void	computeNumberOfStates ()
void	computeNumberOfInputAndOutputSymbols ()
void	computeStateTransitions ()
void	computeOutputAndInputSymbols ()
void	computeDecimalToOutputSymbolVector ()
void	printStateTransitions () const
void	printOutputs () const
void	printTransferFunctionMatrix () const
void	parseMatrix (const char *strMatrix, std::vector< std::vector< int > > &matrix) const
void	parseVector (const char *strVector, std::vector< int > &vector) const
void	convertToShortBitVectorMatrix (std::vector< std::vector< int > > &matrix, std::vector< ShortBitVector > &boolMatrix) const
ShortBitVector	octalToBinary (int octalNum, int fixedSize) const
int	octalToDec (int octalNum) const
std::pair< BitVector, bool >	traversePath (const TrellisGraphNode &bestNode, TrellisGraphNode **bestPaths, bool isTruncatedMode) const

Protected Attributes
const char *	mode
unsigned int	codeRateParamaterK
unsigned int	codeRateParamaterN
unsigned int	codeRatePuncturingK
unsigned int	codeRatePuncturingN
int	memorySizeSum
std::vector< int >	memorySizes
std::vector< int >	constraintLengths
int	numberOfStates
int	numberOfInputSymbols
int	numberOfOutputSymbols
ShortBitVectorMatrix	transferFunctionMatrix
std::vector< ShortBitVector >	puncturingMatrix
int **	inputSymbols
ShortBitVector **	outputSymbols
ShortBitVector *	decimalToInputSymbol
ShortBitVector *	decimalToOutputSymbol
int **	stateTransitions
unsigned char ***	hammingDistanceLookupTable
std::vector< std::vector< TrellisGraphNode > >	trellisGraph
const ConvolutionalCode *	convolutionalCode

Member Typedef Documentation

typedef std::vector<std::vector<ShortBitVector> > inet::physicallayer::ConvolutionalCoder::ShortBitVectorMatrix

Constructor & Destructor Documentation

inet::physicallayer::ConvolutionalCoder::ConvolutionalCoder

(

const ConvolutionalCode *

convolutionalCode

)

                                                                                 : convolutionalCode(convolutionalCode)
{
    const char *strTransferFunctionMatrix = convolutionalCode->getTransferFunctionMatrix();
    const char *strPuncturingMatrix = convolutionalCode->getPuncturingMatrix();
    const char *strConstraintLengthVector = convolutionalCode->getConstraintLengthVector();
    mode = convolutionalCode->getMode();
    if (strcmp(mode, "terminated") && strcmp(mode, "truncated"))
        throw cRuntimeError("Unknown (= %s ) coding mode", mode);
    codeRatePuncturingK = convolutionalCode->getCodeRatePuncturingK();
    codeRatePuncturingN = convolutionalCode->getCodeRatePuncturingN();
    parseVector(strConstraintLengthVector, constraintLengths);
    std::vector<std::vector<int> > pMatrix;
    parseMatrix(strPuncturingMatrix, pMatrix);
    convertToShortBitVectorMatrix(pMatrix, puncturingMatrix);
    std::vector<std::vector<int> > transferFMatrix;
    parseMatrix(strTransferFunctionMatrix, transferFMatrix);
    codeRateParamaterK = transferFMatrix.size();
    codeRateParamaterN = transferFMatrix.at(0).size();
    for (unsigned int i = 0; i < transferFMatrix.size(); i++) {
        for (unsigned int j = 0; j < transferFMatrix.at(i).size(); j++) {
            int decPolynom = octalToDec(transferFMatrix.at(i).at(j));
            int constraintLength = constraintLengths[i];
            if (decPolynom >= pow(2, constraintLength))
                throw cRuntimeError("Code size is greater then constraint length");
        }
    }
    // TODO: check whether it is less than..
    for (unsigned int i = 0; i < codeRateParamaterK; i++)
        if (transferFMatrix.at(i).size() != codeRateParamaterN)
            throw cRuntimeError("Transfer function matrix must be a k-by-n matrix of octal numbers");
    if (transferFMatrix.size() != constraintLengths.size())
        throw cRuntimeError("Constraint length vector must be a 1-by-k vector of integers");
    if (puncturingMatrix.size() != codeRateParamaterN)
        throw cRuntimeError("Puncturing matrix must be a n-by-arbitrary bool matrix");
    setTransferFunctionMatrix(transferFMatrix);
    initParameters();
}

inet::physicallayer::ConvolutionalCoder::~ConvolutionalCoder

(

)

{
    for (int i = 0; i < numberOfOutputSymbols; i++) {
        for (int j = 0; j < numberOfOutputSymbols; j++)
            delete[] hammingDistanceLookupTable[i][j];
        delete[] hammingDistanceLookupTable[i];
    }
    delete[] hammingDistanceLookupTable;
    for (int i = 0; i < numberOfStates; i++) {
        delete[] stateTransitions[i];
        delete[] outputSymbols[i];
        delete[] inputSymbols[i];
    }
    delete[] stateTransitions;
    delete[] outputSymbols;
    delete[] inputSymbols;
    delete[] decimalToOutputSymbol;
    delete[] decimalToInputSymbol;
}

Member Function Documentation

void inet::physicallayer::ConvolutionalCoder::computeDecimalToOutputSymbolVector ( )

protected

Referenced by initParameters().

{
    for (int i = 0; i != numberOfOutputSymbols; i++) {
        ShortBitVector outputSymbol(i, codeRateParamaterN);
        decimalToOutputSymbol[outputSymbol.reverseToDecimal()] = outputSymbol;
    }
}

unsigned int inet::physicallayer::ConvolutionalCoder::computeHammingDistance ( const ShortBitVector &  u, const ShortBitVector &  excludedBits, const ShortBitVector &  w  ) const

inlineprotected

Referenced by updateTrellisGraph().

    {
#ifndef NDEBUG
        if (u.isEmpty() || w.isEmpty())
            throw cRuntimeError("You can't compute the Hamming distance between undefined BitVectors");
        if (u.getSize() != w.getSize())
            throw cRuntimeError("You can't compute Hamming distance between two vectors with different sizes");
#endif // ifndef NDEBUG
        return hammingDistanceLookupTable[u.toDecimal()][w.toDecimal()][excludedBits.toDecimal()];
    }

void inet::physicallayer::ConvolutionalCoder::computeHammingDistanceLookupTable ( )

protected

Referenced by initParameters().

{
    for (int i = 0; i < numberOfOutputSymbols; i++) {
        for (int j = 0; j < numberOfOutputSymbols; j++) {
            for (int k = 0; k < numberOfOutputSymbols; k++) {
                unsigned int hammingDistance = i ^ j;
                hammingDistance = hammingDistance & k;
                hammingDistance = hammingDistance - ((hammingDistance >> 1) & 0x55555555);
                hammingDistance = (hammingDistance & 0x33333333) + ((hammingDistance >> 2) & 0x33333333);
                hammingDistanceLookupTable[i][j][k] = (((hammingDistance + (hammingDistance >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
            }
        }
    }
}

void inet::physicallayer::ConvolutionalCoder::computeMemorySizes ( )

protected

Referenced by initParameters().

{
    for (auto& elem : constraintLengths)
        memorySizes.push_back(elem - 1);
}

void inet::physicallayer::ConvolutionalCoder::computeMemorySizeSum ( )

protected

Referenced by initParameters().

{
    memorySizeSum = 0;
    for (auto& elem : memorySizes)
        memorySizeSum += elem;
}

void inet::physicallayer::ConvolutionalCoder::computeNumberOfInputAndOutputSymbols ( )

protected

Referenced by initParameters().

{
    numberOfInputSymbols = (int)pow(2, codeRateParamaterK);
    numberOfOutputSymbols = (int)pow(2, codeRateParamaterN);
}

void inet::physicallayer::ConvolutionalCoder::computeNumberOfStates ( )

protected

Referenced by initParameters().

{
    numberOfStates = (int)pow(2, memorySizeSum);
}

void inet::physicallayer::ConvolutionalCoder::computeOutputAndInputSymbols ( )

protected

Referenced by initParameters().

{
    for (int i = 0; i != numberOfInputSymbols; i++) {
        ShortBitVector inputSymbol(i, codeRateParamaterK);
        decimalToInputSymbol[inputSymbol.reverseToDecimal()] = inputSymbol;
    }
    for (int decState = 0; decState != numberOfStates; decState++) {
        ShortBitVector state(decState, memorySizeSum);
        for (int decInputSymbol = 0; decInputSymbol != numberOfInputSymbols; decInputSymbol++) {
            const ShortBitVector& inputSymbol = decimalToInputSymbol[decInputSymbol];
            ShortBitVector outputSymbol = inputSymbolToOutputSymbol(state, inputSymbol);
            int decOutputSymbol = outputSymbol.reverseToDecimal();
            int reverseDec = state.reverseToDecimal();
            outputSymbols[reverseDec][decInputSymbol] = outputSymbol;
            inputSymbols[reverseDec][decOutputSymbol] = decInputSymbol;
        }
    }
}

void inet::physicallayer::ConvolutionalCoder::computeStateTransitions ( )

protected

Referenced by initParameters().

{
    for (int decState = 0; decState != numberOfStates; decState++) {
        ShortBitVector state(decState, memorySizeSum);
        ShortBitVector shiftedState = state;
        shiftedState.leftShift(1);
        for (int is = 0; is != numberOfInputSymbols; is++) {
            ShortBitVector nextState = shiftedState;
            ShortBitVector inputSymbol(is, codeRateParamaterK);
            int shift = 0;
            for (int m = inputSymbol.getSize() - 1; m >= 0; m--) {
                nextState.setBit(shift, inputSymbol.getBit(m));
                shift += memorySizes.at(m);
            }
            stateTransitions[state.reverseToDecimal()][inputSymbol.reverseToDecimal()] = nextState.reverseToDecimal();
        }
    }
}

void inet::physicallayer::ConvolutionalCoder::convertToShortBitVectorMatrix ( std::vector< std::vector< int > > &  matrix, std::vector< ShortBitVector > &  boolMatrix  ) const

protected

Referenced by ConvolutionalCoder().

{
    for (auto& elem : matrix) {
        std::vector<int> matrixRow = elem;
        ShortBitVector row;
        for (auto& matrixRow_j : matrixRow) {
            if (matrixRow_j == 1)
                row.appendBit(true);
            else if (matrixRow_j == 0)
                row.appendBit(false);
            else
                throw cRuntimeError("A bool matrix only contains 0-1 values");
        }
        boolMatrix.push_back(row);
    }
}

std::pair< BitVector, bool > inet::physicallayer::ConvolutionalCoder::decode ( const BitVector &  encodedBits ) const

overridevirtual

Implements inet::physicallayer::IFECCoder.

Referenced by inet::physicallayer::ConvolutionalCoderModule::decode().

{
    BitVector isPunctured;
    BitVector depuncturedEncodedBits = depuncturing(encodedBits, isPunctured);
    unsigned int encodedBitsSize = depuncturedEncodedBits.getSize();
    if (encodedBitsSize % codeRateParamaterN != 0)
        throw cRuntimeError("Length of encodedBits must be a multiple of codeRateParamaterN = %d", codeRateParamaterN);
    bool isTruncatedMode = false;
    if (!strcmp(mode, "truncated"))
        isTruncatedMode = true;
    else if (!strcmp(mode, "terminated"))
        isTruncatedMode = false;
    else
        throw cRuntimeError("Unknown decodingMode = %s decodingMode", mode);
    TrellisGraphNode **trellisGraph;
    trellisGraph = new TrellisGraphNode *[numberOfStates];
    for (int i = 0; i != numberOfStates; i++) {
        int length = depuncturedEncodedBits.getSize() / codeRateParamaterN + 1;
        trellisGraph[i] = new TrellisGraphNode[length];
        for (int j = 0; j < length; j++)
            trellisGraph[i][j] = TrellisGraphNode(-1, -1, -1, INT32_MAX, 0, 0);
    }
    trellisGraph[0][0].state = 0;
    EV_DEBUG << "Decoding the following bits: " << depuncturedEncodedBits << endl;
    ShortBitVector countsOnHammingDistance;
    countsOnHammingDistance.appendBit(true, codeRateParamaterN);
    ShortBitVector nextOutputSymbol = giveNextOutputSymbol(depuncturedEncodedBits, 0, isPunctured, countsOnHammingDistance);
    unsigned int time = 0;
    while (!nextOutputSymbol.isEmpty()) {
        updateTrellisGraph(trellisGraph, time, nextOutputSymbol, countsOnHammingDistance);
        time++;
        countsOnHammingDistance = ShortBitVector();
        countsOnHammingDistance.appendBit(true, codeRateParamaterN);
        nextOutputSymbol = giveNextOutputSymbol(depuncturedEncodedBits, time * codeRateParamaterK, isPunctured, countsOnHammingDistance);
    }
    TrellisGraphNode bestNode;
    if (!isTruncatedMode)
        bestNode = trellisGraph[0][time];
    else {
        bestNode = trellisGraph[0][time];
        for (int i = 1; i != numberOfStates; i++) {
            TrellisGraphNode currentNode = trellisGraph[i][time];
            if (currentNode.symbol != -1 && currentNode.comulativeHammingDistance < bestNode.comulativeHammingDistance)
                bestNode = currentNode;
        }
    }
    std::pair<BitVector, bool> result = traversePath(bestNode, trellisGraph, isTruncatedMode);
    if (result.second)
    {
        EV_DEBUG << "Recovered message: " << result.first << endl;
        EV_DEBUG << "Number of errors: " << bestNode.numberOfErrors
                 << " Cumulative error (Hamming distance): " << bestNode.comulativeHammingDistance
                 << " End state: " << bestNode.state << endl;
    }
    else
        EV_DEBUG << "None of the paths in the trellis graph lead to the all-zeros state" << endl;
    for (int i = 0; i < numberOfStates; i++)
        delete[] trellisGraph[i];
    delete[] trellisGraph;
    return result;
}

BitVector inet::physicallayer::ConvolutionalCoder::depuncturing ( const BitVector &  decodedBits, BitVector &  isPunctured  ) const

protected

Referenced by decode().

{
    ASSERT(decodedBits.getSize() % codeRatePuncturingN == 0);
    int encodedLength = (decodedBits.getSize() / codeRatePuncturingN) * codeRatePuncturingK;
    int depuncturedLength = (encodedLength / codeRateParamaterK) * codeRateParamaterN;
    isPunctured = getPuncturedIndices(depuncturedLength);
    BitVector depuncturedDecodedBits;
    int idx = 0;
    for (int i = 0; i < depuncturedLength; i++) {
        if (isPunctured.getBit(i))
            depuncturedDecodedBits.appendBit(false);
        else {
            depuncturedDecodedBits.appendBit(decodedBits.getBit(idx));
            idx++;
        }
    }
    return depuncturedDecodedBits;
}

BitVector inet::physicallayer::ConvolutionalCoder::encode ( const BitVector &  informationBits ) const

overridevirtual

Implements inet::physicallayer::IFECCoder.

Referenced by inet::physicallayer::ConvolutionalCoderModule::encode().

{
    EV_DEBUG << "Encoding the following bits: " << informationBits << endl;
    if (informationBits.getSize() % codeRateParamaterK)
        throw cRuntimeError("Length of informationBits must be a multiple of codeRateParamaterK = %d", codeRateParamaterK);
    BitVector encodedInformationBits;
    int state = 0;
    for (unsigned int i = 0; i < informationBits.getSize(); i += codeRateParamaterK) {
        ShortBitVector inputSymbol;
        for (unsigned int j = i; j < i + codeRateParamaterK; j++)
            inputSymbol.appendBit(informationBits.getBit(j));
        int inputSymbolDec = inputSymbol.reverseToDecimal();
        const ShortBitVector& encodedSymbol = outputSymbols[state][inputSymbolDec];
        state = stateTransitions[state][inputSymbolDec];
        for (unsigned int j = 0; j < encodedSymbol.getSize(); j++)
            encodedInformationBits.appendBit(encodedSymbol.getBit(j));
    }
    BitVector puncturedEncodedInformationBits = puncturing(encodedInformationBits);
    EV_DEBUG << "The encoded bits are: " << puncturedEncodedInformationBits << endl;
    return puncturedEncodedInformationBits;
}

bool inet::physicallayer::ConvolutionalCoder::eXOR ( bool  alpha, bool  beta  ) const

inlineprotected

Referenced by inputSymbolToOutputSymbol(), and modulo2Adder().

{ return alpha != beta; }

const std::vector<int>& inet::physicallayer::ConvolutionalCoder::getConstraintLengthVector ( ) const

inline

{ return constraintLengths; }

const ConvolutionalCode* inet::physicallayer::ConvolutionalCoder::getForwardErrorCorrection ( ) const

inlineoverridevirtual

Implements inet::physicallayer::IFECCoder.

Referenced by inet::physicallayer::ConvolutionalCoderModule::getForwardErrorCorrection().

{ return convolutionalCode; }

unsigned int inet::physicallayer::ConvolutionalCoder::getMemorySizeSum ( ) const

inline

{ return memorySizeSum; }

int inet::physicallayer::ConvolutionalCoder::getNumberOfInputSymbols ( ) const

inline

{ return numberOfInputSymbols; }

int inet::physicallayer::ConvolutionalCoder::getNumberOfOutputSymbols ( ) const

inline

{ return numberOfOutputSymbols; }

int inet::physicallayer::ConvolutionalCoder::getNumberOfStates ( ) const

inline

{ return numberOfStates; }

const int** inet::physicallayer::ConvolutionalCoder::getOutputTable ( ) const

inline

{ return (const int **)inputSymbols; }

BitVector inet::physicallayer::ConvolutionalCoder::getPuncturedIndices ( unsigned int  length ) const

protected

Referenced by depuncturing(), and puncturing().

{
    BitVector isPunctured;
    isPunctured.appendBit(false, length);
    int puncturingMatrixSize = puncturingMatrix.at(0).getSize();
    for (unsigned int i = 0; i < codeRateParamaterN; i++) {
        int idx = 0;
        for (unsigned int j = 0; codeRateParamaterN *j + i < length; j++) {
            int place = idx % puncturingMatrixSize;
            bool stolen = !puncturingMatrix.at(i).getBit(place);
            isPunctured.setBit(codeRateParamaterN * j + i, stolen);
            idx++;
        }
    }
    return isPunctured;
}

const std::vector<ShortBitVector>& inet::physicallayer::ConvolutionalCoder::getPuncturingMatrix ( ) const

inline

{ return puncturingMatrix; }

const int** inet::physicallayer::ConvolutionalCoder::getStateTransitionTable ( ) const

inline

{ return (const int **)stateTransitions; }

const ShortBitVectorMatrix& inet::physicallayer::ConvolutionalCoder::getTransferFunctionMatrix ( ) const

inline

{ return transferFunctionMatrix; }

ShortBitVector inet::physicallayer::ConvolutionalCoder::giveNextOutputSymbol ( const BitVector &  encodedBits, int  decodedLength, const BitVector &  isPunctured, ShortBitVector &  excludedFromHammingDistance  ) const

protected

Referenced by decode().

{
    if (isCompletelyDecoded(encodedBits.getSize(), decodedLength))
        return ShortBitVector();
    int pos = decodedLength / codeRateParamaterK;
    ShortBitVector nextSymbol;
    int idx = 0;
    for (unsigned int i = pos * codeRateParamaterN; i < (pos + 1) * codeRateParamaterN; i++) {
        if (isPunctured.getBit(i))
            countsOnHammingDistance.setBit(idx, false);
        nextSymbol.appendBit(encodedBits.getBit(i));
        idx++;
    }
    return nextSymbol;
}

void inet::physicallayer::ConvolutionalCoder::initParameters ( )

protected

Referenced by ConvolutionalCoder().

{
    computeMemorySizes();
    computeMemorySizeSum();
    computeNumberOfStates();
    computeNumberOfInputAndOutputSymbols();
    memoryAllocations();
    computeOutputAndInputSymbols();
    computeStateTransitions();
    computeDecimalToOutputSymbolVector();
    computeHammingDistanceLookupTable();
}

ShortBitVector inet::physicallayer::ConvolutionalCoder::inputSymbolToOutputSymbol ( const ShortBitVector &  state, const ShortBitVector &  inputSymbol  ) const

protected

Referenced by computeOutputAndInputSymbols().

{
    ShortBitVector outputSymbol;
    outputSymbol.appendBit(false, codeRateParamaterN);
    int shift = 0;
    for (int i = inputSymbol.getSize() - 1; i >= 0; i--) {
        ShortBitVector shiftRegisters;
        shiftRegisters.appendBit(inputSymbol.getBit(i));
        for (int k = shift; k < shift + memorySizes[i]; k++)
            shiftRegisters.appendBit((unsigned int)k >= state.getSize() ? false : state.getBit(k));
        const std::vector<ShortBitVector>& row = transferFunctionMatrix.at(i);
        for (unsigned int j = 0; j < row.size(); j++) {
            const ShortBitVector& generatorPolynomial = row.at(j);
            outputSymbol.setBit(j, eXOR(outputSymbol.getBit(j), modulo2Adder(shiftRegisters, generatorPolynomial)));
        }
        shift += memorySizes[i];
    }
    return outputSymbol;
}

bool inet::physicallayer::ConvolutionalCoder::isCompletelyDecoded ( unsigned int  encodedLength, unsigned int  decodedLength  ) const

protected

Referenced by giveNextOutputSymbol().

{
    ASSERT(decodedLength % codeRateParamaterK == 0);
    unsigned int pos = decodedLength / codeRateParamaterK;
    return (pos + 1) * codeRateParamaterN > encodedLength;
}

void inet::physicallayer::ConvolutionalCoder::memoryAllocations ( )

protected

Referenced by initParameters().

{
    decimalToOutputSymbol = new ShortBitVector[numberOfOutputSymbols];
    outputSymbols = new ShortBitVector *[numberOfStates];
    decimalToInputSymbol = new ShortBitVector[numberOfInputSymbols];
    stateTransitions = new int *[numberOfStates];
    inputSymbols = new int *[numberOfStates];
    hammingDistanceLookupTable = new unsigned char **[numberOfOutputSymbols];
    for (int i = 0; i < numberOfOutputSymbols; i++) {
        hammingDistanceLookupTable[i] = new unsigned char *[numberOfOutputSymbols];
        for (int j = 0; j < numberOfOutputSymbols; j++)
            hammingDistanceLookupTable[i][j] = new unsigned char[numberOfOutputSymbols];
    }
    for (int i = 0; i < numberOfStates; i++) {
        stateTransitions[i] = new int[numberOfInputSymbols];
        inputSymbols[i] = new int[numberOfOutputSymbols];
        outputSymbols[i] = new ShortBitVector[numberOfInputSymbols];
        for (int j = 0; j < numberOfInputSymbols; j++) {
            stateTransitions[i][j] = -1;
            outputSymbols[i][j] = ShortBitVector();
        }
        for (int j = 0; j < numberOfOutputSymbols; j++)
            inputSymbols[i][j] = -1;
    }
}

bool inet::physicallayer::ConvolutionalCoder::modulo2Adder ( const ShortBitVector &  shiftRegisters, const ShortBitVector &  generatorPolynomial  ) const

protected

Referenced by inputSymbolToOutputSymbol().

{
    bool sum = false;
    for (unsigned int i = 0; i < generatorPolynomial.getSize(); i++) {
        if (generatorPolynomial.getBit(i))
            sum = eXOR(sum, shiftRegisters.getBit(i));
    }
    return sum;
}

ShortBitVector inet::physicallayer::ConvolutionalCoder::octalToBinary ( int  octalNum, int  fixedSize  ) const

protected

Referenced by setTransferFunctionMatrix().

{
    unsigned int powerOfEight = 1;
    unsigned int decimal = 0;
    while (octalNum > 0) {
        unsigned int octalDigit = octalNum % 10;
        octalNum /= 10;
        decimal += octalDigit * powerOfEight;
        powerOfEight *= 8;
    }
    return ShortBitVector(decimal, fixedSize);
}

int inet::physicallayer::ConvolutionalCoder::octalToDec ( int  octalNum ) const

protected

Referenced by ConvolutionalCoder().

{
    int powersOfEight = 1;
    int decVal = 0;
    while (octalNum != 0) {
        int octDigit = octalNum % 10;
        decVal += octDigit * powersOfEight;
        octalNum /= 10;
        powersOfEight *= 8;
    }
    return decVal;
}

void inet::physicallayer::ConvolutionalCoder::parseMatrix ( const char *  strMatrix, std::vector< std::vector< int > > &  matrix  ) const

protected

Referenced by ConvolutionalCoder().

{
    cStringTokenizer tokenizer(strMatrix, ";");
    while (tokenizer.hasMoreTokens()) {
        std::vector<int> row;
        parseVector(tokenizer.nextToken(), row);
        matrix.push_back(row);
    }
}

void inet::physicallayer::ConvolutionalCoder::parseVector ( const char *  strVector, std::vector< int > &  vector  ) const

protected

Referenced by ConvolutionalCoder(), and parseMatrix().

{
    cStringTokenizer tokenizer(strVector);
    while (tokenizer.hasMoreTokens())
        vector.push_back(atoi(tokenizer.nextToken()));
}

void inet::physicallayer::ConvolutionalCoder::printOutputs ( ) const

protected

{
    std::cout << "Outputs" << endl;
    for (int i = 0; i != numberOfStates; i++) {
        std::cout << outputSymbols[i][0].reverseToDecimal();
        for (int j = 1; j != numberOfInputSymbols; j++)
            std::cout << " " << outputSymbols[i][j].reverseToDecimal();
        std::cout << endl;
    }
    std::cout << "End Outputs" << endl;
}

void inet::physicallayer::ConvolutionalCoder::printStateTransitions ( ) const

protected

{
    std::cout << "State transitions" << endl;
    for (int i = 0; i != numberOfStates; i++) {
        std::cout << stateTransitions[i][0];
        for (int j = 1; j != numberOfInputSymbols; j++)
            std::cout << " " << stateTransitions[i][j];
        std::cout << endl;
    }
    std::cout << "End State transitions" << endl;
}

std::ostream & inet::physicallayer::ConvolutionalCoder::printToStream ( std::ostream &  stream, int  level  ) const

overridevirtual

Prints this object to the provided output stream.

Function calls to operator<< with pointers or references either const or not are all forwarded to this function.

Reimplemented from inet::physicallayer::IPrintableObject.

Referenced by inet::physicallayer::ConvolutionalCoderModule::printToStream().

{
    stream << "ConvolutionalCoder";
    if (level <= PRINT_LEVEL_TRACE)
        stream << ", convolutionalCode = " << printObjectToString(convolutionalCode, level + 1);
    return stream;
}

void inet::physicallayer::ConvolutionalCoder::printTransferFunctionMatrix ( ) const

protected

{
    std::cout << "Transfer function matrix" << endl;
    for (auto & elem : transferFunctionMatrix) {
        std::cout << elem.at(0);
        for (unsigned int j = 1; j < elem.size(); j++)
            std::cout << "," << elem.at(j);
        std::cout << endl;
    }
}

BitVector inet::physicallayer::ConvolutionalCoder::puncturing ( const BitVector &  informationBits ) const

protected

Referenced by encode().

{
    BitVector puncturedInformationBits;
    BitVector isPunctured = getPuncturedIndices(informationBits.getSize());
    for (unsigned int i = 0; i < informationBits.getSize(); i++)
        if (!isPunctured.getBit(i))
            puncturedInformationBits.appendBit(informationBits.getBit(i));
    return puncturedInformationBits;
}

void inet::physicallayer::ConvolutionalCoder::setTransferFunctionMatrix ( std::vector< std::vector< int > > &  transferFMatrix )

protected

Referenced by ConvolutionalCoder().

{
    for (unsigned int i = 0; i < transferFMatrix.size(); i++) {
        const std::vector<int>& row = transferFMatrix.at(i);
        std::vector<ShortBitVector> bitRow;
        for (auto& elem : row) {
            ShortBitVector bin = octalToBinary(elem, constraintLengths.at(i));
            ShortBitVector reverseBin;
            for (int k = bin.getSize() - 1; k >= 0; k--)
                reverseBin.appendBit(bin.getBit(k));
            bitRow.push_back(reverseBin);
        }
        transferFunctionMatrix.push_back(bitRow);
    }
}

std::pair< BitVector, bool > inet::physicallayer::ConvolutionalCoder::traversePath ( const TrellisGraphNode &  bestNode, TrellisGraphNode **  bestPaths, bool  isTruncatedMode  ) const

protected

Referenced by decode().

{
    if (!isTruncatedMode && bestNode.symbol == -1)
        return std::pair<BitVector, bool>(BitVector(), false);
    TrellisGraphNode path = bestNode;
    BitVector reverseDecodedBits;
    int depth = bestNode.depth;
    while (depth--) {
        const ShortBitVector& inputSymbol = decimalToInputSymbol[path.symbol];
        for (int i = inputSymbol.getSize() - 1; i >= 0; i--)
            reverseDecodedBits.appendBit(inputSymbol.getBit(i));
        path = trellisGraph[path.prevState][depth];
    }
    BitVector decodedBits;
    for (int i = reverseDecodedBits.getSize() - 1; i >= 0; i--)
        decodedBits.appendBit(reverseDecodedBits.getBit(i));
    return std::pair<BitVector, bool>(decodedBits, true);
}

void inet::physicallayer::ConvolutionalCoder::updateTrellisGraph ( TrellisGraphNode **  trellisGraph, unsigned int  time, const ShortBitVector &  outputSymbol, const ShortBitVector &  excludedFromHammingDistance  ) const

protected

Referenced by decode().

{
    int tieBreakingCounter = 0;
    for (int prevState = 0; prevState != numberOfStates; prevState++) {
        const TrellisGraphNode& node = trellisGraph[prevState][time];
        for (int j = 0; j != numberOfOutputSymbols && node.state != -1; j++) {
            int feasibleDecodedSymbol = inputSymbols[prevState][j];
            if (feasibleDecodedSymbol != -1) {
                const ShortBitVector& otherOutputSymbol = decimalToOutputSymbol[j];
                int hammingDistance = computeHammingDistance(outputSymbol, excludedFromHammingDistance, otherOutputSymbol);
                int newState = stateTransitions[prevState][feasibleDecodedSymbol];
                int cumulativeHammingDistance = hammingDistance;
                if (node.comulativeHammingDistance != INT32_MAX)
                    cumulativeHammingDistance += node.comulativeHammingDistance;
                TrellisGraphNode& best = trellisGraph[newState][time + 1];
                bool replace = false;
                if (cumulativeHammingDistance == best.comulativeHammingDistance) {
                    tieBreakingCounter++;
                    if (RNGCONTEXT dblrand() < 1.0 / tieBreakingCounter)
                        replace = true;
                }
                else if (cumulativeHammingDistance < best.comulativeHammingDistance) {
                    tieBreakingCounter = 0;
                    replace = true;
                }
                if (replace) {
                    best.state = newState;
                    best.prevState = prevState;
                    best.depth = node.depth + 1;
                    best.comulativeHammingDistance = cumulativeHammingDistance;
                    if (hammingDistance > 0)
                        best.numberOfErrors = node.numberOfErrors + 1;
                    else
                        best.numberOfErrors = node.numberOfErrors;
                    best.symbol = feasibleDecodedSymbol;
                }
            }
        }
    }
}

Member Data Documentation

unsigned int inet::physicallayer::ConvolutionalCoder::codeRateParamaterK

protected

Referenced by computeNumberOfInputAndOutputSymbols(), computeOutputAndInputSymbols(), computeStateTransitions(), ConvolutionalCoder(), decode(), depuncturing(), encode(), giveNextOutputSymbol(), and isCompletelyDecoded().

unsigned int inet::physicallayer::ConvolutionalCoder::codeRateParamaterN

protected

Referenced by computeDecimalToOutputSymbolVector(), computeNumberOfInputAndOutputSymbols(), ConvolutionalCoder(), decode(), depuncturing(), getPuncturedIndices(), giveNextOutputSymbol(), inputSymbolToOutputSymbol(), and isCompletelyDecoded().

unsigned int inet::physicallayer::ConvolutionalCoder::codeRatePuncturingK

protected

Referenced by ConvolutionalCoder(), and depuncturing().

unsigned int inet::physicallayer::ConvolutionalCoder::codeRatePuncturingN

protected

Referenced by ConvolutionalCoder(), and depuncturing().

std::vector<int> inet::physicallayer::ConvolutionalCoder::constraintLengths

protected

Referenced by computeMemorySizes(), ConvolutionalCoder(), and setTransferFunctionMatrix().

const ConvolutionalCode* inet::physicallayer::ConvolutionalCoder::convolutionalCode

protected

Referenced by printToStream().

ShortBitVector* inet::physicallayer::ConvolutionalCoder::decimalToInputSymbol

protected

Referenced by computeOutputAndInputSymbols(), memoryAllocations(), traversePath(), and ~ConvolutionalCoder().

ShortBitVector* inet::physicallayer::ConvolutionalCoder::decimalToOutputSymbol

protected

Referenced by computeDecimalToOutputSymbolVector(), memoryAllocations(), updateTrellisGraph(), and ~ConvolutionalCoder().

unsigned char*** inet::physicallayer::ConvolutionalCoder::hammingDistanceLookupTable

protected

Referenced by computeHammingDistanceLookupTable(), memoryAllocations(), and ~ConvolutionalCoder().

int** inet::physicallayer::ConvolutionalCoder::inputSymbols

protected

Referenced by computeOutputAndInputSymbols(), memoryAllocations(), updateTrellisGraph(), and ~ConvolutionalCoder().

std::vector<int> inet::physicallayer::ConvolutionalCoder::memorySizes

protected

Referenced by computeMemorySizes(), computeMemorySizeSum(), computeStateTransitions(), and inputSymbolToOutputSymbol().

int inet::physicallayer::ConvolutionalCoder::memorySizeSum

protected

Referenced by computeMemorySizeSum(), computeNumberOfStates(), computeOutputAndInputSymbols(), and computeStateTransitions().

const char* inet::physicallayer::ConvolutionalCoder::mode

protected

Referenced by ConvolutionalCoder(), and decode().

int inet::physicallayer::ConvolutionalCoder::numberOfInputSymbols

protected

Referenced by computeNumberOfInputAndOutputSymbols(), computeOutputAndInputSymbols(), computeStateTransitions(), memoryAllocations(), printOutputs(), and printStateTransitions().

int inet::physicallayer::ConvolutionalCoder::numberOfOutputSymbols

protected

Referenced by computeDecimalToOutputSymbolVector(), computeHammingDistanceLookupTable(), computeNumberOfInputAndOutputSymbols(), memoryAllocations(), updateTrellisGraph(), and ~ConvolutionalCoder().

int inet::physicallayer::ConvolutionalCoder::numberOfStates

protected

Referenced by computeNumberOfStates(), computeOutputAndInputSymbols(), computeStateTransitions(), decode(), memoryAllocations(), printOutputs(), printStateTransitions(), updateTrellisGraph(), and ~ConvolutionalCoder().

ShortBitVector** inet::physicallayer::ConvolutionalCoder::outputSymbols

protected

Referenced by computeOutputAndInputSymbols(), encode(), memoryAllocations(), printOutputs(), and ~ConvolutionalCoder().

std::vector<ShortBitVector> inet::physicallayer::ConvolutionalCoder::puncturingMatrix

protected

Referenced by ConvolutionalCoder(), and getPuncturedIndices().

int** inet::physicallayer::ConvolutionalCoder::stateTransitions

protected

Referenced by computeStateTransitions(), encode(), memoryAllocations(), printStateTransitions(), updateTrellisGraph(), and ~ConvolutionalCoder().

ShortBitVectorMatrix inet::physicallayer::ConvolutionalCoder::transferFunctionMatrix

protected

Referenced by inputSymbolToOutputSymbol(), printTransferFunctionMatrix(), and setTransferFunctionMatrix().

std::vector<std::vector<TrellisGraphNode> > inet::physicallayer::ConvolutionalCoder::trellisGraph

protected

Referenced by decode().

---

The documentation for this class was generated from the following files:

• ConvolutionalCoder.h
• ConvolutionalCoder.cc