蚁群啊蚁群.cpp

用vc++编写的蚁群算法

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#define PI   3.141       //圆周率
#define Q     100     
#define Row   0.7        //挥发率
#define Alfa  1.0
#define Beta  1.0
#define Epsilon 1E-5
#define M  10            //蚂蚁群中蚂蚁的数目     
#define Msearch  100      //搜索次数，邻域搜索的次数
#define R        0.5     //搜索半径
#define Prop_R   0.5      
#define ranP     0.3     //转移概率随即数
#define Nc_out   8
#define Nc_in    8
#define Dim      7               //自变量数
#define Judge    >
double border[Dim][2]={{-10,10},
 {-10,10},{-10,10},{-10,10},{-10,10},{-10,10},{-10,10}};   //自变量取值范围
 
double ran_point=2.0;
double  Dtaw[M],          //信息素的增量
	taw[M],               //信息素强度
	Dz[M][M],             //即为ita（i,j），即目标函数的差异值
	P[M][M],              //转移概率
	X[M][Dim],
	Intx[Dim];           
double  optimum_X[Dim],   //最优x的值
	optimum_Z=99999999.0,
	pre_optimum;
double rad=R;
int i,j;

double f_value(double pre_f_X[Dim])           //求函数值
{
int i_f;
double number,deno,final=0.0;
double x[Dim+1];
for(i_f=0;i_f<Dim;i_f++)
  x[i_f+1]=pre_f_X[i_f];
final=(x[1]-10)*(x[1]-10)+5*(x[2]-12)*(x[2]-12)+x[3]*x[3]*x[3]*x[3]+3*(x[4]-11)*(x[4]-11)+10*x[5]*x[5]*x[5]*x[5]*x[5]*x[5]+7*x[6]*x[6]+x[7]*x[7]*x[7]*x[7]-4*x[6]*x[7]-10*x[6]-8*x[7];

return final;
}


int fun_restrict(double restrict[Dim])      //约束条件判断
{
 int i_fr;
 double x[Dim+1];
 for(i_fr=0;i_fr<Dim;i_fr++)             //pow计算以x为底数的y次幂
   x[i_fr+1]=restrict[i_fr];
 if(!(127.0-2.0*x[1]*x[1]-3.0*pow(x[2],4.0)-x[3]-4.0*pow(x[4],2.0)-5.0*x[5]>=0.0))
   return 0;
 else if(!(282.0-7.0*x[1]-3.0*x[2]-10.0*x[3]*x[3]-x[4]+x[5]>=0.0))
 return 0;
 else if(!(196.0-23.0*x[1]-x[2]*x[2]-6.0*x[6]+8.0*x[7]>=0.0))
  return 0;
 else if(!(-4*x[1]*x[1]-x[2]*x[2]-3*x[1]*x[2]-2*x[3]*x[3]-5*x[6]+11*x[7]>=0.0))
  return 0;
  else
  return 1;
}


double ran0_1(double*ran_point)
{
  int m;
  double s,u,v,p;
  s=65536.0;
  u=2053.0;
  v=13849.0;
  m=(int)(*ran_point/s);
  *ran_point=*ran_point-m*s;
  *ran_point=u*(*ran_point)+v;
  m=(int)(*ran_point/s);
  *ran_point=*ran_point-m*s;
  p=*ran_point/s;
  
  /*	double p;
	p=rand()%1000/1000.0;
	*/
  return p;
}

  double DirP(int i,int j)           //计算转移概率
{
	  int k;
	  double number,deno=0.0,final;
	  if(Dz[i][j] Judge 0)
	  {
		  number=taw[j]*fabs(Dz[i][j]);
		  for(k=0;k<M;k++)
		  {
			  if(Dz[i][k] Judge 0)
				  deno=deno+taw[k]*fabs(Dz[i][k]);
		  }
		  if(deno==0)
			  final=0.0;
		  else
			  final=number/deno;
	  }
	  else
		  final=0.0;
	  return final;
}
    
void updata()                   
{
     int i_updata,j_updata;
     for(i_updata=0;i_updata<M;i_updata++)
	 {
       for(j_updata=0;j_updata<M;j_updata++)
	   {
		   Dz[i_updata][j_updata]=f_value(X[i_updata])-f_value(X[j_updata]);  //Dz矩阵即为ita
	   }
	 }

	 for(i_updata=0;i_updata<M;i_updata++)
	 {
		 for(j_updata=0;j_updata<M;j_updata++)
		 {
			 P[i_updata][j_updata]=DirP(i_updata,j_updata);
		 }
	 }
}

	
	
