frank.cpp

使用Visual C++生成Frank,cubic,chu序列

#include <math.h>
#include <complex>
using namespace std;

#ifndef  PI
#define  PI 3.1415926535897932
#define PPII   3.14159
#endif 
/******************************************************************************
   Function: int gcd(int count1,int count2);

   Purpose:
        Resolve the great common division of two positive integers
   
   Paramters:
        count1:    the first number
        count2:    the second number

   Function returns:
        the great common division of two positive integers
******************************************************************************/	
int gcd(int a,int b)    
{
	int quotient,remainder,c;

	if (a<b)
	{
		c=a;
		a=b;
		b=c;
	}
	remainder=1;
	while (remainder!=0)
	{
		quotient=a/b;
		remainder=a%b;
		a=b;
		b=remainder;
	}
	
	return a;
}
/******************************************************************************
   Function: int coprime(int count1,int a[])

   Purpose: to resolve the integers that coprime to the appointed integer 
            and lower than the appointed integer
                                   
   Paramters:
        count1:    the appointed integer
        count2:    the array to store the resolved integers

   Function returns:
        the number that coprime to m between 1~(m-1)
******************************************************************************/	
int coprime(int m,int a[])    
{
	int i,sum;
	sum=0;
	for (i=1;i<m;i++)
		if (gcd(m,i)==1)
		{
			a[sum]=i;
			sum++;
		}
	return sum;
}
void Frank(int q, int sequence[])
{
    int i, j, r, l, m, n1, length; 
	int *a = new int[q]; 
	n1 = coprime(q, a); 
	
	length = q*q; 
	for (i = 0; i < n1; i++)
	{
		r = a[i]; 
		for (j = 0; j < length; j++)
		{
			l = j/q; 
			m = j%q; 
			sequence[i*length+j] = r*l*m%q; 
		}
	}
	delete []a; 
}

//void Chu(int length,int sequence[])
//{
//	int i,j,m,r;
//	int *a=new int[length];
//	m=coprime(length,a);
//
//	if (length%2==1)
//		for (i=0;i<m;i++)
//		{
//			r=a[i];
//			for (j=0;j<length;j++)
//				sequence[i*length+j]=(r*j*(j+1)/2)%length; 
//		}
//	else		
//		for (i=0;i<m;i++)
//		{
//			r=a[i];
//			for (j=0;j<length;j++)
//				sequence[i*length+j]=(r*j*j)%(2*length);   
//		}    
//}
//
//
//
double PeriodAutoCorrelation(int sequence[],int length,int t)
{
   int i;
   double x;
   x=0;
   for (i=0;i<length;i++)
   {     
     x=x+sequence[i]*sequence[(i+t)%length];
   }
   x=x/length;
   return x;
}

double AperiodAutoCorrelation(int sequence[],int length,int t)
{
   int i;
   double x;
   x=0;
   for (i=0;i<length-t;i++)
   {     
     x=x+sequence[i]*sequence[i+t];
   }
   x=x/length;
   return x;
}

complex<double> PeriodAutoCorrelation(complex<double> sequence[],int length,int t)
{
   int i;
   complex<double> x,length1;
   
   x=complex<double>(0.0,0.0);
   for (i=0;i<length;i++)
   {     
     x=x+sequence[i]*conj(sequence[(i+t)%length]);
   }

   length1=complex<double>(length,0);
   x=x/length1;
   return x;
}

complex<double> AperiodAutoCorrelation(complex<double> sequence[],int length,int t)
{
   int i;
   complex<double> x,length1;
   
   x=complex<double>(0.0,0.0);
   for (i=0;i<length-t;i++)
   {     
       x=x+sequence[i]*conj(sequence[i+t]);
   }

   length1=complex<double>(length,0);
   x=x/length1;
   return x;
}

double distance(complex<double> x,complex<double> y)
{
	double a,b,c;
	a=x.real()-y.real();
	b=x.imag()-y.imag();
	c=sqrt(a*a+b*b);
	return c;
}

complex<double> map(int x)
{
	complex<double> y;

	if (x==0)   y=complex<double> (0.0,0.0);
	if (x==1)   y=complex<double> (1.0,0.0);
	if ((x==2)||(x==3))   y=complex<double> (polar(1.0,2*PI*(x-1)/3));

	return y;   
}

int InverseMap(complex<double> c)
{
	int x;

	if (c==complex<double> (0.0,0.0))   x=0;
	if (c==complex<double> (1.0,0.0))   x=1;
	if (c==complex<double> (polar(1.0,2*PI/3)))   x=2;
    if (c==complex<double> (polar(1.0,4*PI/3)))   x=3;

	return x;
}

int convert(int a)
{
	int b;
	switch (a)
	{
	    case 5: b=0; 
			break;
		case 7: b=1;
			break;
		case 11: b=2;
			break;
		case 13: b=3;
			break;
		case 17: b=4;
			break;
		case 19: b=5;
			break;
		case 23: b=6;
			break;
		case 29: b=7; 
			break;
		case 31: b=8;
			break;
		default : b=0;
	}
	return b;
}

