📄 main.cpp
字号:
temp=c_temp[1];
c_temp[1]=c_temp[i];
c_temp[i]=temp;
}
}
min_c3=c_temp[1];
for(i=1;i<=40;i++) //数据归一化
net_c[i]=(net_c[i]-min_c3)/(max_c3-min_c3);
//fpc=fopen("cc.txt","w");
//for(i=1;i<41;i++)
//fprintf(fpc,"%lf\n",net_c[i]);
///////////////////////////////////输入c3in文件
fp=fopen("c3in.txt","w");
for(i=0;i<1;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=1;i<=7;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=8;i<=14;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=15;i<=21;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=22;i<=28;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=29;i<=35;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=36;i<=40;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
//存预测样本数据
day=yucetian-1; //29 yucetian---为30
pday="c3_day";
strday.Format("%d",day);
pday+=strday;
pday+=".txt";
fpc=fopen(pday,"r");
for(i=0;i<24;i++) //96点的话要修改,这是24点
{
fscanf(fpc,"%lf",&tmp31[i]); //tmp31----29
}
fclose(fpc);
day=yucetian-2; //28
pday="c3_day";
strday.Format("%d",day);
pday+=strday;
pday+=".txt";
//cout<<pday<<endl;
fpd=fopen(pday,"r");
for(i=0;i<24;i++)
{
fscanf(fpd,"%lf",&tmp32[i]); //tmp32---28
}
fclose(fpd);
day=yucetian-3; //27
pday="c3_day";
strday.Format("%d",day);
pday+=strday;
pday+=".txt";
fp=fopen(pday,"r");
for(i=0;i<24;i++)
{
fscanf(fp,"%lf",&tmp33[i]); //tmp3---27
}
fclose(fp);
c3_yuce[1]=tmp31[0];
c3_yuce[0]=tmp32[23]; //96点的话要修改,这是24点
c3_yuce[3]=tmp32[0];
c3_yuce[2]=tmp33[23];
c3_yuce[4]=tmp31[0]-tmp32[0];
day=yucetian-7; //23
pday="c3_day";
strday.Format("%d",day);
pday+=strday;
pday+=".txt";
fpc=fopen(pday,"r");
for(i=0;i<24;i++)
{
fscanf(fpc,"%lf",&tmp34[i]); //tmp34---23
}
fclose(fpc);
day=yucetian-14; //16
pday="c3_day";
strday.Format("%d",day);
pday+=strday;
pday+=".txt";
fpd=fopen(pday,"r");
for(i=0;i<24;i++)
{
fscanf(fpd,"%lf",&tmp35[i]); //tmp35---16
}
fclose(fpd);
c3_yuce[6]=tmp34[0];
c3_yuce[5]=tmp35[0];
///////输入c3bpin文件
for(i=0;i<=6;i++)
c3_yuce[i]=(c3_yuce[i]-min_c3)/(max_c3-min_c3); /////负荷数据归一化
fp=fopen("c3bpin.txt","w");
for(i=0;i<=6;i++)
fprintf(fp,"%lf\t",c3_yuce[i]);
fclose(fp);
///////对c3序列进行神经网络预测
netc3();///网络训练
fp=fopen("c3bpin.txt","r+"); //c3神经网络模型输入的数据文件
fpc=fopen("c3bpout.txt","w+"); //c3神经网络模型输出数据文件
for(i=0;i<IN_c;i++)
{
fscanf(fp,"%lf",&Study_Data_c[0].input[i]);
}
input_P_c(0); //输入第m个学习样本 (2)
H_I_O_c(); //第m个学习样本隐层各单元输入、输出值 (4)
O_I_O_c(); //第m个学习样本输出层各单元输入、输出值 (5)
for(int j=0;j<ON_c;j++)
O_c[j]=(max_c3-min_c3)*O_c[j]+min_c3;
for(j=0;j<ON_c;j++)
fprintf(fpc,"%lf\n",O_c[j]);
fclose(fp);
fclose(fpc);
}
///////////////////////////////////////////////////////////////////////
void yucec3(int hour)
{
net_c[0]=0.00001;
for(int i=hour-1;i<=hour-1;i++)
{
net_c[2]=tmp1[hour-1]; //28
net_c[1]=tmp1[hour-2]; //96点的话要修改,这是24点
net_c[4]=tmp2[hour-1]; //27
net_c[3]=tmp2[hour-2];
net_c[5]=tmp1[hour-1]-tmp2[hour-1];
net_c[7]=tmp4[hour-1]; //22
net_c[6]=tmp5[hour-1]; //15
//训练样本28
net_c[9]=tmp6[hour-1]; //27
net_c[8]=tmp6[hour-2]; //27
net_c[11]=tmp7[hour-1]; //26
net_c[10]=tmp7[hour-2];
net_c[12]=tmp6[hour-1]-tmp7[hour-1];
net_c[14]=tmp9[hour-1]; //21
net_c[13]=tmp10[hour-1]; //14
//训练样本23
net_c[16]=tmp11[hour-1]; //22
net_c[15]=tmp11[hour-2];
net_c[18]=tmp12[hour-1]; //21
net_c[17]=tmp12[hour-2];
net_c[19]=tmp11[hour-1]-tmp12[hour-1];
net_c[21]=tmp14[hour-1]; //16
net_c[20]=tmp15[hour-1]; //9
//训练样本 16
net_c[23]=tmp16[hour-1]; //15
net_c[22]=tmp16[hour-2];
net_c[25]=tmp17[hour-1]; //14
net_c[24]=tmp17[hour-2];
net_c[26]=tmp16[hour-1]-tmp17[hour-1];
net_c[28]=tmp19[hour-1]; //9
net_c[27]=tmp20[hour-1]; //2
//训练样本27
net_c[30]=tmp21[hour-1]; //26
net_c[29]=tmp21[hour-2]; //96点的话要修改,这是24点
net_c[32]=tmp22[hour-1]; //25
net_c[31]=tmp22[hour-2];
net_c[33]=tmp21[hour-1]-tmp22[hour-1];
net_c[35]=tmp24[hour-1]; //20
net_c[34]=tmp25[hour-1]; //13
//教师样本
net_c[36]=tmp26[hour-1]; //29
net_c[37]=tmp27[hour-1]; //28
net_c[38]=tmp28[hour-1]; //23
net_c[39]=tmp29[hour-1]; //16
net_c[40]=tmp30[hour-1]; //27
//预测样本输入
c3_yuce[1]=tmp31[hour-1]; //29
c3_yuce[0]=tmp31[hour-2];
c3_yuce[3]=tmp32[hour-1]; //28
c3_yuce[2]=tmp32[hour-2];
c3_yuce[4]=tmp31[hour-1]-tmp32[hour-1];
c3_yuce[6]=tmp34[hour-1]; //23
c3_yuce[5]=tmp35[hour-1]; //16
}
////数据归一化
for(i=1;i<=40;i++) ///求极大值
c_temp[i]=net_c[i];
for(i=1; i<=40; i++)
{
if(c_temp[1]<c_temp[i])
{
temp=c_temp[1];
c_temp[1]=c_temp[i];
c_temp[i]=temp;
}
}
max_c3=c_temp[1];
for(i=1;i<=40;i++) ////求极小值
c_temp[i]=net_c[i];
for(i=1;i<=40; i++)
{
if(c_temp[1]>c_temp[i])
{
temp=c_temp[1];
c_temp[1]=c_temp[i];
c_temp[i]=temp;
}
}
min_c3=c_temp[1];
for(i=1;i<=40;i++) //数据归一化
net_c[i]=(net_c[i]-min_c3)/(max_c3-min_c3);
///////////////////////////////////输入c3in文件
fp=fopen("c3in.txt","w");
for(i=0;i<1;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=1;i<=7;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=8;i<=14;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=15;i<=21;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=22;i<=28;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=29;i<=35;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
fp=fopen("c3in.txt","a+");
for(i=36;i<=40;i++)
fprintf(fp,"%lf\t",net_c[i]);
fprintf(fp,"\n");
fclose(fp);
///////输入c3bpin文件
for(i=0;i<=6;i++)
c3_yuce[i]=(c3_yuce[i]-min_c3)/(max_c3-min_c3); /////负荷数据归一化
fp=fopen("c3bpin.txt","w");
for(i=0;i<=6;i++)
fprintf(fp,"%lf\t",c3_yuce[i]);
fclose(fp);
///////对c3序列进行神经网络预测
netc3();///网络训练
fp=fopen("c3bpin.txt","r+"); //c3神经网络模型输入的数据文件
fpc=fopen("c3bpout.txt","a+"); //c3神经网络模型输出数据文件
for(i=0;i<IN_c;i++)
{
fscanf(fp,"%lf",&Study_Data_c[0].input[i]);
}
input_P_c(0); //输入第m个学习样本 (2)
H_I_O_c(); //第m个学习样本隐层各单元输入、输出值 (4)
O_I_O_c(); //第m个学习样本输出层各单元输入、输出值 (5)
for(int j=0;j<ON_c;j++)
O_c[j]=(max_c3-min_c3)*O_c[j]+min_c3;
for(j=0;j<ON_c;j++)
fprintf(fpc,"%lf\n",O_c[j]);
fclose(fp);
fclose(fpc);
}
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////d3预测//////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////
//////////////////d3///////////////
///////////////////////////////////
#define N_d3 5//学习样本个数
#define IN_d3 28 //输入层神经元数目
#define HN_d3 15 //隐层神经元数目
#define ON_d3 1 //输出层神经元数目
const R_d3=HN_d3*(IN_d3+1)+ON_d3*(HN_d3+1); //列的常数定义
//#define DIM R_d3
#define EPSILON 0.000000001
#include "qiunid3.c"
extern int gjcpegd3(int process,double A[DIM][DIM],double b[DIM][DIM]);
double P_d3[IN_d3]; //单个样本输入数据
double T_d3[ON_d3]; //单个样本教师数据
double W_d3[HN_d3][IN_d3]; //输入层至隐层权值
double V_d3[ON_d3][HN_d3]; //隐层至输出层权值
double X_d3[HN_d3]; //隐层的输入
double Y_d3[ON_d3]; //输出层的输入
double H_d3[HN_d3]; //隐层的输出
double O_d3[ON_d3]; //输出层的输出
double sita_d3[HN_d3]; //隐层的阈值
double gama_d3[ON_d3]; //输出层的阈值
double err_m_d3[N_d3]; //第m个样本的总误差
double err_O_d3[N_d3][ON_d3]; ///m样本第ON输出的误差
double s2_d3[ON_d3]; //定义敏感度s2
double s1_d3[HN_d3]; //定义敏感度数组s1
double yacobi_d3[N_d3][R_d3]; //N*ON,IN*HN+HN+HN*ON+ON 行，列
double niu_d3,beta_d3=10.0; //定义参数
double det_x_d3[R_d3]; ////定义误差数组
//定义一个放学习样本的结构
struct {
double input[IN_d3];
double teach[ON_d3];
}Study_Data_d3[N_d3];
///////////////////////////
//初始化权、阈值子程序/////
///////////////////////////
initial_d3()
{
//隐层权、阈值初始化//
srand( (unsigned)time( NULL ) );
for(int i=0;i<HN_d3;i++)
{
for(int j=0;j<IN_d3;j++)
W_d3[i][j]= (double)((rand()/32767.0)*2-1); //初始化输入层到隐层的权值，-1到1之间的随机值
}
for(int ii=0;ii<ON_d3;ii++)
{
for(int jj=0;jj<HN_d3;jj++)
V_d3[ii][jj]= (double)((rand()/32767.0)*2-1); //初始化隐层到输出层的权值，-1到1之间的随机值
}
for(int k=0;k<HN_d3;k++)
{
sita_d3[k] = (double)((rand()/32767.0)*2-1); //隐层阈值初始化 -1到1之间的随机值
}
for(int kk=0;kk<ON_d3;kk++)
{
gama_d3[kk] = (double)((rand()/32767.0)*2-1); //输出层阈值初始化 ,-1到1之间的随机值
}
return 1;
}//子程序initial()结束
////////////////////////////////
////第m个学习样本输入子程序///
///////////////////////////////
input_P_d3(int m)
{
int i;
for(i=0;i<IN_d3;i++)
P_d3[i]=Study_Data_d3[m].input[i];
return 1;
}//子程序input_P(m）结束
/////////////////////////////
////第m个样本教师信号子程序//
/////////////////////////////
input_T_d3(int m)
{
int k;
for(k=0;k<ON_d3;k++)
T_d3[k]=Study_Data_d3[m].teach[k];
return 1;
}//子程序input_T(m)结束
/////////////////////////////////
//隐层各单元输入、输出值子程序///
/////////////////////////////////
H_I_O_d3()
{
double sigma;
int i,j;
for (j=0;j<HN_d3;j++)
{
sigma=0.0;
for (i=0;i<IN_d3;i++)
sigma+=W_d3[j][i]*P_d3[i];//求隐层内积
X_d3[j]=sigma+sita_d3[i];//求隐层净输入
H_d3[j]=1.0/(1.0+exp(-X_d3[j]));//求隐层输出
}
return 1;
}//子程序H_I_O()结束
///////////////////////////////////
//输出层各单元输入、输出值子程序///
///////////////////////////////////
O_I_O_d3()
{
int k,j;
double sigma;
for(k=0;k<ON_d3;k++)
{
sigma=0.0;
for (j=0;j<HN_d3;j++)
sigma+=V_d3[k][j]*H_d3[j];//求输出层内积
Y_d3[k]=sigma+gama_d3[k]; //求输出层净输入
O_d3[k]=1.0/(1.0+exp(-Y_d3[k]));
}
return 1;
}//子程序O_I_O()结束
////////////////////////////////////
/////求输出误差、各样本平方误差/////
////////////////////////////////////
Err_yangben_d3(int m)
{
double abs_err[ON_d3]; //每个样本的绝对误差都是从0开始的
double sqr_err=0; //每个样本的平方误差计算都是从0开始的
for (int k=0;k<ON_d3;k++)
{
err_O_d3[m][k]=T_d3[k]-O_d3[k];
abs_err[k]=T_d3[k]-O_d3[k];
sqr_err+=(abs_err[k])*(abs_err[k]);//求第m个样本下输出层的平方误差
}
err_m_d3[m]=sqr_err;
return 1;
}//子程序Err_yangben(m)结束
/////////////////////////////////
//N个样本的全局误差计算子程序////
/////////////////////////////////
double Err_Sum_d3()
{
double total_err=0;
int m;
for (m=0;m<N_d3;m++)
total_err+=err_m_d3[m];//每个样本的均方误差加起来就成了全局误差
return total_err;
}//子程序Err_sum()结束
////////////////////////////////////
//////////////求LM敏感度////////////
////////////////////////////////////
Err_O_H_s_d3()
{
int k;
for (k=0;k<ON_d3;k++)
{
s2_d3[k]=-O_d3[k]*(1.0-O_d3[k]); //敏感度s2
}
return 1;
}//子程序Err_O_H_s(m)结束
Err_H_I_s_d3()
{
int j,k;
double sigma;
for (j=0;j<ON_d3;j++)
{
sigma=0.0;
for (k=0;k<HN_d3;k++)
{
sigma=(H_d3[k]*(1.0-H_d3[k]))*V_d3[j][k];
s1_d3[k]=sigma*s2_d3[j]; //敏感度s1
}
}
return 1;
}//子程序Err_H_I_s_c()结束
////////////////////////////////////
/////////////求雅可比矩阵///////////
////////////////////////////////////
qiuyacobi_d3(int m) //求雅可比矩阵各元素
{
int i,j,jj;
jj=0;
for(i=0;i<HN_d3;i++)
{
for(j=0;j<IN_d3;j++)
{
yacobi_d3[m][jj]=s1_d3[i]*P_d3[j];
jj=jj+1;
}
yacobi_d3[m][jj]=s1_d3[i];
jj=jj+1;
}
for(j=0;j<ON_d3;j++)
{
for(i=0;i<HN_d3;i++)
{
yacobi_d3[m][jj]=s2_d3[j]*H_d3[i];
jj=jj+1;
}
yacobi_d3[m][jj]=s2_d3[j];
jj=jj+1;
}
return 1;
}
//////////////////////////////////////////
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -