├── KOA.m
├── main.m
├── cec14_func.cpp
├── cec17_func.cpp
├── cec20_func.cpp
├── cec14_func.mexw32
├── cec14_func.mexw64
├── cec17_func.mexw64
├── cec20_func.mexw64
├── cec22_func.mexw64
├── initialization.m
├── cec22_test_func.mexw64
├── Get_Functions_detailsCEC.m
└── cec22_func.cpp


/KOA.m:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/KOA.m


--------------------------------------------------------------------------------
/main.m:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/main.m


--------------------------------------------------------------------------------
/cec14_func.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec14_func.cpp


--------------------------------------------------------------------------------
/cec17_func.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec17_func.cpp


--------------------------------------------------------------------------------
/cec20_func.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec20_func.cpp


--------------------------------------------------------------------------------
/cec14_func.mexw32:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec14_func.mexw32


--------------------------------------------------------------------------------
/cec14_func.mexw64:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec14_func.mexw64


--------------------------------------------------------------------------------
/cec17_func.mexw64:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec17_func.mexw64


--------------------------------------------------------------------------------
/cec20_func.mexw64:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec20_func.mexw64


--------------------------------------------------------------------------------
/cec22_func.mexw64:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec22_func.mexw64


--------------------------------------------------------------------------------
/initialization.m:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/initialization.m


--------------------------------------------------------------------------------
/cec22_test_func.mexw64:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/cec22_test_func.mexw64


--------------------------------------------------------------------------------
/Get_Functions_detailsCEC.m:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redamohamed8/Kepler-Optimization-Algorithm/HEAD/Get_Functions_detailsCEC.m