void Creat_Ant()
{
	int i_creat,j_creat;
    for (i_creat=0;i_creat<M;i_creat++)
	{
		for(j_creat=0;j_creat<Dim;j_creat++)
		{
			X[i_creat][j_creat]=border[j_creat][0]+ran0_1(&ran_point)*(border[j_creat][1]-border[j_creat][0]);
		}
		if(fun_restrict(X[i_creat])==0)
			i_creat--;
			
	}
	updata();
}
    


void  find_optimum_X()
 {
	 int i_find,j_find;
	 for(i_find=0;i_find<M;i_find++)
	 {
		 pre_optimum=f_value(X[i_find]);
		 if(!(pre_optimum Judge optimum_Z))
		 {
			 optimum_Z=pre_optimum;
			 for(j_find=0;j_find<Dim;j_find++)
				 optimum_X[j_find]=X[i_find][j_find];
		 }
	 }
 }

void find_optimum_search(double search_optimum_X[Dim])
{
	int i_fos;
	double search_optimum_Z,pre_optimum_Z;
	search_optimum_Z=f_value(search_optimum_X);
	pre_optimum_Z=f_value(X[j]);
	if(!(search_optimum_Z Judge pre_optimum_Z))
	{
		for(i_fos=0;i_fos<Dim;i_fos++)
			X[j][i_fos]=search_optimum_X[i_fos];
	}
}
	

void search(double pre_search_X[Dim])          //针对ita<0时，蚂蚁i做邻域搜索
{
	int i_s,j_s,flag=0;
	double search_X[Dim];
	double sign;
	for(i_s=0;i_s<Msearch;i_s++)
	{
		flag=0;
		for(j_s=0;j_s<Dim;j_s++)
		{
			if(ran0_1(&ran_point)>0.5)
				sign=1.0;
			else
				sign=-1.0;
			search_X[j_s]=pre_search_X[j_s]+sign*rad*ran0_1(&ran_point);
			if(!(search_X[j_s]>=border[j_s][0]&&(search_X[j_s]<=border[j_s][1])))
				flag++;
		}
		if((!flag)&&(fun_restrict(search_X)==1))
			find_optimum_search(search_X);
	}
}
void main()
{
	srand((int)time(0));            //
	int out_count,in_count;
    int k_main;
    //FILE*fp;
    //fp=fopen("Ant_Colomy.dat","w");
	for(i=0;i<M;i++)           //M=10  
	{
		taw[i]=Epsilon;
	    Dtaw[i]=0.0;
	}
	printf("初始化数据:\n");
	for(i=0;i<Dim;i++)
		optimum_X[i]=border[i][0]+ran0_1(&ran_point)*(border[i][1]-border[i][0]);
    for(i=0;i<Dim;i++)
		printf("x%d=%f\t",i+1,optimum_X[i]);
	printf("\n");
	/*if(fun_restrict(optimum_X)==1)
	{
	    optimum_Z=f_value(optimum_X);
	}
	*/
    Creat_Ant();
    for(out_count=0;out_count<Nc_out;out_count++)
	{
		for(in_count=0;in_count<Nc_in;in_count++)
		{
			for(i=0;i<M;i++)
			{
				for(j=0;j<M;j++)
				{
					updata();
					if(P[i][j]>ranP&&Dz[i][j] Judge 0)
					{
						for(k_main=0;k_main<Dim;k_main++)       //针对于ita>0时，蚂蚁i按概率从
							X[i][k_main]=X[j][k_main];          //其邻域j转移蚂蚁i的邻域
						Dtaw[j]=Dtaw[j]+Q;
					}
					else
					{
						search(X[j]);          //针对于ita<0时，做邻域搜索
					 }
				}
				for(k_main=0;k_main<M;k_main++)         //信息素更新
				{
					taw[k_main]=Row*taw[k_main]+Dtaw[k_main];    // k_main第k只蚂蚁的信息素
					Dtaw[k_main]=0.0;
				}
			}
			find_optimum_X();
      //fprintf(fp,"%f,,\t",optimum_Z);
		}
		rad=rad*Prop_R;   //搜索半径每回要改变，变为上次的一半
	}
	printf("输出最优的x值和最优的函数值：\n");
	for(i=0;i<Dim;i++)
		printf("x%d=%f\t",i+1,optimum_X[i]);
	printf("\noptimum=%f\n",optimum_Z);
	 /* fprintf(fp,"\n");
	  for(i=0;i<Dim;i++)
		  fprintf(fp,"x%d=%f,\t",i+1,optimum_X[i]);
	  fprintf(fp,"\noptimum=%f",optimum_Z);  */
}