benchmark.c

MC clerc的tribes PSO 解决TSP问题！

// ----------------------------------------------------------------------------- BENCHMARK
/*
Specific to the benchmark bed
2005-03:    http://www.ntu.edu.sg/home/EPNSugan/  (see CEC05)
*/
struct f benchmark(struct position pos,int funct,double target,int level)
{

// Position evaluation
long double A,B;
double bias[10]={0,100,200,300,400,500,600,700,800,900}; // For hybrid functions
clock_t			clock0,clock1;
int		d;
int		DD;
long double   f,f1;
long double F[10]; // Values for hybrid functions
int		h;
int		i;
int     j;
int     k;
int		m;
int shift;
long double	sum;
struct f 	total;
long double	w[10]; // Weights for hybrid functions
long double z[1000], zt[1000];
long double zz;
long double zzz;

 //-----------------------------------------

eval_f[level]=eval_f[level]+1;
eval_f_tot[level]=eval_f_tot[level]+1;

DD=pos.p.size;
total.size=pos.f.size;

if(funct<15)  // For the others (hybrid) it will be done later (by computing weights)
		for (d=0;d<DD;d++) z[d]=pos.p.x[d]-fshift[d]; // z=x-o

//goto functions; // Test no M

if(read_M==1) // + simple linear transformation (x-o)*M
				// (just one matrix, for most of problems)
{
	for (d=0;d<DD;d++) zt[d]=z[d];
/*
	if(funct==7) // Add noise
	for (d=0;d<DD;d++) 		
		for (j=0;j<DD;j++) M2[j][d]=M[j][d]*(1+0.3*fabs(alea(0,1)));
*/	
	for (d=0;d<DD;d++) // For each element
	{		
		z[d]=0;
		for (j=0;j<DD;j++) // For each line of M
		{
			//if(funct==7) zz=M2[j][d]; else 
				zz=M[j][d]; 
			z[d]=z[d]+zt[j]*zz;
		}
	}
}

/*
// Test for algorithm complexity (problem 3 = elliptic)
	clock0=clock();
  for(i=0;i<200000;i++) {f=elliptic(DD,z,0);total.f[0]=f+fbias;}
  clock1=clock();
  printf("\n T2= %f",(double)(clock1-clock0));
  scanf("%i",&i);
*/
switch (funct)
{
case 1: //Parabole () Sphere
	f=sphere(DD,z,0);
	total.f[0]=f+fbias;
	break;

case 2: //  Schwefel
case 4: // With noise

	f=0;
	for (d=0;d<DD;d++)
	{
		f1=0;
		for(j=0;j<=d;j++) f1=f1+z[j];
		f=f+f1*f1;
	}

	if(funct==4)
	{
		zz=fabs(alea_normal(0,1));
		f=f*(1+0.1*zz);
	}
	total.f[0]=f+fbias;
	break;

case 3: // Elliptic
	f=elliptic(DD,z,0);
	total.f[0]=f+fbias;
	break;

case 5: // Schwefel 2.6 (optimum on bounds)

	f=0;
	for(i=0;i<DD;i++)
	{
		zz=0;
		for(d=0;d<DD;d++) zz=zz+M[i][d]*z[d]; // Ai*(x-o)
		zz=fabs(zz); 
		if(f<zz) f=zz; // max(|Ai*(x-o)|)
	}

	total.f[0]=f+fbias;

	break;

case 6: // Rosenbrock
	for (d=0;d<DD;d++) z[d]=z[d]+1;
	f=rosenbrock(DD,z,0);
	total.f[0]=f+fbias;
	break;

case 7: // Griewank
	f=griewank(DD,z,0);
	total.f[0]=f+fbias;
	break;

case 8: // Ackley
	f=ackley(DD,z,0);
	total.f[0]=f+fbias; // Min possible value = fbias
	break;

case 9: // Rastrigin
case 10: // Rastrigin +linear transformation
	f=rastrigin(DD,z,0);
	total.f[0]=f+fbias;
	break;

case 11: // Weierstrass
	f=weierstrass(DD,z,0);
	total.f[0]=f+fbias;
	break;

case 12: // Schwefel 2.13
	f=0;
	for( i=0;i<DD;i++)
	{
		A=0; B=0;
		for(j=0;j<DD;j++)
		{
			zz=fshift[j]; // coefficient alpha
			A=A+M[i][j]*sin(zz)+M2[i][j]*cos(zz);
			zz=pos.p.x[j];
			B=B+M[i][j]*sin(zz)+M2[i][j]*cos(zz);
		}
		f=f+pow(A-B,2);
	}
	total.f[0]=f+fbias;
	break;

case 13: // Griewank(Rosenbrock) F8F2
	for (d=0;d<DD;d++) z[d]=z[d]+1;
	f=griewank_rosenbrock(DD,z,0);
	total.f[0]=f+fbias;
	break;

case 14: // Scaffer f6
	f=scaffer_f6(DD,z,0);
	total.f[0]=f+fbias;
	break;

	//------------------------ Hybrids functions
case 15: // Hybrid 1
case 16: // + linear transformations
case 17: // + noise
case 18: // Hybrid 2 (including linear transformation)
case 19:
	goto weights;
case 20:
	for (j=1;j<=DD/2;j++) fshift[2*j-1]=5; //***** A REVOIR : DD ou 1000 ?
case 21:
case 22:
case 23:
case 24:
case 25:

weights:
	// Weights

	zzz=0;
	for (i=0;i<10;i++) // 10 times 100 values in fshift
						// (one sequence of 100 for each function
						// that composes the hybrid one
	{
		j=100*i;
		for (d=0;d<DD;d++) 
		{z[d+j]=pos.p.x[d]-fshift[d+j];} // Shifts
 
		zz=0;  
		for(d=0;d<DD;d++) zz=zz+z[d+j]*z[d+j];
		zz=zz/(2*DD*BM_sigma[BM_h][i]*BM_sigma[BM_h][i]);
		w[i]=exp(-zz);
		if(w[i]>zzz) zzz=w[i]; // zzz= max(w_i)
	}
	
	 zz=1-pow(zzz,10); // Be SURE zz<1 on your computer
/*
	 if(zz>=1) 
	 {
		printf("\nbenchmark.c: zz= %.20LE",zz);
		 printf("\nset to almost_one");zz=almost_one;
		printf(" =>  %.20LE",zz);
	 }
*/


	for (i=0;i<10;i++) // Modify
		if(w[i]<zzz) w[i]=w[i]*zz;

//printf("\n w : ");for(i=0;i<10;i++) printf("%.25LE ",w[i]);

	sum=0; for (i=0;i<10;i++) sum=sum+w[i]; // Sum
//printf("\n sum %.30LE",sum);

	if(sum>0) 
		for (i=0;i<10;i++) w[i]=w[i]/sum; // Normalize
	else
		for (i=0;i<10;i++) w[i]=0.1;

//printf("\n w : ");for(i=0;i<10;i++) printf("%.25LE ",w[i]);

	// Stretch/compress
	for (i=0;i<10;i++) // For each function
	{
		j=100*i;
		for(d=0;d<DD;d++) 
		{
			z[j+d]=z[j+d]/BM_lambda[BM_h][i];
		}
	}



	// ------------- Functions

	if(funct==15) goto skip_MH;
//goto skip_MH; // TEST no matrices
		// Linear transformation with several matrices (one for each function)
	for(d=0;d<1000;d++) zt[d]=z[d]; // Temporary copy

	for (k=0;k<10;k++) // For each function
	{
		j=100*k; 
		for (d=0;d<DD;d++) 
		{		
			z[d+j]=0;
			for (i=0;i<DD;i++)
			{				
				z[j+d]=z[j+d]+zt[j+i]*MH[k][i][d];
			}
		}
	}

skip_MH:
	if(funct>17) goto hybrid2;
	
		 // Hybrids 1 --- Functions 15, 16, 17
	// Rastrigin
	shift=0;
	for(m=0;m<=1;m++)
	{
		f=rastrigin(DD,z,shift);
		F[m]=f*BM_fit[m]+bias[m];
		shift=shift+100;
	}
	
	 // Weierstrass
	for(m=2;m<=3;m++)
	{
		f=weierstrass(DD,z,shift);
		F[m]=f*BM_fit[m]+bias[m];
		shift=shift+100;
	}

	// Griewank
	for(m=4;m<=5;m++)
	{
		f=griewank(DD,z,shift);
		F[m]=f*BM_fit[m]+bias[m];
		shift=shift+100;
	}

	 // Ackley
	for(m=6;m<=7;m++)
	{
		f=ackley(DD,z,shift);
		F[m]=f*BM_fit[m]+bias[m];
		shift=shift+100;
	}
	 // Sphere
	for(m=8;m<=9;m++)
	{
		f=sphere(DD,z,shift);
		F[m]=f*BM_fit[m]+bias[m];
	}

	goto weight_f;
	//--------------------------
hybrid2:
	if(funct>20) goto hybrid3; 

			 // Hybrids 2 --- Functions 18,19, 20
// Ackley
	shift=0;
	for(m=0;m<=1;m++)
	{
		f=ackley(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}
	
	 // Rastrigin
	for(m=2;m<=3;m++)
	{
		f=rastrigin(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}

	// Sphere
	for(m=4;m<=5;m++)
	{
		f=sphere(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}

	 // Weierstrass
	for(m=6;m<=7;m++)
	{
		f=weierstrass(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}
	 // Griewank
	for(m=8;m<=9;m++)
	{
		f=griewank(DD,z,shift);
		F[m]=f+bias[m];
	}

		goto weight_f;

	//----------------
hybrid3:
		if(funct>23) goto hybrid4;

		 // Hybrids 3 --- Functions 21, 22, 23

// Scaffer f6
	shift=0;
	for(m=0;m<=1;m++)
	{
		f=scaffer_f6(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}
	
	 // Rastrigin
	for(m=2;m<=3;m++)
	{
		f=rastrigin(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}

	 // Griewank(Rosenbrock)
	for(m=4;m<=5;m++)
	{
		f=griewank_rosenbrock(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}
	 // Weierstrass
	for(m=6;m<=7;m++)
	{
		f=weierstrass(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}

		// Griewank
	for(m=8;m<=9;m++)
	{
		f=griewank(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;
	}

		goto weight_f;

hybrid4:
		 // Hybrids 4 --- Functions 24, 25
// Weierstrass
	shift=0; m=0;
	f=weierstrass(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100; m=m+1;

	 // Scaffer f6
	f=scaffer_f6(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100; m=m+1;

	 // Griewank(Rosenbrock)
		f=griewank_rosenbrock(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100; m=m+1;

	 // Ackley
		f=weierstrass(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100; m=m+1;

		// Rastrigin
		f=rastrigin(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;m=m+1;
	
	// Griewank
		f=griewank(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;m=m+1;

	// Scaffer non_continuous
		for (d=0;d<DD;d++) 
		{
			if(fabs(pos.p.x[d]-fshift[d])>=0.5)
			zt[d+shift]=floor(0.5+2*pos.p.x[d])/2;
		}
		f=scaffer_f6(DD,zt,shift);
		F[m]=f+bias[m];
		shift=shift+100;m=m+1;

	// Rastrigin non-continuous
		for (d=0;d<DD;d++) 
		{
			if(fabs(pos.p.x[d]-fshift[d])>=0.5)
			zt[d+shift]=floor(0.5+2*pos.p.x[d])/2;
		}
		f=rastrigin(DD,zt,shift);
		F[m]=f+bias[m];
		shift=shift+100;m=m+1;

	// Elliptic
		f=elliptic(DD,z,shift);
		F[m]=f+bias[m];
		shift=shift+100;m=m+1;

	// Sphere + noise
		f=griewank(DD,z,shift);
		F[m]=f*(1+0.1*alea_normal(0,1))+bias[m];

	//-----------------
weight_f:
//	printf("\n");for (i=0;i<10;i++) printf("%f ",F[i]); scanf("%i",&i);

	// Weighting function
	f=0;
	for(i=0;i<10;i++) f=f+w[i]*F[i];
	if(funct==17) f=f*(1+0.1*alea_normal(0,1));  // Noise on f
	total.f[0]=f+fbias;

	break;
} // end switch (function)


if(BM_TEST==0) total.f[0]=fabs(target-total.f[0]); 

if(problem[level].printlevel>2)
   printf("\n benchmark => %f",total.f[0]);

return total;
}