#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::IPrintableObject
enum	PrintLevel { PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO, PRINT_LEVEL_COMPLETE = INT_MIN }

enum	PrintFlag { PRINT_FLAG_FORMATTED = (1 << 0), PRINT_FLAG_MULTILINE = (1 << 1) }

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, int evFlags=0) const override
	Prints this object to the provided output stream. More...

Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()

virtual std::string	printToString () const

virtual std::string	printToString (int level, int evFlags=0) const

virtual std::string	getInfoStringRepresentation (int evFlags=0) const

virtual std::string	getDetailStringRepresentation (int evFlags=0) const

virtual std::string	getDebugStringRepresentation (int evFlags=0) const

virtual std::string	getTraceStringRepresentation (int evFlags=0) const

virtual std::string	getCompleteStringRepresentation (int evFlags=0) 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

◆ ShortBitVectorMatrix

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

Constructor & Destructor Documentation

◆ ConvolutionalCoder()

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();
 }

◆ ~ConvolutionalCoder()

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

◆ computeDecimalToOutputSymbolVector()

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

protected

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

Referenced by initParameters().

◆ computeHammingDistance()

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

inlineprotected

     {
 #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()];
     }

Referenced by updateTrellisGraph().

◆ computeHammingDistanceLookupTable()

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

protected

 {
     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;
             }
         }
     }
 }

Referenced by initParameters().

◆ computeMemorySizes()

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

protected

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

Referenced by initParameters().

◆ computeMemorySizeSum()

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

protected

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

Referenced by initParameters().

◆ computeNumberOfInputAndOutputSymbols()

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

protected

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

Referenced by initParameters().

◆ computeNumberOfStates()

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

protected

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

Referenced by initParameters().

◆ computeOutputAndInputSymbols()

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

protected

 {
     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;
         }
     }
 }

Referenced by initParameters().

◆ computeStateTransitions()

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

protected

 {
     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();
         }
     }
 }

Referenced by initParameters().

◆ convertToShortBitVectorMatrix()

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

protected

 {
     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);
     }
 }

Referenced by ConvolutionalCoder().

◆ decode()

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

overridevirtual

Implements inet::physicallayer::IFecCoder.

 {
     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;
 }

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

◆ depuncturing()

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

protected

 {
     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;
 }

Referenced by decode().

◆ encode()

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

overridevirtual

Implements inet::physicallayer::IFecCoder.

 {
     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;
 }

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

◆ eXOR()

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

inlineprotected

77 { return alpha != beta; }

Referenced by inputSymbolToOutputSymbol(), and modulo2Adder().

◆ getConstraintLengthVector()

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

inline

130 { return constraintLengths; }

◆ getForwardErrorCorrection()

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

inlineoverridevirtual

Implements inet::physicallayer::IFecCoder.

124 { return convolutionalCode; }

Referenced by inet::physicallayer::ConvolutionalCoderModule::getForwardErrorCorrection(), and inet::physicallayer::ConvolutionalCoderModule::~ConvolutionalCoderModule().

◆ getMemorySizeSum()

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

inline

129 { return memorySizeSum; }

◆ getNumberOfInputSymbols()

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

inline

135 { return numberOfInputSymbols; }

◆ getNumberOfOutputSymbols()

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

inline

134 { return numberOfOutputSymbols; }

◆ getNumberOfStates()

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

inline

133 { return numberOfStates; }

◆ getOutputTable()

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

inline

141 { return (const int **)inputSymbols; }

◆ getPuncturedIndices()

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

protected

 {
     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;
 }

Referenced by depuncturing(), and puncturing().

◆ getPuncturingMatrix()

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

inline

132 { return puncturingMatrix; }

◆ getStateTransitionTable()

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

inline

140 { return (const int **)stateTransitions; }

◆ getTransferFunctionMatrix()

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

inline

131 { return transferFunctionMatrix; }

◆ giveNextOutputSymbol()

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

protected

 {
     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;
 }

Referenced by decode().

◆ initParameters()

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

protected

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

Referenced by ConvolutionalCoder().

◆ inputSymbolToOutputSymbol()

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

protected

 {
     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;
 }

Referenced by computeOutputAndInputSymbols().

◆ isCompletelyDecoded()

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

protected

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

Referenced by giveNextOutputSymbol().

◆ memoryAllocations()

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

protected

 {
     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;
     }
 }

Referenced by initParameters().

◆ modulo2Adder()

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

protected

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

Referenced by inputSymbolToOutputSymbol().

◆ octalToBinary()

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

protected

 {
     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);
 }

Referenced by setTransferFunctionMatrix().

◆ octalToDec()

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

protected

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

Referenced by ConvolutionalCoder().

◆ parseMatrix()

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

protected

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

Referenced by ConvolutionalCoder().

◆ parseVector()

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

protected

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

Referenced by ConvolutionalCoder(), and parseMatrix().

