miscellaneous.cpp

这是校验位打孔重传的源程序

#include "parameter_sets.h"

///////////////////////////////////////////////////////////////////////////////
// Miscellaneous Functions
///////////////////////////////////////////////////////////////////////////////

const double sqrt2norm[2] = {3.16227766016838, 6.48074069840786};

const double const16QAM[2][2][2] = {
// MSB = 0
	1.0/3.16227766016838, 3.0/3.16227766016838,
// MSB = 1
	-1.0/3.16227766016838, -3.0/3.16227766016838,
// LSB = 0
	-1.0/3.16227766016838, 1.0/3.16227766016838,
// LSB = 1
	-3.0/3.16227766016838, 3.0/3.16227766016838
};

const double const64QAM[3][2][4] = {
// MSB = 0
	1.0/6.48074069840786, 3.0/6.48074069840786, 5.0/6.48074069840786, 7.0/6.48074069840786, 
// MSB = 1
	-1.0/6.48074069840786, -3.0/6.48074069840786, -5.0/6.48074069840786, -7.0/6.48074069840786,
// CSB = 0
	-3.0/6.48074069840786, -1.0/6.48074069840786, 1.0/6.48074069840786, 3.0/6.48074069840786,
// CSB = 1
	-7.0/6.48074069840786, -5.0/6.48074069840786, 5.0/6.48074069840786, 7.0/6.48074069840786,
// LSB = 0
	-5.0/6.48074069840786, -3.0/6.48074069840786, 3.0/6.48074069840786, 5.0/6.48074069840786,
// LSB = 1
	-7.0/6.48074069840786, -1.0/6.48074069840786, 1.0/6.48074069840786, 7.0/6.48074069840786
};

const double MAX = 10000.0;

const int PuncPos[15] = {17, 19, 21, 23, 25, 27, 29, 31, 18, 24, 22, 28, 30, 20, 26};

double logcothsemi(double x) {
	return -1*log(tanh(x/2));
}

int MaxLogDeMap(int start, int length, double symbol, double * llr) {

	int i, j, k;
	double temp, mindis[2];

	if (length == 2) {
		// Demap the inphase or quadrature part of 16QAM
		for (i=0; i<2; i++) {
			// each bit
			mindis[0] = MAX;
			mindis[1] = MAX;
			for (j=0; j<2; j++) {
				// 0 or 1
				for (k=0; k<2; k++) {
					// find the minimum distance
					temp = pow((symbol-const16QAM[i][j][k]), 2);
					if (temp < mindis[j])
						mindis[j] = temp;
				}
			}
			*(llr+start+i) = mindis[1]-mindis[0];
		}
	} else if (length == 3) {
		// Demap the inphase or quadrature part of 64QAM
		for (i=0; i<3; i++) {
			// each bit
			mindis[0] = MAX;
			mindis[1] = MAX;
			for (j=0; j<2; j++) {
				// 0 or 1
				for (k=0; k<4; k++) {
					// find the minimum distance
					temp = pow((symbol-const64QAM[i][j][k]), 2);
					if (temp < mindis[j])
						mindis[j] = temp;
				}
			}
			*(llr+start+i) = mindis[1]-mindis[0];
		}
	} else {
		// Unsupported modulation types
		return 1;
	}
	return 0;
}

int CalcZfactorF(int K, int N)		//计算z
{
	
	int mb = 16;
	int kb = 16;
	double r = ((double) K)/N;
	int z;

	if (r <= 0.5) 
	{
		// lower rate
		z = ((N-K)%mb) ? ((N-K)/mb+1) : ((N-K)/mb);
	}
	else 
	{
		// higher rate
		z = (K%kb) ? (K/kb+1) : (K/kb);
	}

	return z;
}

int ResumeBitsF(struct BasicParaS * ctrl, double * input, double * output) {

	int diff_sys = (ctrl->numInBits-ctrl->codeK);
	int diff_par = ctrl->numChk-ctrl->codeM;
	int i, j, k, m;

	if (ctrl->typeDecode == 0) { // SPA
		for (i=0; i<diff_sys; i++) {
			*(output+i) = 0; // the punctured systematic bits were all zeros
		}
		for (i=0; i<ctrl->codeK; i++) {
			*(output+diff_sys+i) = *(input+i);
		}
	} else { // LSPA and SMA
		for (i=0; i<diff_sys; i++) {
			*(output+i) = 10000.0; // the punctured systematic bits were all zeros
		}
		for (i=0; i<ctrl->codeK; i++) {
			*(output+diff_sys+i) = *(input+i);
		}			
	}

	if (ctrl->codeK <= ctrl->codeM) 
	{ // the code rate is below 1/2
		for (i=0; i<ctrl->codeM; i++) 
		{
			*(output+ctrl->numInBits+i) = *(input+ctrl->codeK+i);
		}
		// truncated bits were resumed
		if (ctrl->typeDecode == 0) { // SPA
			for (i=0; i<diff_par; i++) 
			{
				*(output+ctrl->numInBits+ctrl->codeM+i) = 0.5; // we don't know truncated bits
			}
		} else 
		{ // LSPA and SMA
			for (i=0; i<diff_par; i++) {
				*(output+ctrl->numInBits+ctrl->codeM+i) = 0; // we don't know truncated bits
			} 
		}
	} else 
	{ // the code rate is above 1/2
		k = diff_par/ctrl->zfactor;
		m = diff_par%ctrl->zfactor;
		// set all the parity as -1
		for (i=0; i<ctrl->numChk; i++) 
		{
			*(output+ctrl->numInBits+i) = -1;
		}
		// label the bits should be punctured
		if (ctrl->typeDecode == 0) 
		{ // SPA
			for (i=0; i<k; i++) 
			{
				for (j=0; j<ctrl->zfactor; j++) 
				{
					*(output+PuncPos[i]*ctrl->zfactor+j) = 0.5;
				}
			}
			for (i=0; i<m; i++) 
			{
				*(output+PuncPos[k]*ctrl->zfactor+i) = 0.5;
			}
		} else 
		{ // LSPA and MSA
			for (i=0; i<k; i++) 
			{
				for (j=0; j<ctrl->zfactor; j++) 
				{
				*(output+PuncPos[i]*ctrl->zfactor+j) = 0;
				}
			}
			for (i=0; i<m; i++) 
			{
				*(output+PuncPos[k]*ctrl->zfactor+i) = 0;
			}
		}
		// set the living parity bits
		j = 0;
		for (i=0; i<ctrl->numChk; i++) 
		{
			if ((*(output+ctrl->numInBits+i)) == -1)
			{ // only the unlabeled bits would be covered
				*(output+ctrl->numInBits+i) = *(input+ctrl->codeK+j);
				j++;
			}
		}
	}
	
	return 0;
}