encclass.cpp

自编常用无线通信编码器程序

	// RSC-2
	// No tail bits added
	// rsc(..) return unuseful tail bits
	// the input para."length" is the length of rsc2_in viz. length+lreg
	// index = 0;
	// syscode = 0;
	tail2 = rsc(rsc2_in, xp2, in_s2, out_s, L, gen, n0, k0, 0, 0);

	// Multiplex
    // length of code = length(data)*(2+puncture)
	mux(rsc1_in, xp1, xp2, code, L, puncture);

	//free space
	delete []out_s;
    delete []rsc1_in;
	delete []rsc2_in;
	delete []xp1;
	delete []xp2;
}

/*=================================================================*
Function: Mux
===================================================================*/
void encoder::mux(int *data, int *p1, int *p2, int *code, int length,int puncture)
{
	int i;
	int r=puncture+2;

	if (puncture == 0)
	{
		for (i=0; i<length; i++)
		{
			code[i*r] = data[i];
			if (i%2 == 0)
			{
				code[r*i+1] = p1[i];
			}
			else
			{
				code[r*i+1] = p2[i];
			}
		}
	}
	else if(puncture == 1)
	{
		for (i=0; i<length; i++)
		{
			code[r*i] = data[i];
			code[r*i+1] = p1[i];
			code[r*i+2] = p2[i];
		}
	}
}

/*============================================================*
Function: interleaver_random
  Generate random interleaver
Input:
  length - interleaver length
Output:
  select - pointer of interleaver
Return:
  select
==============================================================*/
int *encoder::interleaver_random(int length)
{
	int i;
	int Lnum=length;
	int sel,temp;
	
	int *select = new int[length];
	NULLDetection(select);

	int *num = new int[length];     //Store number sequence
	NULLDetection(num);             // from 0 ~ N-1
	for (i=0; i<length; i++)
	{
		num[i] = i;
	}
	
	// Start
	//srand((unsigned)time(NULL));
	//--------Generate  sel number----------//
	for (i=0; i<length; i++)
	{
		// Step 1: Generate random index
	    sel = rand()%Lnum;
	
		//num[sel]即该序号在原序列中的位置I(i)	
		select[i] = num[sel];

	    //Step 2: Adjust num sequence
	    if (sel==Lnum-1)
		{
		    Lnum--;
		}
	    else
		{
			// put the num[sel] to the tail of num sequence
		    //viz. to swap the num[sel] and num[Lnum-1]
		    temp = num[sel];
		    num[sel] = num[Lnum-1];
		    num[Lnum-1] = temp;

		    Lnum--;
		}
	}

	//free space
	delete []num;

	return select;
}

/*============================================================*
Function: interleaver_Sdis
  Generate S-distance random interleaver
Input:
  S - distance S
  length - interleaver length
Output:
  select - pointer of interleaver
Return:
  select
==============================================================*/
int *encoder::interleaver_Sdis(int S, int length)
{
	int Smax;
	//检查输入的S是否满足条件
	Smax=(int)(sqrt(length/2.0))-1;	//caculate S
	if (S>=Smax) //若超过最大可收敛S，则结束函数
	{
		cout<<"S is too large! Select a proper one, please."<<endl;
		printf("length = 128,  Smax = 7\n");
		printf("length = 256,  Smax = 10\n");
		printf("length = 512,  Smax = 15\n");
		printf("length = 1024, Smax = 21\n");
		return 0;
	}
	
	int SelNum,RejNum,SeledSeq;
	int i,j,n;
	char test,SJudge;

	int *select = new int[length];
	NULLDetection(select);

	int *SelSeq = new int[length];
	NULLDetection(SelSeq);

	int *RestSeq = new int[length];
    NULLDetection(RestSeq);

	test=1;	
	while(test)
	{
		i=0;	                //需要计算的位置置0
		SelNum = length;		//计算可选数据个数
		RejNum = 0;	            //被拒绝的数据个数
		for (j=0; j<SelNum; j++)
		{
			SelSeq[j] = j;	//可选数据
			RestSeq[j] = j;	//剩余数据
		}
		
		while( (i < length) && (RejNum < SelNum) )
		{
			//从数字数组中随机选择一个数
			SelNum = length-i;					//计算可选数据个数
			
			SeledSeq = rand()%(SelNum-RejNum);	//获得可选数据的位置
			
			select[i] = RestSeq[SeledSeq];		//获得交织结果
			
			for(n=0; n<SelNum-SeledSeq; n++)	//剩余数据移位
			{		
				RestSeq[SeledSeq+n] = RestSeq[SeledSeq+n+1];
			}
	
			//判断是否满足S
			SJudge=1;	//SJudge标志置1
			for(j=1;j<S;j++)
			{
				if(i-j>0)
				{	
					if(abs(select[i]-select[i-j])<S)
					{	
						SJudge=0;      //不满足S，SJudge标志置0
						break;
					}
				}
			}

			//判断是否拒绝该数
			if (SJudge)		//接收
			{	
				n=0;
				for (j=0; j<SelNum; j++)
				{
					if(select[i]!=SelSeq[j])
					{
						SelSeq[n++]=SelSeq[j];
					}
				}

				i += 1;
				RejNum = 0;
				
				for (j=0; j<(SelNum-1); j++)
				{
					RestSeq[j] = SelSeq[j];
				}
			}
			else                   //拒绝
			{	
				RejNum +=1;
			}
		}
			
		if(i==length)
		{
			test=0;
		}
	}

	//生成反交织表
	/*for(i=0;i<length;i++)
	{
		Dinterleave[interleave[i]]=i;
	}*/

	//free space
	delete []SelSeq;
	delete []RestSeq;

	return select;
}

