main.cpp

本算法采用LVQ竞争学习网络

#include "head.h"


/*************************************************************
*				训练网络样本输入的设置						 *															 *
**************************************************************/

void teachinginputset(int m,int interval)
{
	data[m].input[0]=loadpointer[m-1][interval];
	//data[m].input[1]=loadpointer[m-2][interval];
	data[m].input[1]=pricepointer[m-1][interval];
	//data[m].input[2]=pricepointer[m-2][interval];
//	data[m].input[2]=loadpointer[m-7][interval];
//	data[m].input[3]=pricepointer[m-7][interval];
	if(interval==0)
	{
		data[m].input[2]=pricepointer[m-1][interval+N-1];
		data[m].input[3]=loadpointer[m-1][interval+N-1];
	//	data[m].input[8]=pricepointer[m-1][interval+N-2];
	//	data[m].input[9]=loadpointer[m-1][interval+N-2];
	}
	else if(interval==1)
	{
		data[m].input[2]=pricepointer[m][interval-1];
		data[m].input[3]=loadpointer[m][interval-1];
	//	data[m].input[8]=pricepointer[m-1][interval+N-2];
	//	data[m].input[9]=loadpointer[m-1][interval+N-2];
	
	
	}
	else if(interval>=2)
	{
		data[m].input[2]=pricepointer[m][interval-1];
		data[m].input[3]=loadpointer[m][interval-1];
	//	data[m].input[8]=pricepointer[m][interval-2];
	//	data[m].input[9]=loadpointer[m][interval-2];
	}
	data[m].input[4]=loadpointer[m][interval];
	data[m].teach=pricepointer[m][interval];

}
				
			
			
		

/*************************************************************
*					测试网络样本输入的设置					  *															 *
**************************************************************/
void testinginputset(int m,int interval)
{
	data[m].input[0]=loadpointer[m-1][interval];
	//data[m].input[1]=loadpointer[m-2][interval];
	data[m].input[1]=pricepointer[m-1][interval];
//	data[m].input[3]=pricepointer[m-2][interval];
//	data[m].input[2]=loadpointer[m-7][interval];
//	data[m].input[3]=pricepointer[m-7][interval];
	if(interval==0)
	{
		data[m].input[2]=pricepointer[m][interval+N-1];
		data[m].input[3]=nextdayload[interval+N-1];
	//	data[m].input[8]=pricepointer[m-1][interval+N-2];
	//	data[m].input[9]=loadpointer[m-1][interval+N-2];
	}
	if(interval==1)
	{
		data[m].input[2]=pricepointer[m][interval-1];
		data[m].input[3]=nextdayload[interval-1];
	//	data[m].input[8]=pricepointer[m-1][interval+N-2];
	//	data[m].input[9]=loadpointer[m-1][interval+N-2];
	
	
	}
	else if(interval>=2)
	{
		data[m].input[2]=pricepointer[m][interval-1];
		data[m].input[3]=nextdayload[interval-1];
	//	data[m].input[8]=pricepointer[m][interval-2];
	//	data[m].input[9]=loadpointer[m][interval-2];
	}
		data[m].input[4]=nextdayload[interval];
		data[m].teach=goalprice[interval];

}





/*************************************************************
*				GLVQ 算法						 *															 *
**************************************************************/

double t[daynumber][IN];
double t_temp[daynumber][IN];

void initial(int m,int interval)
{
	/*
	data[m].input[0]=loadpointer[m-1][interval];
	//data[m].input[1]=loadpointer[m-2][interval];
	data[m].input[1]=pricepointer[m-1][interval];
	//data[m].input[2]=pricepointer[m-2][interval];
//	data[m].input[2]=loadpointer[m-7][interval];
//	data[m].input[3]=pricepointer[m-7][interval];
	if(interval==0)
	{
		data[m].input[2]=pricepointer[m-1][interval+N-1];
		data[m].input[3]=loadpointer[m-1][interval+N-1];
	//	data[m].input[8]=pricepointer[m-1][interval+N-2];
	//	data[m].input[9]=loadpointer[m-1][interval+N-2];
	}
	else if(interval==1)
	{
		data[m].input[2]=pricepointer[m][interval-1];
		data[m].input[3]=loadpointer[m][interval-1];
	//	data[m].input[8]=pricepointer[m-1][interval+N-2];
	//	data[m].input[9]=loadpointer[m-1][interval+N-2];
	
	
	}
	else if(interval>=2)
	{
		data[m].input[2]=pricepointer[m][interval-1];
		data[m].input[3]=nextdayload[interval-1];
	//	data[m].input[8]=pricepointer[m][interval-2];
	//	data[m].input[9]=loadpointer[m][interval-2];
	}
	data[m].input[4]=nextdayload[interval];
	

	
	for(int i=0;i<IN;i++)
	{
		t[0][i]=data[m].input[i];
		//cout<<"t[0]["<<i<<"]="<<t[0][i]<<endl;
	}
	
	for(i=0;i<IN;i++)
	{
		t[0][i]=fabs(((double)rand()/32767.0)*2-1);
		//cout<<"t[0]["<<i<<"]="<<t[0][i]<<endl;
	}
	*/

	for(int j=0;j<classifynumber;j++)
		for(i=0;i<IN;i++)
		{
			t[j][i]=fabs(((double)rand()/32767.0)*2-1);
			//	cout<<"t["<<j<<"]["<<i<<"]="<<t[j][i]<<endl;
		}

}