--------------------------------------------------------------------------------
/cec22_func.cpp:
--------------------------------------------------------------------------------
   1 | /*
   2 |   CEC22 Test Function Suite for Single Objective Bound Constrained Numerical Optimization
   3 | 
   4 | 
   5 |   1. Run the following command in Matlab window:
   6 |   mex cec22_test_func.cpp -DWINDOWS
   7 |   2. Then you can use the test functions as the following example:
   8 |   f = cec22_func(x,func_num);
   9 |   Here x is a D*pop_size matrix.
  10 | */
  11 | 
  12 | // #include <WINDOWS.H>
  13 | #include <stdio.h>
  14 | #include <math.h>
  15 | #include <malloc.h>
  16 | #include <mex.h>
  17 | 
  18 | double *OShift,*M,*y,*z,*x_bound;
  19 | int ini_flag=0,n_flag,func_flag,*SS;
  20 | 
  21 | // #include <WINDOWS.H>
  22 | // #include <stdio.h>
  23 | // #include <math.h>
  24 | // #include <malloc.h>
  25 | 
  26 | #define INF 1.0e99
  27 | #define EPS 1.0e-14
  28 | #define E  2.7182818284590452353602874713526625
  29 | #define PI 3.1415926535897932384626433832795029
  30 | 
  31 | void ackley_func (double *, double *, int , double *,double *, int, int); /* Ackley's */
  32 | void bent_cigar_func(double *, double *, int , double *,double *, int, int); /* Discus */
  33 | void discus_func(double *, double *, int , double *,double *, int, int);  /* Bent_Cigar */
  34 | void ellips_func(double *, double *, int , double *,double *, int, int); /* Ellipsoidal */
  35 | void escaffer6_func (double *, double *, int , double *,double *, int, int); /* Expanded Scaffer¡¯s F6  */
  36 | void griewank_func (double *, double *, int , double *,double *, int, int); /* Griewank's  */
  37 | void grie_rosen_func (double *, double *, int , double *,double *, int, int); /* Griewank-Rosenbrock  */
  38 | void happycat_func (double *, double *, int , double *,double *, int, int); /* HappyCat */
  39 | void hgbat_func (double *, double *, int , double *,double *, int, int); /* HGBat  */
  40 | void rosenbrock_func (double *, double *, int , double *,double *, int, int); /* Rosenbrock's */
  41 | void rastrigin_func (double *, double *, int , double *,double *, int, int); /* Rastrigin's  */
  42 | void schwefel_func (double *, double *, int , double *,double *, int, int); /* Schwefel's */
  43 | void schaffer_F7_func (double *, double *, int , double *,double *, int, int); /* Schwefel's F7 */
  44 | void step_rastrigin_func (double *, double *, int , double *,double *, int, int); /* Noncontinuous Rastrigin's  */
  45 | void levy_func(double *, double *, int , double *,double *, int, int); /* Levy */
  46 | void zakharov_func(double *, double *, int , double *,double *, int, int); /* ZAKHAROV */
  47 | void katsuura_func (double *, double *, int , double *,double *, int, int); /* Katsuura */
  48 | 
  49 | 
  50 | 
  51 | void hf02 (double *, double *, int, double *,double *, int *,int, int); /* Hybrid Function 2 */
  52 | void hf06 (double *, double *, int, double *,double *, int *,int, int); /* Hybrid Function 6 */
  53 | void hf10 (double *, double *, int, double *,double *, int *,int, int); /* Hybrid Function 10 */
  54 | 
  55 | 
  56 | void cf01 (double *, double *, int , double *,double *, int); /* Composition Function 1 */
  57 | void cf02 (double *, double *, int , double *,double *, int); /* Composition Function 2 */
  58 | void cf06 (double *, double *, int , double *,double *, int); /* Composition Function 6 */
  59 | void cf07 (double *, double *, int , double *,double *, int); /* Composition Function 7 */
  60 | 
  61 | 
  62 | 
  63 | void shiftfunc (double*,double*,int,double*);
  64 | void rotatefunc (double*,double*,int, double*);
  65 | void sr_func (double *, double *, int, double*, double*, double, int, int); /* shift and rotate */
  66 | void asyfunc (double *, double *x, int, double);
  67 | void oszfunc (double *, double *, int);
  68 | void cf_cal(double *, double *, int, double *,double *,double *,double *,int);
  69 | 
  70 | void cec22_test_func(double *, double *,int,int,int);
  71 | 
  72 | void mexFunction (int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
  73 | {
  74 | 	int  m, n,func_num;
  75 | 	double  *f, *x;
  76 | 	if ((nrhs < 2) || (nlhs < 1))
  77 |     {
  78 | 		mexPrintf ("usage: f = cec22_func(x, func_num);\n");
  79 | 		mexErrMsgTxt ("example: f= cec22_func([3.3253000e+000, -1.2835000e+000]', 1);");
  80 |     }
  81 | 	n = mxGetM (prhs[0]);
  82 | 	if (!(n==2||n==10||n==20))
  83 |     {
  84 | 		mexPrintf ("usage: f = cec22_func(x, func_num);\n");
  85 | 		mexErrMsgTxt ("Error: Test functions are only defined for D=2,10,20.");
  86 |     }
  87 | 	m = mxGetN (prhs[0]);
  88 | 	x = mxGetPr (prhs[0]);
  89 | 	func_num= (int)*mxGetPr (prhs[1]);
  90 | 	if (func_num>12)
  91 |     {
  92 | 		mexPrintf ("usage: f = cec22_func(x, func_num);\n");
  93 | 		mexErrMsgTxt ("Error: There are only 10 test functions in this test suite!");
  94 |     }
  95 | 
  96 | 	plhs[0] = mxCreateDoubleMatrix (1, m, mxREAL);
  97 | 	f = mxGetPr (plhs[0]);
  98 | 	cec22_test_func(&x[0], &f[0], n,m,func_num);
  99 | }
 100 | 
 101 | 
 102 | void cec22_test_func(double *x, double *f, int nx, int mx,int func_num)
 103 | {
 104 | 
 105 |     int cf_num=12,i,j;
 106 |     if (func_num<1||func_num>12)
 107 | 		{
 108 | 			printf("\nError: Test function %d is not defined.\n", func_num);
 109 | 		}
 110 | 	if (ini_flag==1)
 111 | 	{
 112 | 		if ((n_flag!=nx)||(func_flag!=func_num))
 113 | 		{
 114 | 			ini_flag=0;
 115 | 		}
 116 | 	}
 117 | 
 118 | 	if (ini_flag==0)
 119 | 	{
 120 | 		FILE *fpt;
 121 | 		char FileName[256];
 122 | 		free(M);
 123 | 		free(OShift);
 124 | 		free(y);
 125 | 		free(z);
 126 | 		free(x_bound);
 127 | 		y=(double *)malloc(sizeof(double)  *  nx);
 128 | 		z=(double *)malloc(sizeof(double)  *  nx);
 129 | 		x_bound=(double *)malloc(sizeof(double)  *  nx);
 130 | 		for (i=0; i<nx; i++)
 131 | 			x_bound[i]=100.0;
 132 | 
 133 | 		if (!(nx==2||nx==10||nx==20))
 134 | 		{
 135 | 			printf("\nError: Test functions are only defined for D=2,10,20.\n");
 136 | 		}
 137 | 		if (nx==2&&(func_num==6||func_num==7||func_num==8))
 138 | 		{
 139 | 			printf("\nError:  NOT defined for D=2.\n");
 140 | 		}
 141 | 
 142 | 		/* Load Matrix M*/
 143 | 		sprintf(FileName, "input_data22/M_%d_D%d.txt", func_num,nx);
 144 | 		fpt = fopen(FileName,"r");
 145 | 		if (fpt==NULL)
 146 | 		{
 147 | 		    printf("\n Error: Cannot open M_%d_D%d.txt for reading \n",func_num,nx);
 148 | 		}
 149 | 		if (func_num<9)
 150 | 		{
 151 | 			M=(double*)malloc(nx*nx*sizeof(double));
 152 | 			if (M==NULL)
 153 | 				printf("\nError: there is insufficient memory available!\n");
 154 | 			for (i=0; i<nx*nx; i++)
 155 | 			{
 156 | 				fscanf(fpt,"%lf",&M[i]);
 157 | 			}
 158 | 		}
 159 | 		else
 160 | 		{
 161 | 			M=(double*)malloc(cf_num*nx*nx*sizeof(double));
 162 | 			if (M==NULL)
 163 | 				printf("\nError: there is insufficient memory available!\n");
 164 | 			for (i=0; i<cf_num*nx*nx; i++)
 165 | 			{
 166 | 				fscanf(fpt,"%lf",&M[i]);
 167 | 			}
 168 | 		}
 169 | 		fclose(fpt);
 170 | 
 171 | 		/* Load shift_data */
 172 | 		sprintf(FileName, "input_data22/shift_data_%d.txt", func_num);
 173 | 		fpt = fopen(FileName,"r");
 174 | 		if (fpt==NULL)
 175 | 		{
 176 | 			printf("\n Error: Cannot open shift_data_%d.txt for reading \n",func_num);
 177 | 		}
 178 | 
 179 | 		if (func_num<9)
 180 | 		{
 181 | 			OShift=(double *)malloc(nx*sizeof(double));
 182 | 			if (OShift==NULL)
 183 | 			printf("\nError: there is insufficient memory available!\n");
 184 | 			for(i=0;i<nx;i++)
 185 | 			{
 186 | 				fscanf(fpt,"%lf",&OShift[i]);
 187 | 			}
 188 | 		}
 189 | 		else
 190 | 		{
 191 |             //OShift=(double *)malloc(nx*sizeof(double));
 192 | 			OShift=(double *)malloc(nx*cf_num*sizeof(double));
 193 | 			if (OShift==NULL)
 194 | 			printf("\nError: there is insufficient memory available!\n");
 195 | 			for(i=0;i<cf_num-1;i++)
 196 | 			{
 197 | 				for (j=0;j<nx;j++)
 198 | 				{
 199 | 					fscanf(fpt,"%lf",&OShift[i*nx+j]);
 200 | 
 201 | 				}
 202 | 				fscanf(fpt,"%*[^\n]%*c");
 203 | 			}
 204 | 			for (j=0;j<nx;j++)
 205 | 			{
 206 |  				fscanf(fpt,"%lf",&OShift[nx*(cf_num-1)+j]);
 207 | 
 208 | 			}
 209 | 
 210 | 		}
 211 | 		fclose(fpt);
 212 | 
 213 | 
 214 | 		/* Load Shuffle_data */
 215 | 
 216 | 		if (func_num>=6&&func_num<=8)
 217 | 		{
 218 | 			sprintf(FileName, "input_data22/shuffle_data_%d_D%d.txt", func_num, nx);
 219 | 			fpt = fopen(FileName,"r");
 220 | 			if (fpt==NULL)
 221 | 			{
 222 | 				printf("\n Error: Cannot open shuffle_data_%d_D%d.txt for reading \n", func_num, nx);
 223 | 			}
 224 | 			SS=(int *)malloc(nx*sizeof(int));
 225 | 			if (SS==NULL)
 226 | 				printf("\nError: there is insufficient memory available!\n");
 227 | 			for(i=0;i<nx;i++)
 228 | 			{
 229 | 				fscanf(fpt,"%d",&SS[i]);
 230 | 			}
 231 | 			fclose(fpt);
 232 | 		}
 233 | 
 234 | 		n_flag=nx;
 235 | 		func_flag=func_num;
 236 | 		ini_flag=1;
 237 | 		//printf("Function has been initialized!\n");
 238 | 	}
 239 | 
 240 | 
 241 | 	for (i = 0; i < mx; i++)
 242 | 	{
 243 | 		switch(func_num)
 244 | 		{
 245 | 		case 1:
 246 | 			zakharov_func(&x[i*nx],&f[i],nx,OShift,M,1,1);
 247 | 			f[i]+=300.0;
 248 | 			break;
 249 | 		case 2:
 250 | 			rosenbrock_func(&x[i*nx],&f[i],nx,OShift,M,1,1);
 251 | 			f[i]+=400.0;
 252 | 			break;
 253 | 		case 3:
 254 | 			schaffer_F7_func(&x[i*nx],&f[i],nx,OShift,M,1,1);
 255 | 			f[i]+=600.0;
 256 | 			break;
 257 | 		case 4:
 258 |             step_rastrigin_func(&x[i*nx],&f[i],nx,OShift,M,1,1);
 259 | 			f[i]+=800.0;
 260 | 			break;
 261 | 		case 5:
 262 | 			levy_func(&x[i*nx],&f[i],nx,OShift,M,1,1);
 263 | 			f[i]+=900.0;
 264 | 			break;
 265 | 		case 6:
 266 | 			hf02(&x[i*nx],&f[i],nx,OShift,M,SS,1,1);
 267 | 			f[i]+=1800.0;
 268 | 			break;
 269 | 		case 7:
 270 | 			hf10(&x[i*nx],&f[i],nx,OShift,M,SS,1,1);
 271 | 			f[i]+=2000.0;
 272 | 			break;
 273 | 		case 8:
 274 | 			hf06(&x[i*nx],&f[i],nx,OShift,M,SS,1,1);
 275 | 			f[i]+=2200.0;
 276 | 			break;
 277 | 		case 9:
 278 | 			cf01(&x[i*nx],&f[i],nx,OShift,M,1);
 279 | 			f[i]+=2300.0;
 280 | 			break;
 281 | 		case 10:
 282 | 			cf02(&x[i*nx],&f[i],nx,OShift,M,1);
 283 | 			f[i]+=2400.0;
 284 | 			break;
 285 |         case 11:
 286 |             cf06(&x[i*nx],&f[i],nx,OShift,M,1);
 287 | 			f[i]+=2600.0;
 288 | 			break;
 289 |         case 12:
 290 |             cf07(&x[i*nx],&f[i],nx,OShift,M,1);
 291 | 			f[i]+=2700.0;
 292 | 			break;
 293 | 		default:
 294 | 			printf("\nError: There are only 10 test functions in this test suite!\n");
 295 | 			f[i] = 0.0;
 296 | 			break;
 297 | 		}
 298 | 
 299 | 	}
 300 | 
 301 | }
 302 | 
 303 | 
 304 | 
 305 | void ellips_func (double *x, double *f, int nx, double *Os,double *Mr, int s_flag, int r_flag) /* Ellipsoidal */
 306 | {
 307 |     int i;
 308 | 	f[0] = 0.0;
 309 | 	sr_func (x, z, nx, Os, Mr,1.0, s_flag, r_flag); /* shift and rotate */
 310 | 	for (i=0; i<nx; i++)
 311 | 	{
 312 |        f[0] += pow(10.0,6.0*i/(nx-1))*z[i]*z[i];
 313 | 	}
 314 | }
 315 | 
 316 | 
 317 | 
 318 | void bent_cigar_func (double *x, double *f, int nx, double *Os,double *Mr, int s_flag, int r_flag) /* Bent_Cigar */
 319 | {
 320 |     int i;
 321 | 	sr_func (x, z, nx, Os, Mr,1.0, s_flag, r_flag); /* shift and rotate */
 322 | 	f[0] = z[0]*z[0];
 323 | 	for (i=1; i<nx; i++)
 324 | 	{
 325 | 		f[0] += pow(10.0,6.0)*z[i]*z[i];
 326 | 	}
 327 | 
 328 | }
 329 | 
 330 | void discus_func (double *x, double *f, int nx, double *Os,double *Mr, int s_flag, int r_flag) /* Discus */
 331 | {
 332 |     int i;
 333 | 	sr_func (x, z, nx, Os, Mr,1.0, s_flag, r_flag); /* shift and rotate */
 334 | 	f[0] = pow(10.0,6.0)*z[0]*z[0];
 335 | 	for (i=1; i<nx; i++)
 336 | 	{
 337 | 		f[0] += z[i]*z[i];
 338 | 	}
 339 | }
 340 | 
 341 | 
 342 | 
 343 | void rosenbrock_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Rosenbrock's */
 344 | {
 345 |     int i;
 346 | 	double tmp1,tmp2;
 347 | 	f[0] = 0.0;
 348 | 	sr_func (x, z, nx, Os, Mr, 2.048/100.0, s_flag, r_flag); /* shift and rotate */
 349 | 	z[0] += 1.0;//shift to orgin
 350 | 	for (i=0; i<nx-1; i++)
 351 | 	{
 352 | 		z[i+1] += 1.0;//shift to orgin
 353 | 		tmp1=z[i]*z[i]-z[i+1];
 354 | 		tmp2=z[i]-1.0;
 355 | 		f[0] += 100.0*tmp1*tmp1 +tmp2*tmp2;
 356 | 	}
 357 | }
 358 | 
 359 | 
 360 | 
 361 | void ackley_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Ackley's  */
 362 | {
 363 |     int i;
 364 |     double sum1, sum2;
 365 |     sum1 = 0.0;
 366 |     sum2 = 0.0;
 367 | 
 368 | 	sr_func (x, z, nx, Os, Mr, 1.0, s_flag, r_flag); /* shift and rotate */
 369 | 
 370 | 	for (i=0; i<nx; i++)
 371 | 	{
 372 | 		sum1 += z[i]*z[i];
 373 | 		sum2 += cos(2.0*PI*z[i]);
 374 | 	}
 375 | 	sum1 = -0.2*sqrt(sum1/nx);
 376 | 	sum2 /= nx;
 377 | 		f[0] =  E - 20.0*exp(sum1) - exp(sum2) +20.0;
 378 | }
 379 | 
 380 | 
 381 | 
 382 | 
 383 | void griewank_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Griewank's  */
 384 | {
 385 |     int i;
 386 |     double s, p;
 387 |     s = 0.0;
 388 |     p = 1.0;
 389 | 
 390 | 	sr_func (x, z, nx, Os, Mr, 600.0/100.0, s_flag, r_flag); /* shift and rotate */
 391 | 
 392 | 	for (i=0; i<nx; i++)
 393 | 	{
 394 | 		s += z[i]*z[i];
 395 | 		p *= cos(z[i]/sqrt(1.0+i));
 396 | 	}
 397 | 	f[0] = 1.0 + s/4000.0 - p;
 398 | }
 399 | 
 400 | void rastrigin_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Rastrigin's  */
 401 | {
 402 |     int i;
 403 | 	f[0] = 0.0;
 404 | 
 405 | 	sr_func (x, z, nx, Os, Mr, 5.12/100.0, s_flag, r_flag); /* shift and rotate */
 406 | 
 407 | 	for (i=0; i<nx; i++)
 408 | 	{
 409 | 		f[0] += (z[i]*z[i] - 10.0*cos(2.0*PI*z[i]) + 10.0);
 410 | 	}
 411 | }
 412 | 
 413 | 
 414 | 
 415 | void schwefel_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Schwefel's  */
 416 | {
 417 |     int i;
 418 | 	double tmp;
 419 | 	f[0]=0.0;
 420 | 
 421 | 	sr_func (x, z, nx, Os, Mr, 1000.0/100.0, s_flag, r_flag); /* shift and rotate */
 422 | 
 423 | 	for (i=0; i<nx; i++)
 424 | 	{
 425 | 		z[i] += 4.209687462275036e+002;
 426 | 		if (z[i]>500)
 427 | 		{
 428 | 			f[0]-=(500.0-fmod(z[i],500))*sin(pow(500.0-fmod(z[i],500),0.5));
 429 | 			tmp=(z[i]-500.0)/100;
 430 | 			f[0]+= tmp*tmp/nx;
 431 | 		}
 432 | 		else if (z[i]<-500)
 433 | 		{
 434 | 			f[0]-=(-500.0+fmod(fabs(z[i]),500))*sin(pow(500.0-fmod(fabs(z[i]),500),0.5));
 435 | 			tmp=(z[i]+500.0)/100;
 436 | 			f[0]+= tmp*tmp/nx;
 437 | 		}
 438 | 		else
 439 | 			f[0]-=z[i]*sin(pow(fabs(z[i]),0.5));
 440 | 		}
 441 | 		f[0] +=4.189828872724338e+002*nx;
 442 | 
 443 | }
 444 | 
 445 | 
 446 | 
 447 | void grie_rosen_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Griewank-Rosenbrock  */
 448 | {
 449 |     int i;
 450 |     double temp,tmp1,tmp2;
 451 |     f[0]=0.0;
 452 | 
 453 | 	sr_func (x, z, nx, Os, Mr, 5.0/100.0, s_flag, r_flag); /* shift and rotate */
 454 | 
 455 | 	z[0] += 1.0;//shift to orgin
 456 |     for (i=0; i<nx-1; i++)
 457 |     {
 458 | 		z[i+1] += 1.0;//shift to orgin
 459 | 		tmp1 = z[i]*z[i]-z[i+1];
 460 | 		tmp2 = z[i]-1.0;
 461 |         temp = 100.0*tmp1*tmp1 + tmp2*tmp2;
 462 |          f[0] += (temp*temp)/4000.0 - cos(temp) + 1.0;
 463 |     }
 464 | 	tmp1 = z[nx-1]*z[nx-1]-z[0];
 465 | 	tmp2 = z[nx-1]-1.0;
 466 |     temp = 100.0*tmp1*tmp1 + tmp2*tmp2;;
 467 |     f[0] += (temp*temp)/4000.0 - cos(temp) + 1.0 ;
 468 | }
 469 | 
 470 | 
 471 | void escaffer6_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Expanded Scaffer��s F6  */
 472 | {
 473 |     int i;
 474 |     double temp1, temp2;
 475 | 
 476 | 	sr_func (x, z, nx, Os, Mr, 1.0, s_flag, r_flag); /* shift and rotate */
 477 | 
 478 |     f[0] = 0.0;
 479 |     for (i=0; i<nx-1; i++)
 480 |     {
 481 |         temp1 = sin(sqrt(z[i]*z[i]+z[i+1]*z[i+1]));
 482 | 		temp1 =temp1*temp1;
 483 |         temp2 = 1.0 + 0.001*(z[i]*z[i]+z[i+1]*z[i+1]);
 484 |         f[0] += 0.5 + (temp1-0.5)/(temp2*temp2);
 485 |     }
 486 |     temp1 = sin(sqrt(z[nx-1]*z[nx-1]+z[0]*z[0]));
 487 | 	temp1 =temp1*temp1;
 488 |     temp2 = 1.0 + 0.001*(z[nx-1]*z[nx-1]+z[0]*z[0]);
 489 |     f[0] += 0.5 + (temp1-0.5)/(temp2*temp2);
 490 | }
 491 | 
 492 | void happycat_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* HappyCat, provdided by Hans-Georg Beyer (HGB) */
 493 | /* original global optimum: [-1,-1,...,-1] */
 494 | {
 495 | 	int i;
 496 | 	double alpha,r2,sum_z;
 497 | 	alpha=1.0/8.0;
 498 | 
 499 | 	sr_func (x, z, nx, Os, Mr, 5.0/100.0, s_flag, r_flag); /* shift and rotate */
 500 | 
 501 | 	r2 = 0.0;
 502 | 	sum_z=0.0;
 503 |     for (i=0; i<nx; i++)
 504 |     {
 505 | 		z[i]=z[i]-1.0;//shift to orgin
 506 |         r2 += z[i]*z[i];
 507 | 		sum_z += z[i];
 508 |     }
 509 |     f[0]=pow(fabs(r2-nx),2*alpha) + (0.5*r2 + sum_z)/nx + 0.5;
 510 | }
 511 | 
 512 | void hgbat_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* HGBat, provdided by Hans-Georg Beyer (HGB)*/
 513 | /* original global optimum: [-1,-1,...,-1] */
 514 | {
 515 | 	int i;
 516 | 	double alpha,r2,sum_z;
 517 | 	alpha=1.0/4.0;
 518 | 
 519 | 	sr_func (x, z, nx, Os, Mr, 5.0/100.0, s_flag, r_flag); /* shift and rotate */
 520 | 
 521 | 	r2 = 0.0;
 522 | 	sum_z=0.0;
 523 |     for (i=0; i<nx; i++)
 524 |     {
 525 | 		z[i]=z[i]-1.0;//shift to orgin
 526 |         r2 += z[i]*z[i];
 527 | 		sum_z += z[i];
 528 |     }
 529 |     f[0]=pow(fabs(pow(r2,2.0)-pow(sum_z,2.0)),2*alpha) + (0.5*r2 + sum_z)/nx + 0.5;
 530 | }
 531 | 
 532 | 
 533 | void schaffer_F7_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Schwefel's 1.2  */
 534 | {
 535 |     int i;
 536 | 	double tmp;
 537 |     f[0] = 0.0;
 538 | 	sr_func (x, z, nx, Os, Mr, 1.0, s_flag, r_flag); /* shift and rotate */
 539 | 	for (i=0; i<nx-1; i++)
 540 | 	{
 541 | 		z[i]=pow(y[i]*y[i]+y[i+1]*y[i+1],0.5);
 542 | 		tmp=sin(50.0*pow(z[i],0.2));
 543 | 		f[0] += pow(z[i],0.5)+pow(z[i],0.5)*tmp*tmp ;
 544 | 	}
 545 | 	f[0] = f[0]*f[0]/(nx-1)/(nx-1);
 546 | }
 547 | 
 548 | void step_rastrigin_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Noncontinuous Rastrigin's  */
 549 | {
 550 |     int i;
 551 | 	f[0]=0.0;
 552 | 	for (i=0; i<nx; i++)
 553 | 	{
 554 | 		if (fabs(y[i]-Os[i])>0.5)
 555 | 		y[i]=Os[i]+floor(2*(y[i]-Os[i])+0.5)/2;
 556 | 	}
 557 | 
 558 | 	sr_func (x, z, nx, Os, Mr, 5.12/100.0, s_flag, r_flag); /* shift and rotate */
 559 | 
 560 | 	for (i=0; i<nx; i++)
 561 | 	{
 562 | 		f[0] += (z[i]*z[i] - 10.0*cos(2.0*PI*z[i]) + 10.0);
 563 | 	}
 564 | }
 565 | 
 566 | void levy_func (double *x, double *f, int nx, double *Os,double *Mr, int s_flag, int r_flag) /* Levy */
 567 | {
 568 |     int i;
 569 | 	f[0] = 0.0;
 570 | 	sr_func (x, z, nx, Os, Mr,1.0, s_flag, r_flag); /* shift and rotate */
 571 | 
 572 | 	double *w;
 573 | 	w=(double *)malloc(sizeof(double)  *  nx);
 574 | 
 575 | 	double sum1= 0.0;
 576 | 	for (i=0; i<nx; i++)
 577 | 	{
 578 | 	   w[i] = 1.0 + (z[i] - 0.0)/4.0;
 579 | 	}
 580 | 
 581 | 	double term1 = pow((sin(PI*w[0])),2);
 582 | 	double term3 = pow((w[nx-1]-1),2) * (1+pow((sin(2*PI*w[nx-1])),2));
 583 | 
 584 | 	double sum = 0.0;
 585 | 
 586 | 	for (i=0; i<nx-1; i++)
 587 | 	{
 588 | 		double wi = w[i];
 589 |         double newv = pow((wi-1),2) * (1+10*pow((sin(PI*wi+1)),2));
 590 | 		sum = sum + newv;
 591 | 	}
 592 | 
 593 | 	f[0] = term1 + sum + term3;
 594 | 	free(w);   // ADD THIS LINE to free memory! Thanks for Dr. Janez
 595 | }
 596 | 
 597 | void zakharov_func (double *x, double *f, int nx, double *Os,double *Mr, int s_flag, int r_flag) /* zakharov */
 598 | {
 599 | 	int i;
 600 | 	sr_func (x, z, nx, Os, Mr,1.0, s_flag, r_flag); // shift and rotate
 601 | 	f[0] = 0.0;
 602 | 	double sum1 = 0.0;
 603 | 	double sum2 = 0.0;
 604 | 	for (i=0; i<nx; i++)
 605 | 	{
 606 | 		double xi = z[i];
 607 | 		sum1 = sum1 + pow(xi,2);
 608 | 		sum2 = sum2 + 0.5*(i+1)*xi;
 609 | 	}
 610 | 
 611 | 	f[0] = sum1 + pow(sum2,2) + pow(sum2,4);
 612 | }
 613 | 
 614 | void katsuura_func (double *x, double *f, int nx, double *Os,double *Mr,int s_flag, int r_flag) /* Katsuura  */
 615 | {
 616 |     int i,j;
 617 | 	double temp,tmp1,tmp2,tmp3;
 618 | 	f[0]=1.0;
 619 | 	tmp3=pow(1.0*nx,1.2);
 620 | 
 621 | 	sr_func (x, z, nx, Os, Mr, 5.0/100.0, s_flag, r_flag); /* shift and rotate */
 622 | 
 623 |     for (i=0; i<nx; i++)
 624 | 	{
 625 | 		temp=0.0;
 626 | 		for (j=1; j<=32; j++)
 627 | 		{
 628 | 			tmp1=pow(2.0,j);
 629 | 			tmp2=tmp1*z[i];
 630 | 			temp += fabs(tmp2-floor(tmp2+0.5))/tmp1;
 631 | 		}
 632 | 		f[0] *= pow(1.0+(i+1)*temp,10.0/tmp3);
 633 |     }
 634 | 	tmp1=10.0/nx/nx;
 635 |     f[0]=f[0]*tmp1-tmp1;
 636 | 
 637 | }
 638 | 
 639 | 
 640 | void hf02 (double *x, double *f, int nx, double *Os,double *Mr,int *S,int s_flag,int r_flag) /* Hybrid Function 2 */
 641 | {
 642 | 	int i,tmp,cf_num=3;
 643 | 	double fit[3];
 644 | 	int G[3],G_nx[3];
 645 | 	double Gp[3]={0.4,0.4,0.2};
 646 | 
 647 | 	tmp=0;
 648 | 	for (i=0; i<cf_num-1; i++)
 649 | 	{
 650 | 		G_nx[i] = ceil(Gp[i]*nx);
 651 | 		tmp += G_nx[i];
 652 | 	}
 653 | 	G_nx[cf_num-1]=nx-tmp;
 654 | 
 655 | 	G[0]=0;
 656 | 	for (i=1; i<cf_num; i++)
 657 | 	{
 658 | 		G[i] = G[i-1]+G_nx[i-1];
 659 | 	}
 660 | 
 661 | 	sr_func (x, z, nx, Os, Mr, 1.0, s_flag, r_flag); /* shift and rotate */
 662 | 
 663 | 	for (i=0; i<nx; i++)
 664 | 	{
 665 | 		y[i]=z[S[i]-1];
 666 | 	}
 667 | 	i=0;
 668 | 	bent_cigar_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 669 | 	i=1;
 670 | 	hgbat_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 671 | 	i=2;
 672 | 	rastrigin_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 673 | 
 674 | 	f[0]=0.0;
 675 | 	for(i=0;i<cf_num;i++)
 676 | 	{
 677 | 		f[0] += fit[i];
 678 | 	}
 679 | }
 680 | 
 681 | void hf10 (double *x, double *f, int nx, double *Os,double *Mr,int *S,int s_flag,int r_flag) /* Hybrid Function 6 */
 682 | {
 683 | 	int i,tmp,cf_num=6;
 684 | 	double fit[6];
 685 | 	int G[6],G_nx[6];
 686 | 	double Gp[6]={0.1,0.2,0.2,0.2,0.1,0.2};
 687 | 
 688 | 	tmp=0;
 689 | 	for (i=0; i<cf_num-1; i++)
 690 | 	{
 691 | 		G_nx[i] = ceil(Gp[i]*nx);
 692 | 		tmp += G_nx[i];
 693 | 	}
 694 | 	G_nx[cf_num-1]=nx-tmp;
 695 | 
 696 | 	G[0]=0;
 697 | 	for (i=1; i<cf_num; i++)
 698 | 	{
 699 | 		G[i] = G[i-1]+G_nx[i-1];
 700 | 	}
 701 | 
 702 | 	sr_func (x, z, nx, Os, Mr, 1.0, s_flag, r_flag); /* shift and rotate */
 703 | 
 704 | 	for (i=0; i<nx; i++)
 705 | 	{
 706 | 		y[i]=z[S[i]-1];
 707 | 	}
 708 | 
 709 | 	i=0;
 710 | 	hgbat_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 711 | 	i=1;
 712 | 	katsuura_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 713 | 	i=2;
 714 | 	ackley_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 715 | 	i=3;
 716 | 	rastrigin_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 717 | 	i=4;
 718 | 	schwefel_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 719 | 	i=5;
 720 | 	schaffer_F7_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 721 | 
 722 | 	f[0]=0.0;
 723 | 	for(i=0;i<cf_num;i++)
 724 | 	{
 725 | 		f[0] += fit[i];
 726 | 	}
 727 | }
 728 | 
 729 | void hf06 (double *x, double *f, int nx, double *Os,double *Mr,int *S,int s_flag,int r_flag) /* Hybrid Function 6 */
 730 | {
 731 | 	int i,tmp,cf_num=5;
 732 | 	double fit[5];
 733 | 	int G[5],G_nx[5];
 734 | 	double Gp[5]={0.3,0.2,0.2,0.1,0.2};
 735 | 
 736 | 	tmp=0;
 737 | 	for (i=0; i<cf_num-1; i++)
 738 | 	{
 739 | 		G_nx[i] = ceil(Gp[i]*nx);
 740 | 		tmp += G_nx[i];
 741 | 	}
 742 | 	G_nx[cf_num-1]=nx-tmp;
 743 | 
 744 | 	G[0]=0;
 745 | 	for (i=1; i<cf_num; i++)
 746 | 	{
 747 | 		G[i] = G[i-1]+G_nx[i-1];
 748 | 	}
 749 | 
 750 | 	sr_func (x, z, nx, Os, Mr, 1.0, s_flag, r_flag); /* shift and rotate */
 751 | 
 752 | 	for (i=0; i<nx; i++)
 753 | 	{
 754 | 		y[i]=z[S[i]-1];
 755 | 	}
 756 | 	i=0;
 757 | 	katsuura_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 758 | 	i=1;
 759 | 	happycat_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 760 | 	i=2;
 761 | 	grie_rosen_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 762 | 	i=3;
 763 | 	schwefel_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 764 | 	i=4;
 765 | 	ackley_func(&y[G[i]],&fit[i],G_nx[i],Os,Mr,0,0);
 766 | 	f[0]=0.0;
 767 | 	for(i=0;i<cf_num;i++)
 768 | 	{
 769 | 		f[0] += fit[i];
 770 | 	}
 771 | }
 772 | 
 773 | void cf01 (double *x, double *f, int nx, double *Os,double *Mr,int r_flag) /* Composition Function 1 */
 774 | {
 775 | 	int i,cf_num=5;
 776 | 	double fit[5];
 777 | 	double delta[5] = {10, 20, 30, 40, 50};
 778 | 	double bias[5] = {0, 200, 300, 100, 400};
 779 | 
 780 | 	i=0;
 781 | 	rosenbrock_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 782 | 	fit[i]=10000*fit[i]/1e+4;
 783 | 	i=1;
 784 | 	ellips_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 785 | 	fit[i]=10000*fit[i]/1e+10;
 786 | 	i=2;
 787 | 	bent_cigar_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 788 | 	fit[i]=10000*fit[i]/1e+30;
 789 | 	i=3;
 790 | 	discus_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 791 | 	fit[i]=10000*fit[i]/1e+10;
 792 | 	i=4;
 793 | 	ellips_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,0);
 794 | 	fit[i]=10000*fit[i]/1e+10;
 795 | 	cf_cal(x, f, nx, Os, delta,bias,fit,cf_num);
 796 | }
 797 | 
 798 | void cf02 (double *x, double *f, int nx, double *Os,double *Mr,int r_flag) /* Composition Function 2 */
 799 | {
 800 | 	int i,cf_num=3;
 801 | 	double fit[3];
 802 | 	double delta[3] = {20,10,10};
 803 | 	double bias[3] = {0, 200, 100};
 804 | 
 805 | 	i=0;
 806 | 	schwefel_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,0);
 807 | 	i=1;
 808 | 	rastrigin_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 809 | 	i=2;
 810 | 	hgbat_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 811 | 	cf_cal(x, f, nx, Os, delta,bias,fit,cf_num);
 812 | }
 813 | 
 814 | 
 815 | void cf06 (double *x, double *f, int nx, double *Os,double *Mr,int r_flag) /* Composition Function 4 */
 816 | {
 817 | 	int i,cf_num=5;
 818 | 	double fit[5];
 819 | 	double delta[5] = {20,20,30,30,20};
 820 | 	double bias[5] = {0, 200, 300, 400, 200};
 821 | 	i=0;
 822 | 	escaffer6_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 823 | 	fit[i]=10000*fit[i]/2e+7;
 824 | 	i=1;
 825 | 	schwefel_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 826 | 	i=2;
 827 | 	griewank_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 828 | 	fit[i]=1000*fit[i]/100;
 829 | 	i=3;
 830 | 	rosenbrock_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 831 | 	i=4;
 832 | 	rastrigin_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 833 | 	fit[i]=10000*fit[i]/1e+3;
 834 | 	cf_cal(x, f, nx, Os, delta,bias,fit,cf_num);
 835 | }
 836 | 
 837 | void cf07 (double *x, double *f, int nx, double *Os,double *Mr,int r_flag) /* Composition Function 4 */
 838 | {
 839 | 	int i,cf_num=6;
 840 | 	double fit[6];
 841 | 	double delta[6] = {10,20,30,40,50,60};
 842 | 	double bias[6] = {0, 300, 500, 100, 400, 200};
 843 | 	i=0;
 844 | 	hgbat_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 845 | 	fit[i]=10000*fit[i]/1000;
 846 | 	i=1;
 847 | 	rastrigin_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 848 | 	fit[i]=10000*fit[i]/1e+3;
 849 | 	i=2;
 850 | 	schwefel_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 851 | 	fit[i]=10000*fit[i]/4e+3;
 852 | 	i=3;
 853 | 	bent_cigar_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 854 | 	fit[i]=10000*fit[i]/1e+30;
 855 | 	i=4;
 856 | 	ellips_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 857 | 	fit[i]=10000*fit[i]/1e+10;
 858 | 	i=5;
 859 | 	escaffer6_func(x,&fit[i],nx,&Os[i*nx],&Mr[i*nx*nx],1,r_flag);
 860 | 	fit[i]=10000*fit[i]/2e+7;
 861 | 	cf_cal(x, f, nx, Os, delta,bias,fit,cf_num);
 862 | }
 863 | 
 864 | 
 865 | 
 866 | 
 867 | void shiftfunc (double *x, double *xshift, int nx,double *Os)
 868 | {
 869 | 	int i;
 870 |     for (i=0; i<nx; i++)
 871 |     {
 872 |         xshift[i]=x[i]-Os[i];
 873 |     }
 874 | }
 875 | 
 876 | void rotatefunc (double *x, double *xrot, int nx,double *Mr)
 877 | {
 878 | 	int i,j;
 879 |     for (i=0; i<nx; i++)
 880 |     {
 881 |         xrot[i]=0;
 882 | 			for (j=0; j<nx; j++)
 883 | 			{
 884 | 				xrot[i]=xrot[i]+x[j]*Mr[i*nx+j];
 885 | 			}
 886 |     }
 887 | }
 888 | 
 889 | void sr_func (double *x, double *sr_x, int nx, double *Os,double *Mr, double sh_rate, int s_flag,int r_flag) /* shift and rotate */
 890 | {
 891 | 	int i;
 892 | 	if (s_flag==1)
 893 | 	{
 894 | 		if (r_flag==1)
 895 | 		{
 896 | 			shiftfunc(x, y, nx, Os);
 897 | 			for (i=0; i<nx; i++)//shrink to the orginal search range
 898 | 			{
 899 | 				y[i]=y[i]*sh_rate;
 900 | 			}
 901 | 			rotatefunc(y, sr_x, nx, Mr);
 902 | 		}
 903 | 		else
 904 | 		{
 905 | 			shiftfunc(x, sr_x, nx, Os);
 906 | 			for (i=0; i<nx; i++)//shrink to the orginal search range
 907 | 			{
 908 | 				sr_x[i]=sr_x[i]*sh_rate;
 909 | 			}
 910 | 		}
 911 | 	}
 912 | 	else
 913 | 	{
 914 | 
 915 | 		if (r_flag==1)
 916 | 		{
 917 | 			for (i=0; i<nx; i++)//shrink to the orginal search range
 918 | 			{
 919 | 				y[i]=x[i]*sh_rate;
 920 | 			}
 921 | 			rotatefunc(y, sr_x, nx, Mr);
 922 | 		}
 923 | 		else
 924 | 		for (i=0; i<nx; i++)//shrink to the orginal search range
 925 | 		{
 926 | 			sr_x[i]=x[i]*sh_rate;
 927 | 		}
 928 | 	}
 929 | }
 930 | 
 931 | void asyfunc (double *x, double *xasy, int nx, double beta)
 932 | {
 933 | 	int i;
 934 |     for (i=0; i<nx; i++)
 935 |     {
 936 | 		if (x[i]>0)
 937 |         xasy[i]=pow(x[i],1.0+beta*i/(nx-1)*pow(x[i],0.5));
 938 |     }
 939 | }
 940 | 
 941 | void oszfunc (double *x, double *xosz, int nx)
 942 | {
 943 | 	int i,sx;
 944 | 	double c1,c2,xx;
 945 |     for (i=0; i<nx; i++)
 946 |     {
 947 | 		if (i==0||i==nx-1)
 948 |         {
 949 | 			if (x[i]!=0)
 950 | 				xx=log(fabs(x[i]));
 951 | 			if (x[i]>0)
 952 | 			{
 953 | 				c1=10;
 954 | 				c2=7.9;
 955 | 			}
 956 | 			else
 957 | 			{
 958 | 				c1=5.5;
 959 | 				c2=3.1;
 960 | 			}
 961 | 			if (x[i]>0)
 962 | 				sx=1;
 963 | 			else if (x[i]==0)
 964 | 				sx=0;
 965 | 			else
 966 | 				sx=-1;
 967 | 			xosz[i]=sx*exp(xx+0.049*(sin(c1*xx)+sin(c2*xx)));
 968 | 		}
 969 | 		else
 970 | 			xosz[i]=x[i];
 971 |     }
 972 | }
 973 | 
 974 | 
 975 | void cf_cal(double *x, double *f, int nx, double *Os,double * delta,double * bias,double * fit, int cf_num)
 976 | {
 977 | 	int i,j;
 978 | 	double *w;
 979 | 	double w_max=0,w_sum=0;
 980 | 	w=(double *)malloc(cf_num * sizeof(double));
 981 | 	for (i=0; i<cf_num; i++)
 982 | 	{
 983 | 		fit[i]+=bias[i];
 984 | 		w[i]=0;
 985 | 		for (j=0; j<nx; j++)
 986 | 		{
 987 | 			w[i]+=pow(x[j]-Os[i*nx+j],2.0);
 988 | 		}
 989 | 		if (w[i]!=0)
 990 | 			w[i]=pow(1.0/w[i],0.5)*exp(-w[i]/2.0/nx/pow(delta[i],2.0));
 991 | 		else
 992 | 			w[i]=INF;
 993 | 		if (w[i]>w_max)
 994 | 			w_max=w[i];
 995 | 	}
 996 | 
 997 | 	for (i=0; i<cf_num; i++)
 998 | 	{
 999 | 		w_sum=w_sum+w[i];
1000 | 	}
1001 | 	if(w_max==0)
1002 | 	{
1003 | 		for (i=0; i<cf_num; i++)
1004 | 			w[i]=1;
1005 | 		w_sum=cf_num;
1006 | 	}
1007 | 	f[0] = 0.0;
1008 |     for (i=0; i<cf_num; i++)
1009 |     {
1010 | 		f[0]=f[0]+w[i]/w_sum*fit[i];
1011 |     }
1012 | 	free(w);
1013 | }
1014 | 
1015 | 


--------------------------------------------------------------------------------