/*============================================================*
Function: interleaver_kmod
  Generate k mod random interleaver
Input:
  k - mod k
  length - interleaver length
Output:
  select - pointer of interleaver
Return:
  select
==============================================================*/
int *encoder::interleaver_kmod(int k, int length)
{
	int SelNum,RejNum,SeledSeq;
	int i,j,n;
	char test,kJudge;

	int *select = new int[length];
	NULLDetection(select);

	int *SelSeq = new int[length];
	NULLDetection(SelSeq);

	int *RestSeq = new int[length];
    NULLDetection(RestSeq);
	
	test=1;	
	while(test)
	{
		i=0;	                //需要计算的位置置0
		SelNum = length;		//计算可选数据个数
		RejNum = 0;	            //被拒绝的数据个数
		for (j=0; j<SelNum; j++)
		{
			SelSeq[j] = j;	//可选数据
			RestSeq[j] = j;	//剩余数据
		}
		
		while( (i < length) && (RejNum < SelNum) )
		{
			//从数字数组中随机选择一个数
			SelNum = length-i;					//计算可选数据个数
			
			SeledSeq = rand()%(SelNum-RejNum);	//获得可选数据的位置
			
			select[i] = RestSeq[SeledSeq];		//获得交织结果
			
			for(n=0; n<SelNum-SeledSeq; n++)	//剩余数据移位
			{		
				RestSeq[SeledSeq+n] = RestSeq[SeledSeq+n+1];
			}


			//判断是否满足模k
			if((i%k)==(select[i]%k))
			{
				kJudge=1;	//满足模k,kJudge标志置1
			}
			else
			{
				kJudge=0;	//不满足模k,kJudge标志置0
			}
			

			//判断是否拒绝该数
			if (kJudge)		//接收
			{	
				n=0;
				for (j=0; j<SelNum; j++)
				{
					if(select[i]!=SelSeq[j])
					{
						SelSeq[n++]=SelSeq[j];
					}
				}

				i += 1;
				RejNum = 0;
				
				for (j=0; j<(SelNum-1); j++)
				{
					RestSeq[j] = SelSeq[j];
				}
			}
			else                   //拒绝
			{	
				RejNum +=1;
			}
		}
			
		if(i==length)
		{
			test=0;
		}
	}

	//生成反交织表
	/*for(i=0;i<length;i++)
	{
		Dinterleave[interleave[i]]=i;
	}*/

	//free space
	delete []SelSeq;
	delete []RestSeq;

	return select;
}

/*============================================================*
Function: interleaver_Sdis
  Generate S-distance k-mod random interleaver
Input:
  S - distance S
  k - mod k
  length - interleaver length
Output:
  select - pointer of interleaver
Return:
  select
==============================================================*/
int *encoder::interleaver_Sk(int S, int k, int length)
{
	int Smax;
	//检查输入的S是否满足条件
	Smax=(int)(sqrt(length/2.0))-1;	//caculate S
	if (S>=Smax) //若超过最大可收敛S，则结束函数
	{
		cout<<"S is too large! Select a proper one, please."<<endl;
		printf("length = 128,  Smax = 7\n");
		printf("length = 256,  Smax = 10\n");
		printf("length = 512,  Smax = 15\n");
		printf("length = 1024, Smax = 21\n");
		return 0;
	}

	int SelNum,RejNum,SeledSeq;
	int i,j,n;
	char test,SJudge,kJudge;

	int *select = new int[length];
	NULLDetection(select);

	int *SelSeq = new int[length];
	NULLDetection(SelSeq);

	int *RestSeq = new int[length];
    NULLDetection(RestSeq);

	// Generation Start
	test=1;	
	while(test)
	{
		i=0;	                //需要计算的位置置0
		SelNum = length;		//计算可选数据个数
		RejNum = 0;	            //被拒绝的数据个数
		for (j=0; j<SelNum; j++)
		{
			SelSeq[j] = j;	    //可选数据
			RestSeq[j] = j;	    //剩余数据
		}
		
		while( (i < length) && (RejNum < SelNum) )
		{
			//从数字数组中随机选择一个数
			SelNum = length-i;					//计算可选数据个数
			
			SeledSeq = rand()%(SelNum-RejNum);	//获得可选数据的位置
			
			select[i] = RestSeq[SeledSeq];		//获得交织结果
			
			for(n=0; n<SelNum-SeledSeq; n++)	//剩余数据移位
			{		
				RestSeq[SeledSeq+n] = RestSeq[SeledSeq+n+1];
			}
			
			//判断是否满足S
			SJudge=1;	//SJudge标志置1
			for(j=1;j<S;j++)
			{
				if(i-j>0)
				{	
					if(abs(select[i]-select[i-j])<S)
					{	
						SJudge=0;      //不满足S，SJudge标志置0
						break;
					}
				}
			}
			
			//判断是否满足模k
			if((i%k)==(select[i]%k))
			{
				kJudge=1;	//满足模k,kJudge标志置1
			}
			else
			{
				kJudge=0;	//不满足模k,kJudge标志置0
			}

			//判断是否拒绝该数
			if (SJudge&kJudge)		//接收
			{	
				n=0;
				for (j=0; j<SelNum; j++)
				{
					if(select[i]!=SelSeq[j])
					{
						SelSeq[n++]=SelSeq[j];
					}
				}

				i += 1;
				RejNum = 0;
				
				for (j=0; j<(SelNum-1); j++)
				{
					RestSeq[j] = SelSeq[j];
				}
			}
			else                   //拒绝
			{	
				RejNum +=1;
			}
		}
			
		if(i==length)
		{
			test=0;
		}
	}

	//生成反交织表
	/*for(i=0;i<length;i++)
	{
		Dinterleave[interleave[i]]=i;
	}*/

	//free space
	delete []SelSeq;
	delete []RestSeq;

	return select;
}