◆ printOutputs()

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;
 }

◆ printStateTransitions()

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;
 }

◆ printToStream()

std::ostream & inet::physicallayer::ConvolutionalCoder::printToStream	(	std::ostream &	stream,
		int	level,
		int	evFlags = `0`
	)		const

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

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

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

◆ printTransferFunctionMatrix()

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;
     }
 }

◆ puncturing()

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

protected

 {
     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;
 }

Referenced by encode().

◆ setTransferFunctionMatrix()

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

protected

 {
     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);
     }
 }

Referenced by ConvolutionalCoder().

◆ traversePath()

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

protected

 {
     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);
 }

Referenced by decode().

◆ updateTrellisGraph()

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

protected

 {
     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;
                 }
             }
         }
     }
 }

Referenced by decode().

Member Data Documentation

◆ codeRateParamaterK

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

protected

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

◆ codeRateParamaterN

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

protected

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

◆ codeRatePuncturingK

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

protected

Referenced by ConvolutionalCoder(), and depuncturing().

◆ codeRatePuncturingN

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

protected

Referenced by ConvolutionalCoder(), and depuncturing().

◆ constraintLengths

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

protected

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

◆ convolutionalCode

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

protected

Referenced by ConvolutionalCoder(), and printToStream().

◆ decimalToInputSymbol

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

protected

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

◆ decimalToOutputSymbol

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

protected

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

◆ hammingDistanceLookupTable

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

protected

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

◆ inputSymbols

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

protected

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

◆ memorySizes

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

protected

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

◆ memorySizeSum

int inet::physicallayer::ConvolutionalCoder::memorySizeSum

protected

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

◆ mode

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

protected

Referenced by ConvolutionalCoder(), and decode().

◆ numberOfInputSymbols

int inet::physicallayer::ConvolutionalCoder::numberOfInputSymbols

protected

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

◆ numberOfOutputSymbols

int inet::physicallayer::ConvolutionalCoder::numberOfOutputSymbols

protected

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

◆ numberOfStates

int inet::physicallayer::ConvolutionalCoder::numberOfStates

protected

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

◆ outputSymbols

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

protected

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

◆ puncturingMatrix

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

protected

Referenced by ConvolutionalCoder(), and getPuncturedIndices().

◆ stateTransitions

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

protected

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

◆ transferFunctionMatrix

ShortBitVectorMatrix inet::physicallayer::ConvolutionalCoder::transferFunctionMatrix

protected

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

◆ trellisGraph

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

protected

Referenced by decode(), traversePath(), and updateTrellisGraph().

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ ShortBitVectorMatrix

Constructor & Destructor Documentation

◆ ConvolutionalCoder()

◆ ~ConvolutionalCoder()

Member Function Documentation

◆ computeDecimalToOutputSymbolVector()

◆ computeHammingDistance()

◆ computeHammingDistanceLookupTable()

◆ computeMemorySizes()

◆ computeMemorySizeSum()

◆ computeNumberOfInputAndOutputSymbols()

◆ computeNumberOfStates()

◆ computeOutputAndInputSymbols()

◆ computeStateTransitions()

◆ convertToShortBitVectorMatrix()

◆ decode()

◆ depuncturing()

◆ encode()

◆ eXOR()

◆ getConstraintLengthVector()

◆ getForwardErrorCorrection()

◆ getMemorySizeSum()

◆ getNumberOfInputSymbols()

◆ getNumberOfOutputSymbols()

◆ getNumberOfStates()

◆ getOutputTable()

◆ getPuncturedIndices()

◆ getPuncturingMatrix()

◆ getStateTransitionTable()

◆ getTransferFunctionMatrix()

◆ giveNextOutputSymbol()

◆ initParameters()

◆ inputSymbolToOutputSymbol()

◆ isCompletelyDecoded()

◆ memoryAllocations()

◆ modulo2Adder()

◆ octalToBinary()

◆ octalToDec()

◆ parseMatrix()

◆ parseVector()

◆ printOutputs()

◆ printStateTransitions()

◆ printToStream()

◆ printTransferFunctionMatrix()

◆ puncturing()

◆ setTransferFunctionMatrix()

◆ traversePath()

◆ updateTrellisGraph()

Member Data Documentation

◆ codeRateParamaterK

◆ codeRateParamaterN

◆ codeRatePuncturingK

◆ codeRatePuncturingN

◆ constraintLengths

◆ convolutionalCode

◆ decimalToInputSymbol

◆ decimalToOutputSymbol

◆ hammingDistanceLookupTable

◆ inputSymbols

◆ memorySizes

◆ memorySizeSum

◆ mode

◆ numberOfInputSymbols

◆ numberOfOutputSymbols

◆ numberOfStates

◆ outputSymbols

◆ puncturingMatrix

◆ stateTransitions

◆ transferFunctionMatrix

◆ trellisGraph