00001 #include <math.h> 00002 #include "funsoft.h" 00003 #include "cec08data.h" 00004 #include "f7f11data.h" 00005 #include <assert.h> 00006 #define abss(a) (a<0 ? (-a) : a) 00007 00008 static double pi = acos(-1.0); 00009 static double e=exp(1.0); 00010 00011 00012 tFitness Shifted_Sphere( int dim , const double* x ){ 00013 int i; 00014 tFitness z; 00015 tFitness F = 0; 00016 for(i=0;i<dim;i++){ 00017 z = x[i] - sphere[i]; 00018 F += z*z; 00019 } 00020 return F + f_bias[0]; 00021 } 00022 00023 tFitness Schwefel_Problem( int dim , const double * x ){ 00024 int i; 00025 tFitness z; 00026 tFitness F = abss(x[0]); 00027 for(i=1;i<dim;i++){ 00028 z = x[i] - schwefel[i]; 00029 F = (F > abss(z) ? F : abss(z)); 00030 } 00031 return F + f_bias[1]; 00032 } 00033 00034 tFitness Shifted_Rosenbrock( int dim , const double* x ){ 00035 int i; 00036 double z[dim]; 00037 tFitness F = 0; 00038 00039 for(i=0;i<dim;i++) z[i] = x[i] - rosenbrock[i] + 1; 00040 00041 for(i=0;i<dim-1;i++){ 00042 F = F + 100*( pow((pow(z[i],2)-z[i+1]) , 2) ) + pow((z[i]-1) , 2); 00043 } 00044 return F + f_bias[2]; 00045 } 00046 00047 tFitness Shifted_Rastrigin( int dim , const double * x ) 00048 { 00049 int i; 00050 double z; 00051 tFitness F = 0; 00052 for(i=0;i<dim;i++){ 00053 z = x[i] - rastrigin[i]; 00054 F = F + ( pow(z,2) - 10*cos(2*pi*z) + 10); 00055 } 00056 return F + f_bias[3]; 00057 } 00058 00059 tFitness Shifted_Griewank( int dim , const double * x ){ 00060 int i; 00061 tFitness z; 00062 tFitness F1 = 0; 00063 tFitness F2 = 1; 00064 for(i=0;i<dim;i++){ 00065 z = x[i] - griewank[i]; 00066 F1 = F1 + ( pow(z,2) / 4000 ); 00067 F2 = F2 * ( cos(z/sqrt(i+1))); 00068 00069 } 00070 return (F1 - F2 + 1 + f_bias[4]); 00071 } 00072 00073 tFitness Shifted_Ackley( int dim , const double* x ){ 00074 int i; 00075 double z; 00076 double Sum1 = 0; 00077 double Sum2 = 0; 00078 double F = 0; 00079 for(i=0;i<dim;i++){ 00080 z = x[i] - ackley[i]; 00081 Sum1 = Sum1 + pow(z , 2 ); 00082 Sum2 = Sum2 + cos(2*pi*z); 00083 } 00084 F = -20*exp(-0.2*sqrt(Sum1/dim)) -exp(Sum2/dim) + 20 + e + f_bias[5]; 00085 00086 return F; 00087 } 00088 00089 tFitness f_Schwefel2_22(int dim, double *s) 00090 { 00091 tFitness sum, currentGen, prod; 00092 00093 sum = 0.0; 00094 prod = 1.0; 00095 00096 for (int i = 0; i < dim; i++) 00097 { 00098 currentGen = fabs(s[i]-f7[i]); 00099 sum += currentGen; 00100 prod *= currentGen; 00101 } 00102 00103 return sum + prod; 00104 } 00105 00106 tFitness f_Schwefel2_22NoDesplazamiento(int dim, double *s) 00107 { 00108 tFitness sum, currentGen, prod; 00109 00110 sum = 0.0; 00111 prod = 1.0; 00112 00113 for (int i = 0; i < dim; i++) 00114 { 00115 currentGen = fabs(s[i]); 00116 sum += currentGen; 00117 prod *= currentGen; 00118 } 00119 00120 return sum + prod; 00121 } 00122 00123 00124 00125 tFitness f_Schwefel1_2(int dim, double *s) 00126 { 00127 tFitness Sum=0.0, Val=0.0; 00128 00129 for (int i = 0; i < dim; i++) 00130 { 00131 Val += s[i]-f8[i]; 00132 Sum += Val * Val; 00133 } 00134 00135 return Sum; 00136 } 00137 00138 tFitness f_10(double x, double y) 00139 { 00140 double p, z, t; 00141 00142 p=(x*x+y*y); 00143 00144 z=pow(p, 0.25); 00145 t=sin(50.0*pow(p, 0.1)); 00146 t=t*t+1.0; 00147 00148 return z*t; 00149 } 00150 00151 tFitness Extended_f_10(int dim, double *x) 00152 { 00153 double suma=0.0; 00154 00155 for(int i=0; i<dim-1; i++) 00156 suma+=f_10(x[i]-f9[i], x[i+1]-f9[i+1]); 00157 00158 suma+=f_10(x[dim-1]-f9[dim-1], x[0]-f9[0]); 00159 00160 return suma; 00161 } 00162 00163 tFitness Extended_f_10NoDesplazamiento(int dim, double *x) 00164 { 00165 double suma=0.0; 00166 00167 for(int i=0; i<dim-1; i++) 00168 suma+=f_10(x[i], x[i+1]); 00169 00170 suma+=f_10(x[dim-1], x[0]); 00171 00172 return suma; 00173 } 00174 00175 tFitness f_Bohachevsky(int dim, double *s) 00176 { 00177 const double PI = 3.141592653589793; 00178 tFitness sum = 0.0; 00179 int i; 00180 double currentGen; 00181 double nextGen; 00182 00183 currentGen = s[0]-f10[0]; 00184 00185 for (i = 1; i < dim; i++) 00186 { 00187 nextGen = s[i]-f10[i]; 00188 sum += currentGen * currentGen + 2.0 * nextGen * nextGen; 00189 double c1=cos(3.0 * PI * currentGen); 00190 double c2=cos(4.0 * PI * nextGen); 00191 sum += 0.7 -(0.3*c1+0.4*c2); 00192 currentGen = nextGen; 00193 } 00194 00195 return sum; 00196 } 00197 00198 tFitness f_BohachevskyNoDesplazamiento(int dim, double *s) 00199 { 00200 const double PI = 3.141592653589793; 00201 tFitness sum = 0.0; 00202 int i; 00203 double currentGen; 00204 double nextGen; 00205 00206 currentGen = s[0]; 00207 00208 for (i = 1; i < dim; i++) 00209 { 00210 nextGen = s[i]; 00211 sum += currentGen * currentGen + 2.0 * nextGen * nextGen; 00212 double c1=cos(3.0 * PI * currentGen); 00213 double c2=cos(4.0 * PI * nextGen); 00214 sum += 0.7 -(0.3*c1+0.4*c2); 00215 currentGen = nextGen; 00216 } 00217 00218 return sum; 00219 } 00220 00221 00222 tFitness f_Schaffer(int dim, double *s) 00223 { 00224 int i; 00225 tFitness sum; 00226 double aux, aux2; 00227 double currentGen, nextGen; 00228 00229 sum = 0.0; 00230 currentGen = s[0]-f11[0]; 00231 currentGen = currentGen * currentGen; 00232 00233 for (i = 1; i < dim; i++) 00234 { 00235 nextGen = s[i]-f11[i]; 00236 nextGen = nextGen * nextGen; 00237 aux = currentGen + nextGen; 00238 currentGen = nextGen; 00239 aux2 = sin(50. * pow(aux, 0.1)); 00240 sum += pow(aux, 0.25) * (aux2 * aux2 + 1.0); 00241 } 00242 00243 return sum; 00244 } 00245 00246 static void divideFunctions(int dim, double *s, double *part1, double *part2, double m, int *psize1, int *psize2) { 00247 int shared; 00248 int rest, i, total; 00249 double *partrest; 00250 00251 if (m <= 0.5) { 00252 partrest = part2; 00253 } 00254 else { 00255 partrest = part1; 00256 m = 1-m; 00257 } 00258 00259 shared = (int) floor(dim*m); 00260 rest = 2*shared; 00261 00262 for (i = 0; i < shared; i++) { 00263 part1[i] = s[i*2]; 00264 part2[i] = s[i*2+1]; 00265 } 00266 total = dim-shared; 00267 00268 for (i = 0; i < total-shared; i++) { 00269 partrest[i+shared] = s[i+rest]; 00270 } 00271 00272 *psize1 = shared; 00273 *psize2 = dim-shared; 00274 00275 if (partrest == part1) { 00276 int temp = *psize1; 00277 *psize1 = *psize2; 00278 *psize2 = temp; 00279 } 00280 } 00281 00282 tFitness f_Hybrid_12(int dim, double *s) 00283 { 00284 double part1[dim], part2[dim]; 00285 int size1, size2; 00286 tFitness f1, f2; 00287 divideFunctions(dim,s, part1, part2, 0.25, &size1, &size2); 00288 00289 f1=Extended_f_10NoDesplazamiento(size1, part1); 00290 f2=Shifted_Sphere(size2,part2)-f_bias[0]; 00291 assert(f1 >= 0); 00292 assert(f2 >= 0); 00293 00294 return f1+f2; 00295 } 00296 00297 tFitness f_Hybrid_13(int dim, double *s) 00298 { 00299 double part1[dim], part2[dim]; 00300 int size1, size2; 00301 tFitness f1, f2; 00302 00303 divideFunctions(dim,s, part1, part2, 0.25, &size1, &size2); 00304 f1=Extended_f_10NoDesplazamiento(size1, part1); 00305 f2=Shifted_Rosenbrock(size2,part2)-f_bias[2]; 00306 00307 return f1+f2; 00308 } 00309 00310 tFitness f_Hybrid_14(int dim, double *s) 00311 { 00312 double part1[dim], part2[dim]; 00313 int size1, size2; 00314 tFitness f1, f2; 00315 divideFunctions(dim,s, part1, part2, 0.25, &size1, &size2); 00316 00317 f1=Extended_f_10NoDesplazamiento(size1, part1); 00318 f2=Shifted_Rastrigin(size2, part2)-f_bias[3]; 00319 00320 return f1+f2; 00321 } 00322 00323 tFitness f_Hybrid_15(int dim, double *s) 00324 { 00325 double part1[dim], part2[dim]; 00326 double desp[dim]; 00327 int size1, size2; 00328 tFitness f1, f2; 00329 00330 for (int i = 0; i < dim; ++i) { 00331 desp[i] = s[i] - f15[i]; 00332 } 00333 00334 divideFunctions(dim, desp, part1, part2, 0.25, &size1, &size2); 00335 00336 f1=f_BohachevskyNoDesplazamiento(size1, part1); 00337 f2=f_Schwefel2_22NoDesplazamiento(size2, part2); 00338 return f1+f2; 00339 } 00340 00341 tFitness f_Hybrid_16new(int dim, double *s) 00342 { 00343 double part1[dim], part2[dim]; 00344 int size1, size2; 00345 tFitness f1, f2; 00346 divideFunctions(dim,s, part1, part2, 0.5, &size1, &size2); 00347 00348 f1=Extended_f_10NoDesplazamiento(size1, part1); 00349 assert(f1 >= 0); 00350 f2=Shifted_Sphere(size2, part2)-f_bias[0]; 00351 assert(f2 >= 0); 00352 00353 return f1+f2; 00354 } 00355 00356 tFitness f_Hybrid_17new(int dim, double *s) 00357 { 00358 double part1[dim], part2[dim]; 00359 int size1, size2; 00360 tFitness f1, f2; 00361 00362 divideFunctions(dim,s, part1, part2, 0.75, &size1, &size2); 00363 f1=Extended_f_10NoDesplazamiento(size1, part1); 00364 f2=Shifted_Rosenbrock(size2,part2)-f_bias[2]; 00365 00366 return f1+f2; 00367 } 00368 00369 tFitness f_Hybrid_18new(int dim, double *s) 00370 { 00371 double part1[dim], part2[dim]; 00372 int size1, size2; 00373 tFitness f1=0; 00374 tFitness f2=0; 00375 00376 divideFunctions(dim,s, part1, part2, 0.75, &size1, &size2); 00377 00378 f1=Extended_f_10NoDesplazamiento(size1, part1); 00379 f2=Shifted_Rastrigin(size2, part2)-f_bias[3]; 00380 assert(isfinite(f1)); 00381 assert(isfinite(f2)); 00382 00383 return f1+f2; 00384 } 00385 00386 tFitness f_Hybrid_19new(int dim, double *s) 00387 { 00388 double part1[dim], part2[dim]; 00389 int size1, size2; 00390 double desp[dim]; 00391 tFitness f1, f2; 00392 00393 for (int i = 0; i < dim; ++i) { 00394 desp[i] = s[i] - f19[i]; 00395 } 00396 00397 divideFunctions(dim, desp, part1, part2, 0.75, &size1, &size2); 00398 00399 f1=f_Bohachevsky(size1, part1); 00400 f2=f_Schwefel2_22NoDesplazamiento(size2, part2); 00401 00402 return f1+f2; 00403 }