cc.h

his file contains a summary of what you will find in each of the files that make up your CC applica

/********************************************************
*  CC.h
*　说明：利用文(1)中的C-C算法计算各种混沌时间序列的嵌入
　　　　　维数和最佳延时
*  2004,11.1 zya
*  (1) Kim, HS, Eykholt, R. and Salas, JD, 1999, 
     "Nonlinear Dynamics, Delay Times, and Embedding Windows", 
	 Physica D Nonlinear Phenomena, Physica D127, 48-60
**********************************************************/

#include "math.h"

const int length=3000;  //mat文件中数组的长度

double Cs(double *X,int Xlen, int m, double r, int t)
{
    //int L=ceil(length/t); //数组长度
	int M=Xlen-m+1;
	int cr=0; 
	double Cr;//关联积分概率
	double distance;
	double max=0;
	for (int i=0; i<M-1; i++)
	{
        for (int j=i+1; j<M; j++)
		{
			for (int k=0; k<m; k++)
			{
				distance = fabs(X[i+k]-X[j+k]);
				if (distance>max)
					max = distance;
			}
			if (r>=max)
				cr++;
			max = 0;
		}
	}
	Cr = cr*2.0/(M*(M-1));

	return Cr;

}

double Csm(double *X,int Xlen, int m, double r, int t)
{
	double distance;
	int cr=0;
    double Crm;
	for (int i=0; i<Xlen-1; i++)
	{
		for (int j=i+1; j<Xlen; j++)
		{
			distance = fabs(X[i]-X[j]);
			if (r>=distance)
				cr++;
		}
	}
	Crm = cr*2.0/(Xlen*(Xlen-1));
	Crm = pow(Crm, m);

	return Crm;
}

double S(double **X,int *Xlen, int m, double r, int t)
{
	double reS=0;
	int i;

	for (i=0; i<t; i++)
	{
        reS += Cs(X[i],Xlen[i],m,r,t)-Csm(X[i],Xlen[i],m,r,t);
	}
	reS = reS/t;

	return reS;
}
//求延时的主要函数
double CC(double *X, int m, double r, int t)
{
	//得到t个数组
	double **Y;
	int l;
	int *len = new int[t];
	int supply = length%t;
	//动态创建二维数组
	Y = new double*[t];
	for (l=0; l<t; l++)
	{
		if (l<supply)
			len[l] =  (length-supply)/t+1;
		else
			len[l] = (length-supply)/t;
		Y[l] = new double[len[l]];
	}
	int i=0;
	int j=0;
	int k=0;
    //分配数组
	while (i<length)
	{
	    Y[j][k]=X[i];
		i++;
		j++;

		if (j>=t)
		{
		    j=0;
			k++;
		}
	}

    double cc=S(Y,len,m,r,t);
	//删除数组
	for (l=0; l<t; l++)
	{
		delete [] Y[l];
	}
	delete [] Y;
	delete [] len;
		
	return cc;
}

//
void MaxMin(double **SeqIn, double *SeqOut)
{
	double Max[201];
	double Min[201];
	int i,t;
    
	//初始化最大最小数组
	for (t=0; t<201; t++)
	{
		Max[t] = SeqIn[0][t];
		Min[t] = SeqIn[0][t];
	}
	for (t=0; t<201; t++)
	{
		for (i=1; i<4; i++)
		{
			//找出最大值
			if (Max[t]<SeqIn[i][t])
				Max[t]=SeqIn[i][t];
			//找出最小值
			if (Min[t]>SeqIn[i][t])
				Min[t]=SeqIn[i][t];
		}
		SeqOut[t]=Max[t]-Min[t];
	}
}