免疫优化计算、学习与识别.txt

免疫算法,用于参数优化和系统辨识等,希望对大家有用!

附录C基本算法
C.1二进制编码的简单遗传算法源程序 -ga（）
C.2二进制编码的简单克隆选择算法源程序-ia（）
comfit（）共用


#include "math.h" 
#include <stdlib.h> 
#include <stdio.h> 
#include <time.h> 
#include "time.h"
#include <iostream.h> 

#define ND 10

double comfit(int funn,int vn,double v1i[]); 
void ia();
void ga();

void ia()
{ 
   char *m_SP2;
int m_N,m_ge,m_Nb,m_c,m_now;

m_SP2="F013";
m_N=20; 
m_c=5; 
m_ge=100; 
m_Nb=5;
if (m_SP2=="") 
{ 
m_SP2="F005";
} 
if (m_N==0||m_ge==0||m_Nb==0) 
{ 
m_N=50; 
m_c=5; 
m_ge=100; 
m_Nb=5;
} //设置算法默认参数 
//-------------------------------------------------------------- 
int N=m_N; 
int funn; 
int c; 
double Nb=m_Nb; 
int ge=m_ge; 
double vup,vdown,ting; 
int i,j,k,L; //定义算法变量 
//=========================== 
if (m_SP2=="F001") //定义测试问题的变量区间
{ 
funn=1; 
vup=0.5; 
vdown=-0.5;c=1; 
ting=100000000000000000; 
} 
else if (m_SP2=="F003") 
{ 
funn=3; 
vup=1; 
vdown=-1;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F004") 
{ 
funn=4; 
vup=10; 
vdown=-10;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F005") 
{ 
funn=5; 
vup=1; 
vdown=-1;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F006") 
{ 
funn=6; 
vup=1; 
vdown=-1;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F007") 
{ 
funn=7; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F008") 
{ 
funn=8; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F009") 
{ 
funn=9; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F011") 
{ 
funn=11; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F013") 
{ 
funn=13; 
vup=10; 
vdown=-10;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F014") 
{ 
funn=14; 
vup=512; 
vdown=-512;c=2; 
ting=100000000000000000; 
} 
m_c=c; 
//-------------------------------------------------------------- 
//算法程序（输入变量：N种群规模；funn测试问题；c变量维数；Nb克隆比例；ge最大进化代数； 
// vup变量上限；vdown变量下限；ting终止亲和度值(如果没有请设置成足够大的数） 
//输出变量：it进化代数；guiji[]最优值进化轨迹；fev评价次数 
//-------------------------------------------------------------- 
double Nc; Nc=N*Nb; 
int CL=20; //编码长度 
int (*v)[100]; 
v=new int [1000][100]; 
double (*v1)[ND]; 
v1 = new double [1000][ND]; 
double fa1[ND]; 
double fit1[1000],fit[1000],guiji[2000]; 
double z=32768,ab,max; 
double Ns; //,yop
int fev=0;int it=0; 
double sollution=-1*10000000; 
int sub[1000][100]; 
double r[1000], maxhang[1000]; 
//定义程序变量 
// srand( (unsigned)time( NULL ) ); 
//------------------------------------------------------------- 
for (i=0;i<N;i++) 
{ 
for (j=0;j<c*CL;j++) 
{ 
ab=rand()/z; 
if (ab<=0.5) 
{ 
v[i][j]=0; 
} 
else 
{ 
v[i][j]=1; 
} 
} 
} 
//初始化二进制种群； 
for (i=0;i<N;i++) 
{ 
for (j=0;j<c;j++) 
{ 
v1[i][j]=0; 
for (k=0;k<CL;k++) 
{ 
if (v[i][j*CL+k]==1) 
{
v1[i][j]=v1[i][j]+pow(2,CL-k-1); 
} 
else 
{
v1[i][j]=v1[i][j];
} 
} 
fa1[j]=v1[i][j]*(vup-vdown)/(pow(2,CL)-1)+vdown; 
}
fit[i]=comfit(funn,c,fa1); 
} 
//译码 
fev=fev+N; 
//计算亲合度值 
while (it<ge&&sollution<ting) 
{ 
for (i=0;i<N;i++) 
{ 
Ns=Nb; 
for (j=0;j<Ns;j++) 
{
for (k=0;k<c*CL;k++) 
{ 
sub[j][k]=v[i][k]; 
} 
for (L=0;L<c*CL;L++) 
{ 
r[L]=rand()/z; 
} 
for (k=0;k<c*CL;k++) 
{
if (r[k]<=1.000000000000/CL) 
{ 
sub[j][k]=1-sub[j][k]; 
} 
} 
} //克隆操作

for (j=0;j<Ns;j++) 
{ 
for (k=0;k<c;k++) 
{ 
v1[j][k]=0; 
for (L=0;L<CL;L++) 
{ 
if (sub[j][k*CL+L]==1) 
{ 
v1[j][k]=v1[j][k]+pow(2,CL-L-1); 
} 
else 
{ 
v1[j][k]=v1[j][k]; 
} 
} 
fa1[k]=v1[j][k]*(vup-vdown)/(pow(2,CL)-1)+vdown; 
} 
fit1[j]=comfit(funn,c,fa1); //克隆子群体计算亲和度值 
fev=fev+1; 
} 
//------------------------------------------------------------------ 
max=fit[i]; 
for (k=0;k<c*CL;k++) 
{ 
maxhang[k]=v[i][k]; 
} 
for (k=0;k<Ns;k++) 
{ 
if (max<fit1[k]) 
{ 
max=fit1[k]; 
for (L=0;L<c*CL;L++) 
{
maxhang[L]=sub[k][L]; 
} 
} 
} 
for (k=0;k<c*CL;k++) 
{ 
v[i][k]=int(maxhang[k]); 
} 
fit[i]=max;
} //克隆选择完成
max=fit[0]; 
for (i=1;i<N;i++) 
{ 
if (max<fit[i]) 
{ 
max=fit[i]; 
} 
} 
//输出结果: 
sollution=max; 
guiji[it]=sollution; 
it=it+1; 
m_now=it; 
cout<<m_now<<"\t"<<max<<endl;
   } 
//算法程序（输入变量：N种群规模；funn测试问题；c变量维数；Nb克隆比例； ge最大进化代数 
//输出变量：it进化代数；guiji[]最优值进化轨迹；fev评价次数 
delete [] v; 
delete [] v1; 
} 
void ga()
{ 
   int m_N,m_ge,m_c,m_now; 
double m_Pc,m_Pm;
char *m_SP2;

m_SP2="F013";
m_N=100; 
m_c=5; 
m_ge=100; 
m_Pc=0.8; 
m_Pm=0.15; 
//-------------------------------------------- 
if (m_SP2=="") 
{ 
m_SP2="F005";
} 
if (m_N==0||m_ge==0||m_Pc==0||m_Pm==0) 
{ 
m_N=100; 
m_c=5; 
m_ge=100; 
m_Pc=0.8; 
m_Pm=0.15; 
} //设置默认参数 
//-------------------------------------------------------------- 
int N=m_N; 
int funn; 
int c; 
double Pc=m_Pc; 
double Pm=m_Pm; 
int ge=m_ge; 
double vup,vdown,ting; 
int i,j,k,L; 
//=========================== 
if (m_SP2=="F001") //定义测试问题的变量区间
{ 
funn=1; 
vup=0.5; 
vdown=-0.5;c=1; 
ting=100000000000000000; 
} 
else if (m_SP2=="F003") 
{ 
funn=3; 
vup=1; 
vdown=-1;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F004") 
{ 
funn=4; 
vup=10; 
vdown=-10;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F005") 
{ 
funn=5; 
vup=1; 
vdown=-1;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F006") 
{ 
funn=6; 
vup=1; 
vdown=-1;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F007") 
{ 
funn=7; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F008") 
{ 
funn=8; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F009") 
{ 
funn=9; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F011") 
{ 
funn=11; 
vup=5.12; 
vdown=-5.12;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F013") 
{ 
funn=13; 
vup=10; 
vdown=-10;c=2; 
ting=100000000000000000; 
} 
else if (m_SP2=="F014") 
{ 
funn=14; 
vup=512; 
vdown=-512;c=2; 
ting=100000000000000000; 
} 
m_c=c; 
//-------------------------------------------------------------- 
//算法程序（输入变量： N种群规模； funn测试问题；c变量维数；ge最大进化代数； 
// vup变量上限；vdown变量下限； ting终止适应度值(如果没有请设置成足够大的数） 
//输出变量：it进化代数；guiji[]最优值进化轨迹； fev评价次数 
//-------------------------------------------------------------- 

int CL=20; //编码长度 
int (*v)[100]; 
v=new int [1000][100]; 
int (*vs)[100]; 
vs=new int [1000][100]; 
double (*v1)[ND]; 
v1 = new double [1000][ND];
int aa[1000],bb[1000]; 
double fa1[ND]; 
double fit1[1000],fit[1000],guiji[2000]; 
double z=32768,max; 
double abb; 
int fev=0;int it=0,ab; 
double sollution=-1*10000000; 
double r[1000], max1; 
int maxhang[1000],maxhang1[1000]; 
//定义程序变量 
srand( (unsigned)time( NULL ) ); 
//------------------------------------------------------------- 
for (i=0;i<N;i++) 
{ 
for (j=0;j<c*CL;j++) 
{ 
abb=rand()/z; 
if (abb<=0.5) 
{ 
v[i][j]=0; 
} 
else 
{ 
v[i][j]=1; 
} 
} 
} 
//初始化二进制种群； 
for (i=0;i<N;i++) 
{ 
for (j=0;j<c;j++) 
{ 
v1[i][j]=0; 
for (k=0;k<CL;k++) 
{ 
if (v[i][j*CL+k]==1) 
{ 
v1[i][j]=v1[i][j]+pow(2,CL-k-1); 
} 
else 
{ 
v1[i][j]=v1[i][j]; 
} 
} 
fa1[j]=v1[i][j]*(vup-vdown)/(pow(2,CL)-1)+vdown; 
} 

fit[i]=comfit(funn,c,fa1); 
}
//译码 
fev=fev+N; //计算适应度值
max=fit[0]; 
for (i=1;i<N;i++) 
{ 
if (max<fit[i])

{ 
max=fit[i]; 
for(j=0;j<c*CL;j++) 
{
maxhang[j]=v[i][j]; 
} 
} 
} 
while (it<ge&&sollution<ting) 
{ 
for (i=0;i<N;i++) 
{ 
for (j=0;j<c*CL;j++) 
{
aa[j]=v[i][j]; 
} 
fa1[1]=fit[i]; 
ab=rand()%N; 
for (j=0;j<c*CL;j++) 
{
bb[j]=v[ab][j]; 
} 
fa1[2]=fit[ab]; 
if (fa1[1]<fa1[2]) 
{
for (j=0;j<c*CL;j++) 
{
vs[i][j]=bb[j]; 
} 
fit1[i]=fa1[2]; 
} 
else 
{
for (j=0;j<c*CL;j++) 
{ 
vs[i][j]=aa[j]; 
} 
fit1[i]=fa1[1]; 
} 
} 
v=vs; 
for (i=0;i<N;i++) 
{ 
fit[i]=fit1[i]; 
} 
//联赛选择 
//交叉 
for (i=0;i<N;i++) 
{ 
if(rand()/z<Pc) 
{ 
for (j=0;j<c*CL;j++) 
{ 
aa[j]=v[i][j]; 
} 
ab=rand()%N; 
for (j=0;j<c*CL;j++) 
{ 
bb[j]=v[ab][j]; 
} 
ab=rand()%(c*CL); 
for (j=0;j<ab;j++) 
{ 
aa[j]=bb[j]; 
} 
for(j=0;j<c*CL;j++) 
{ 
v[i][j]=aa[j]; 
} 
} 
} 
//变异 
for (i=0;i<N;i++) 
{ 
for (L=0;L<c*CL;L++) 
{ 
r[L]=rand()/z; 
} 
for (k=0;k<c*CL;k++) 
{ 
if (r[k]<=Pm*1.000/(c*CL)) 
{ 
v[i][k]=1-v[i][k]; 
} 
} 
} 
for (i=0;i<N;i++) 
{ 
for (j=0;j<c;j++) 
{ 
v1[i][j]=0; 
for (k=0;k<CL;k++) 
{ 
if (v[i][j*CL+k]==1) 
{ 
v1[i][j]=v1[i][j]+pow(2,CL-k-1); 
} 
else 
{ 
v1[i][j]=v1[i][j]; 
} 
} 
fa1[j]=v1[i][j]*(vup-vdown)/(pow(2,CL)-1)+vdown; 
} 
fit[i]=comfit(funn,c,fa1); 
} //译码 
fev=fev+N; //计算适应度值 
//------------------------------------------------------------------ 
max1=fit[0]; 
for (i=1;i<N;i++) 
{ 
if (max1<fit[i]) 
{ 
max1=fit[i]; 
for(j=0;j<c*CL;j++) 
{ 
maxhang1[j]=v[i][j]; 
} 
} 
} 
if (max<max1) 
{ 
max=max1; 
for(j=0;j<c*CL;j++) 
{
maxhang[j]=maxhang1[j]; 
} 
} 
//输出结果: 
sollution=max; 
guiji[it]=sollution; 
it=it+1; 
m_now=it; 
} 
//算法程序（输入变量：N种群规模；funn测试问题；c变量维数；ge最大进化代数 
//输出变量：it进化代数；guiji[]最优值进化轨迹；fev评价次数 
delete [] v; 
delete [] v1; 

} 

double comfit(int funn,int vn,double v1i[]) 
//计算一个抗体的亲和力，funn为函数序号，vn为变量维数，v1i[]为一个抗体 
{ 
int i;double f1=0,f1h,f1m; 
switch (funn) 
{ 
case 1:
{
f1=10+(sin(1/v1i[0]))/((v1i[0]-0.16)*(v1i[0]-0.16)+0.1); 
} 
break; 
case 3: 
{
f1=pow(v1i[0],2)+pow(v1i[1],2)-0.3*cos(3*3.1415926535897931*v1i[0])+0.3*cos(4*3.1415926535897931*v1i[1])+0.3; 
f1=-1*f1; 
} 
break; 
case 4:
{ 
f1h=0;f1m=0; 
for (i=1;i<6;i++) 
{
f1h=f1h+i*cos((i+1)*v1i[0]+i); 
f1m=f1m+i*cos((i+1)*v1i[1]+i); 
} 
f1=f1h*f1m; 
f1=-1*f1; 
} 
break; 
case 5: 
{ 
f1=1+v1i[0]*sin(4*3.1415926*v1i[0])-v1i[1]*sin(4*3.1415926*v1i[1]+3.1415926)+sin(6*sqrt(v1i[0]*v1i[0]+v1i[1]*v1i[1]))/( 

6*sqrt(v1i[0]*v1i[0]+v1i[1]*v1i[1])+pow(10,-15)); 
} 
break; 
case 6: 
{
f1=1+v1i[0]*sin(4*3.1415926*v1i[0])-v1i[1]*sin(4*3.1415926*v1i[1]+3.1415926); 
} 
break; 
case 7: 
{
f1=pow(3/(0.05+pow(v1i[0],2)+pow(v1i[1],2)),2)+pow(pow(v1i[0],2)+pow(v1i[1],2),2); 
} 
break; 
case 8: 
{
f1=-1*pow(pow(v1i[0],2)+pow(v1i[1],2),0.25)*(pow(sin(50*pow(v1i[0]*v1i[0]+v1i[1]*v1i[1],0.1)),2)+1.0); 
} 
break; 
case 9:
{ 
for (i=0;i<2;i++) 
{
f1=f1+pow(v1i[i],2)-10*cos(2*3.1415926*v1i[i]); 
} 
f1=10*vn+f1; 
f1=-1*f1; 
} 
break; 
case 11: 
{
f1=-1*pow(v1i[0],2)-1*pow(v1i[1],2); 
} 
break; 
case 13: 
{
f1=0.5+(pow(sin(sqrt(v1i[0]*v1i[0]+v1i[1]*v1i[1])),2)-0.5)/pow(1+0.001*(pow(v1i[0]*v1i[0]+v1i[1]*v1i[1],2)),2); 
f1=-1*f1; 
} 
break; 
case 14: 
{
f1=v1i[0]*sin(sqrt(fabs(v1i[1]+1-v1i[0])))*cos(sqrt(fabs(v1i[1]+1+v1i[0])))+(v1i[1]+1)*cos(sqrt(fabs(v1i[1]+1-v1i[0])))* 
sin(sqrt(fabs(v1i[1]+1+v1i[0]))); 
f1=-1*f1; 
} 
break;
} 
return (f1); 
} 

void main()
{
ia();
ga();
}