//float* CompACF(int CodeNumber, float *m_FloatValue_, int m_SeqLength, int m_SeqNumber, float *CompACF_)
//{
//	int a,b,w;
//	float *midACF_=new float[2*m_SeqNumber-1];
//	for(a=0;a<m_SeqNumber;a++){
//		for(w=0;w<2*m_SeqNumber-1;w++)
//			midACF_[w]=0;
//		midACF_ = SXDACF(CodeNumber*m_SeqNumber+a,m_FloatValue_, m_SeqNumber,m_SeqNumber, midACF_);
//		for(b=0;b<2*m_SeqNumber-1;b++)
//			CompACF_[b]+=midACF_[b];
//	}
//	delete midACF_;
//	return CompACF_;
//}
//
//float* SXDACF(int CodeNumber, float *m_FloatValue_, int m_SeqLength, int m_SeqNumber, float *SXDACF_)
//{
//	for(int c=0;c<m_SeqLength;c++)
//			for(int d=m_SeqLength*CodeNumber;d<(m_SeqLength*(CodeNumber+1));d++){
//				if(m_FloatValue_[d]==m_FloatValue_[(d+c)%m_SeqLength+CodeNumber*m_SeqLength])
//					SXDACF_[c]++;
//				else 
//					SXDACF_[c]--;
//				}
//	return SXDACF_;
//}
void ACF(long PACF_Code,long lLength,long lNumber,int sequence[],long SeqPhase,float fPacf[] )
{
	int i,j;
	//float *fPacf;
	//fPacf=new float[lLength];
	for(i=0;i<lLength;i++)
		fPacf[i]=0;

	float *fTempSeqArray=new float[lLength*lNumber];
	long lValue;
	for (i=0;i<lLength*lNumber;i++)
	{
	lValue = (long)sequence[i];
	fTempSeqArray[i] = lValue;
	}


	float A_Real,A_Image,B_Real,B_Image;
	float * SeqACFReal_;
	float * SeqACFImage_;
	SeqACFReal_=new float[lLength];
	SeqACFImage_=new float[lLength];
	for(i=0;i<lLength;i++){
	    SeqACFReal_[i]=0;
		SeqACFImage_[i]=0;
	}
	for(i=0;i<lLength;i++){
		for(j=lLength*(PACF_Code-1);j<lLength*PACF_Code;j++){
			A_Real=cos(2*PPII*fTempSeqArray[j]/SeqPhase);
			A_Image=sin(2*PPII*fTempSeqArray[j]/SeqPhase);
			B_Real=cos(2*PPII*fTempSeqArray[(j+i)%lLength+lLength*(PACF_Code-1)]/SeqPhase);
			B_Image=sin(2*PPII*fTempSeqArray[(j+i)%lLength+lLength*(PACF_Code-1)]/SeqPhase);
			SeqACFReal_[i]+=(A_Real*B_Real+A_Image*B_Image);
			SeqACFImage_[i]+=(A_Image*B_Real-A_Real*B_Image);	
		}
		fPacf[i]=SeqACFReal_[i]*SeqACFReal_[i]+SeqACFImage_[i]*SeqACFImage_[i];
		fPacf[i]=sqrt(fPacf[i]);
	}
	delete SeqACFReal_;
	delete SeqACFImage_;
	//return fPacf;
}

void CCF(long PCCF_Code1,long PCCF_Code2,long lLength,long lNumber,int sequence[],long SeqPhase,float fPccf[] )
{
	int i,j,k;
	//float *fPacf;
	//fPacf=new float[lLength];
	for(i=0;i<lLength;i++)
		fPccf[i]=0;

	float *fTempSeqArray=new float[lLength*lNumber];
	long lValue;
	for (i=0;i<lLength*lNumber;i++)
	{
	lValue = (long)sequence[i];
	fTempSeqArray[i] = lValue;
	}


	float A_Real,A_Image,B_Real,B_Image;
	float * SeqCCFReal_;
	float * SeqCCFImage_;
	SeqCCFReal_=new float[lLength];
	SeqCCFImage_=new float[lLength];
	for(i=0;i<lLength;i++){
		SeqCCFReal_[i]=0;
		SeqCCFImage_[i]=0;
	}
	for(i=0;i<lLength;i++){
		for(j=lLength*(PCCF_Code1-1),k=lLength*(PCCF_Code2-1);j<lLength*PCCF_Code1;j++,k++){
			A_Real=cos(2*PPII*fTempSeqArray[j]/SeqPhase);
			A_Image=sin(2*PPII*fTempSeqArray[j]/SeqPhase);
			B_Real=cos(2*PPII*fTempSeqArray[(k+i)%lLength+lLength*(PCCF_Code2-1)]/SeqPhase);
			B_Image=sin(2*PPII*fTempSeqArray[(k+i)%lLength+lLength*(PCCF_Code2-1)]/SeqPhase);
			SeqCCFReal_[i]+=(A_Real*B_Real+A_Image*B_Image);
			SeqCCFImage_[i]+=(A_Image*B_Real-A_Real*B_Image);
		}
		fPccf[i]=SeqCCFReal_[i]*SeqCCFReal_[i]+SeqCCFImage_[i]*SeqCCFImage_[i];
		fPccf[i]=sqrt(fPccf[i]);
	}
	delete SeqCCFReal_;
	delete SeqCCFImage_;
	//return fPacf;
}