uwb同步搜索算法1.cpp

该压缩包中包括常见的超宽带通信的同步比特的搜索算法.

// *************************************************
// 仿真线性搜索，随机搜索，折半搜索，K步搜索四种算法
// *************************************************

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#define MAXRAND   LONG_MAX
#define N 10000	//仿真次数
#define M 12
#define NN 32	// 序列长度

// 归一化同步比特数
double kk[M]={0.05,0.07,0.1,0.14,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9};
// 折半搜索比特位置
int half4[32]={1,17,9,25,5,13,21,29,3,7,11,15,19,23,27,31,2,6,10,14,18,22,26,30,4,8,12,16,20,24,28,32};

void main(void)
{   
	FILE *fp;
    void seedrand(void);	// 产生随机数种子
    int int_random(unsigned upperBound);    
	int i=0,j=0,k=0,l=0,n=0;
    int linearss[M]={0},randss[M]={0},halfss[M]={0};
	int *sequence;
	int location=0;
	int number_ls,number_rs,number_kt,number_hs;
	int sy_num[M]={0};
	
	seedrand();
	
	// 计算同步比特数
	for(i=0;i<M;i++)
	{
		sy_num[i]=(int)(NN*kk[i]);
	}
	
	fp=fopen("UWB-result1.txt","w");
	if(fp==NULL)
	{
		exit(1) ;
	}
	
    printf ("\n结果为：\n");
	printf ("同步比特数 归一化同步比特数   线性搜索   随机搜索   折半搜索  K步搜索\n");	
	for (i=0;i<M;i++)
	{  
		number_ls=0;number_rs=0;number_hs=0;number_kt=0;
		sequence=new int[NN];
		
		for(j=0;j<N;j++) 
		{
			// 初始化			
			for(l=0;l<NN;l++)
			{
				*(sequence+l)=0;
			}
			
			// 同步比特出现的位置
			// 指针sequence中的值（0：不是同步比特；1：同步比特）
			location=int_random(NN);
			if(location<=(NN-sy_num[i]))
			{ 
				for(n=location;n<(location+sy_num[i]);n++)
				{
					*(sequence+n)=1;
				}
			}
			else
			{
				for(n=location;n<NN;n++)
				{
					*(sequence+n)=1;
				}
				for(n=0;n<(sy_num[i]-(NN-location));n++)
				{
					*(sequence+n)=1;  
				}
			}
			
			for(k=0;k<NN;k++)   //线性搜索
			{
				if(*(sequence+k)==0)
				{
					number_ls=number_ls+1;
				}
				else
				{
					number_ls=number_ls+1;
					break;
				}
			}      
			
			//随机搜索
			int tp=0;
			bool flag=false;
			do
			{
				tp=int_random(NN);                
				if(*(sequence+tp)==0)
				{
					number_rs=number_rs+1;
				}
				else 
				{	  
					number_rs=number_rs+1;
					flag=true;
				}     
			}while(flag==false);
			
			
			//K步搜索
			for(k=0;k<NN;k++) 
			{
				if(k%sy_num[i]==0)
				{
					if(*(sequence+k)==0)
					{
						number_kt=number_kt+1;
					}
					else
					{
						number_kt=number_kt+1;
						break; 
					}
				}
			}
			
			//折半搜索			
			for(k=0;k<NN;k++)
			{
				if(*(sequence+half4[k]-1)==0)
				{
					number_hs=number_hs+1;
				}
				else
				{
					number_hs=number_hs+1;
					break;
				}
			}			
		}
		
		int n1=0,n2=0,n3=0,n4=0;
		if(number_ls%N==0)
		{
			n1=number_ls/N;
		}
		else
		{
			n1=number_ls/N+1;
		}
		
		if(number_rs%N==0)
		{
			n2=number_rs/N;
		}
		else
		{
			n2=number_rs/N+1;
		}
		
		if(number_hs%N==0)
		{
			n3=number_hs/N;
		}
		else
		{
			n3=number_hs/N+1;
		}
		
		if(number_kt%N==0)
		{
			n4=number_kt/N;
		}
		else
		{
			n4=number_kt/N+1;
		}		
		
		// 打印程序仿真结果
		printf("%6d %2.2lf %10.6lf %10.6lf %10.6lf %10.6lf\n",sy_num[i],kk[i],n1/(double)NN,n2/(double)NN,n3/(double)NN,n4/(double)NN); 
		fprintf(fp, "%6d %2.2lf %10.6lf %10.6lf %10.6lf %10.6lf\n",sy_num[i],kk[i],n1/(double)NN,n2/(double)NN,n3/(double)NN,n4/(double)NN); 
	}
	
	fclose(fp);
}

void seedrand(void)
{
	// ********************
	// 产生随机数种子
	// ********************
	srand(static_cast<unsigned>(time((time_t *)NULL)));  
}

int int_random(unsigned upperBound) 
{
	// ***************************
	// 产生0~upperBound均匀分布
	// ***************************
	double random_0_1=0.0;
	random_0_1=rand()/(static_cast<double>(RAND_MAX)+1);
	return (int)((upperBound+1)*random_0_1);
}