int similarmatching(int m)
{
	int cell;
	double distance=0.0;
	double  dmin=1000;
	for(j=0;j<classifynumber;j++)
	{
		//distance=0.0;
		for(int i=0;i<IN;i++)
		distance+=(data[m].input[i]-t[j][i])*(data[m].input[i]-t[j][i]);
		distance=sqrt(distance);
        if(distance<dmin) 
		{
			dmin=distance;
			cell=j;
			
		}
		distance=0.0;
	}


	//cout<<"cell="<<cell<<endl;
	return cell;
}


		
int correctweight(double z,int k)//m 分类数，z学习效率，k为第k个学习模式；
{
	int index;
	
		index=similarmatching(k);
		for(int i=0;i<IN;i++)
		t[index][i]=t[index][i]+z*(data[k].input[i]-t[index][i]);
				//cout<<"t["<<j<<"]["<<i<<"]="<<t[j][i]<<endl;


	return index;
}





double studyvelocity;
int timeslimit=200;
double error_lvq=1e-5;
void GLVQ(int interval,int d[classifynumber][daynumber])
{
	
	srand((unsigned)time(NULL));
	int lop=0;
	int k[classifynumber];
	studyvelocity=0.8;
	initial();
	double dis;
	while(lop<timeslimit)
	{
		dis=0.0;
		for(int j=0;j<classifynumber;j++)
			for(int i=0;i<IN;i++)
			t_temp[j][i]=t[j][i];
		lop++;
		for(i=0;i<classifynumber;i++)
		k[i]=0;
		for(int m=1;m<daynumber;m++)
		{
			int flag;
			flag=correctweight(studyvelocity,m);
			d[flag][k[flag]]=m;
			k[flag]=k[flag]+1;
		}

		for(int i=k[flag];i<daynumber;i++)
		d[flag][i]=0;
		studyvelocity=studyvelocity*(1-(double)lop/timeslimit);
		//cout<<"studyvelocity="<<studyvelocity<<endl;
		
		for(j=0;j<classifynumber;j++)
			for(int i=0;i<IN;i++)
			dis+=(t_temp[j][i]-t[j][i])*(t_temp[j][i]-t[j][i]);
			dis=sqrt(dis);
		if(dis<error_lvq) break;

		dis=0.0;
	}


}

int  chosedata()
{






}



/*************************************************************
*				BP 算法										*															 *
**************************************************************/
//-----------------------------------------------------------
//初始化. 将连接权值、偏置系数置为(-1,1)之间的随机数
//	cout<<"输出w[i][j],unitnumber_b[i],v[i],y_b的初始值"<<endl;
void initializing()
{
	
	srand((unsigned)time(NULL));
	for(i=0; i<unitnumber; i++)
		for(j=0; j<IN-1; j++)
		{
			w[i][j]=((double)rand()/32767.0)*2-1;
		//	cout<<"w["<<i+1<<"]["<<j+1<<"]="<<w[i][j]<<endl;
		};
    for(i=0; i<unitnumber; i++)
		for(j=0; j<IN-1; j++)
		{
			w0[i][j] = 0.0;
				
		};
			
	for(i=0; i<unitnumber; i++)
	{
		hn_b[i] = ((double)rand()/32767.0)*2-1;
		//	cout<<"unitnumber_b["<<i+1<<"]="<<unitnumber_b[i]<<endl;
				
	};
			
			
	for(i=0; i<unitnumber; i++)
	{		
		v[i] = ((double)rand()/32767.0)*2-1;
	//	cout<<"v["<<i+1<<"]="<<v[i]<<endl;
	}
			
	for(i=0; i<unitnumber; i++)
	{		
		v0[i] =0.0;
	}
			
	y_b = ((double)rand()/32767.0)*2-1;
	//cout<<"y_b="<<y_b<<endl;
			
}		



void layer_in(int m) //样本m输入层的输出
{
	
	//输入正向传播
	for(j=0; j<IN; j++)                 //设置输入层的输出
		xout[j]=t[m][j];
	
}






void hnout()
{
	for(i=0; i<unitnumber; i++)								//计算隐含层的输出
	{
		sumtemp = 0.0;
		for(j=0; j<IN; j++)
			sumtemp += w[i][j] * xout[j];
		sumtemp +=hn_b[i];
		hn_out[i]=1/(1+exp(-sumtemp));			//隐含层作用函数为y=1/(1+exp(-sumtemp)
	}
	
}


void yout()
{
	sumtemp = 0.0;