00001
00020
00021
00022
00023
00024 # include <stdio.h>
00025 # include <stdlib.h>
00026 # include <math.h>
00027
00028 # include "global.h"
00029 # include "sub.h"
00030 # include "rand.h"
00031
00032 long double calc_benchmark_func_f1(long double *x)
00033 {
00034 long double res;
00035 transform (x, 0);
00036 basic_f[0] = calc_sphere (trans_x);
00037 res = basic_f[0] + bias[0];
00038 return (res);
00039 }
00040
00041 long double calc_benchmark_func_f2(long double *x)
00042 {
00043 long double res;
00044 transform (x, 0);
00045 basic_f[0] = calc_schwefel (trans_x);
00046 res = basic_f[0] + bias[0];
00047 return (res);
00048 }
00049
00050 long double calc_benchmark_func_f3(long double *x)
00051 {
00052 int i;
00053 long double res;
00054 transform (x, 0);
00055 basic_f[0] = 0.0;
00056 for (i=0; i<nreal; i++)
00057 {
00058 basic_f[0] += trans_x[i]*trans_x[i]*pow(1.0e6,i/(nreal-1.0));
00059 }
00060 res = basic_f[0] + bias[0];
00061 return (res);
00062 }
00063
00064 long double calc_benchmark_func_f4(long double *x)
00065 {
00066 long double res;
00067 transform (x, 0);
00068 basic_f[0] = calc_schwefel(trans_x)*(1.0 + 0.4*fabs(randomnormaldeviate()));
00069 res = basic_f[0] + bias[0];
00070 return (res);
00071 }
00072
00073 long double calc_benchmark_func_f5(long double *x)
00074 {
00075 int i, j;
00076 long double res;
00077 basic_f[0] = -INF;
00078 for (i=0; i<nreal; i++)
00079 {
00080 res=0.0;
00081 for (j=0; j<nreal; j++)
00082 {
00083 res += Af5[i][j]*x[j];
00084 }
00085 res = fabs(res-Bf5[i]);
00086 if (basic_f[0] < res)
00087 {
00088 basic_f[0] = res;
00089 }
00090 }
00091 res = basic_f[0] + bias[0];
00092 return (res);
00093 }
00094
00095 long double calc_benchmark_func_f6(long double *x)
00096 {
00097 long double res;
00098 transform (x, 0);
00099 basic_f[0] = calc_rosenbrock(trans_x);
00100 res = basic_f[0] + bias[0];
00101 return (res);
00102 }
00103
00104 long double calc_benchmark_func_f7(long double *x)
00105 {
00106 long double res;
00107 transform (x, 0);
00108 basic_f[0] = calc_griewank(trans_x);
00109 res = basic_f[0] + bias[0];
00110 return (res);
00111 }
00112
00113 long double calc_benchmark_func_f8(long double *x)
00114 {
00115 long double res;
00116 transform (x, 0);
00117 basic_f[0] = calc_ackley(trans_x);
00118 res = basic_f[0] + bias[0];
00119 return (res);
00120 }
00121
00122 long double calc_benchmark_func_f9(long double *x)
00123 {
00124 long double res;
00125 transform (x, 0);
00126 basic_f[0] = calc_rastrigin(trans_x);
00127 res = basic_f[0] + bias[0];
00128 return (res);
00129 }
00130
00131 long double calc_benchmark_func_f10(long double *x)
00132 {
00133 long double res;
00134 transform (x, 0);
00135 basic_f[0] = calc_rastrigin(trans_x);
00136 res = basic_f[0] + bias[0];
00137 return (res);
00138 }
00139
00140 long double calc_benchmark_func_f11(long double *x)
00141 {
00142 int i;
00143 long double res;
00144 for (i=0; i<nreal; i++)
00145 {
00146 norm_x[i] = 0.0;
00147 }
00148 transform (x, 0);
00149 basic_f[0] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00150 res = basic_f[0] + bias[0];
00151 return (res);
00152 }
00153
00154 long double calc_benchmark_func_f12(long double *x)
00155 {
00156 long double res;
00157 long double sum1, sum2;
00158 int i, j;
00159 basic_f[0] = 0.0;
00160 for (i=0; i<nreal; i++)
00161 {
00162 sum1 = 0.0;
00163 sum2 = 0.0;
00164 for (j=0; j<nreal; j++)
00165 {
00166 sum1 += Af12[i][j]*sin(alphaf12[j]) + Bf12[i][j]*cos(alphaf12[j]);
00167 sum2 += Af12[i][j]*sin(x[j]) + Bf12[i][j]*cos(x[j]);
00168 }
00169 basic_f[0] += pow((sum1-sum2),2.0);
00170 }
00171 res = basic_f[0] + bias[0];
00172 return (res);
00173 }
00174
00175 long double calc_benchmark_func_f13(long double *x)
00176 {
00177 int i;
00178 long double temp;
00179 long double res;
00180 transform(x,0);
00181 res = 0.0;
00182 for (i=0; i<nreal-1; i++)
00183 {
00184 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00185 res += (temp*temp)/4000.0 - cos(temp) + 1.0;
00186 }
00187 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00188 res += (temp*temp)/4000.0 - cos(temp) + 1.0 + bias[0];
00189 return (res);
00190 }
00191
00192 long double calc_benchmark_func_f14(long double *x)
00193 {
00194 int i;
00195 long double temp1, temp2;
00196 long double res;
00197 transform(x,0);
00198 res = 0.0;
00199 for (i=0; i<nreal-1; i++)
00200 {
00201 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00202 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00203 res += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00204 }
00205 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00206 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00207 res += 0.5 + (temp1-0.5)/(pow(temp2,2.0)) + bias[0];
00208 return (res);
00209 }
00210
00211 void calc_benchmark_norm_f15()
00212 {
00213 int i;
00214 transform_norm (0); norm_f[0] = calc_rastrigin(trans_x);
00215 transform_norm (1); norm_f[1] = calc_rastrigin(trans_x);
00216 for (i=0; i<nreal; i++)
00217 {
00218 norm_x[i] = 0.0;
00219 }
00220 transform_norm (2); norm_f[2] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00221 transform_norm (3); norm_f[3] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00222 transform_norm (4); norm_f[4] = calc_griewank(trans_x);
00223 transform_norm (5); norm_f[5] = calc_griewank(trans_x);
00224 transform_norm (6); norm_f[6] = calc_ackley(trans_x);
00225 transform_norm (7); norm_f[7] = calc_ackley(trans_x);
00226 transform_norm (8); norm_f[8] = calc_sphere(trans_x);
00227 transform_norm (9); norm_f[9] = calc_sphere(trans_x);
00228 return;
00229 }
00230
00231 long double calc_benchmark_func_f15(long double *x)
00232 {
00233 int i;
00234 int nfunc = 10;
00235 long double res;
00236 transform (x, 0); basic_f[0] = calc_rastrigin(trans_x);
00237 transform (x, 1); basic_f[1] = calc_rastrigin(trans_x);
00238 for (i=0; i<nreal; i++)
00239 {
00240 norm_x[i] = 0.0;
00241 }
00242 transform (x, 2); basic_f[2] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00243 transform (x, 3); basic_f[3] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00244 transform (x, 4); basic_f[4] = calc_griewank(trans_x);
00245 transform (x, 5); basic_f[5] = calc_griewank(trans_x);
00246 transform (x, 6); basic_f[6] = calc_ackley(trans_x);
00247 transform (x, 7); basic_f[7] = calc_ackley(trans_x);
00248 transform (x, 8); basic_f[8] = calc_sphere(trans_x);
00249 transform (x, 9); basic_f[9] = calc_sphere(trans_x);
00250 for (i=0; i<nfunc; i++)
00251 {
00252 basic_f[i] *= C/norm_f[i];
00253 }
00254 calc_weight(x, nfunc);
00255 res = global_bias;
00256 for (i=0; i<nfunc; i++)
00257 {
00258 res += weight[i]*(basic_f[i]+bias[i]);
00259 }
00260 return (res);
00261 }
00262
00263 void calc_benchmark_norm_f16()
00264 {
00265 int i;
00266 transform_norm (0); norm_f[0] = calc_rastrigin(trans_x);
00267 transform_norm (1); norm_f[1] = calc_rastrigin(trans_x);
00268 for (i=0; i<nreal; i++)
00269 {
00270 norm_x[i] = 0.0;
00271 }
00272 transform_norm (2); norm_f[2] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00273 transform_norm (3); norm_f[3] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00274 transform_norm (4); norm_f[4] = calc_griewank(trans_x);
00275 transform_norm (5); norm_f[5] = calc_griewank(trans_x);
00276 transform_norm (6); norm_f[6] = calc_ackley(trans_x);
00277 transform_norm (7); norm_f[7] = calc_ackley(trans_x);
00278 transform_norm (8); norm_f[8] = calc_sphere(trans_x);
00279 transform_norm (9); norm_f[9] = calc_sphere(trans_x);
00280 return;
00281 }
00282
00283 long double calc_benchmark_func_f16(long double *x)
00284 {
00285 int i;
00286 long double res;
00287 int nfunc = 10;
00288 transform (x, 0); basic_f[0] = calc_rastrigin(trans_x);
00289 transform (x, 1); basic_f[1] = calc_rastrigin(trans_x);
00290 for (i=0; i<nreal; i++)
00291 {
00292 norm_x[i] = 0.0;
00293 }
00294 transform (x, 2); basic_f[2] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00295 transform (x, 3); basic_f[3] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00296 transform (x, 4); basic_f[4] = calc_griewank(trans_x);
00297 transform (x, 5); basic_f[5] = calc_griewank(trans_x);
00298 transform (x, 6); basic_f[6] = calc_ackley(trans_x);
00299 transform (x, 7); basic_f[7] = calc_ackley(trans_x);
00300 transform (x, 8); basic_f[8] = calc_sphere(trans_x);
00301 transform (x, 9); basic_f[9] = calc_sphere(trans_x);
00302 for (i=0; i<nfunc; i++)
00303 {
00304 basic_f[i] *= C/norm_f[i];
00305 }
00306 calc_weight(x, nfunc);
00307 res = global_bias;
00308 for (i=0; i<nfunc; i++)
00309 {
00310 res += weight[i]*(basic_f[i]+bias[i]);
00311 }
00312 return (res);
00313 }
00314
00315 void calc_benchmark_norm_f17()
00316 {
00317 int i;
00318 transform_norm (0); norm_f[0] = calc_rastrigin(trans_x);
00319 transform_norm (1); norm_f[1] = calc_rastrigin(trans_x);
00320 for (i=0; i<nreal; i++)
00321 {
00322 norm_x[i] = 0.0;
00323 }
00324 transform_norm (2); norm_f[2] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00325 transform_norm (3); norm_f[3] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00326 transform_norm (4); norm_f[4] = calc_griewank(trans_x);
00327 transform_norm (5); norm_f[5] = calc_griewank(trans_x);
00328 transform_norm (6); norm_f[6] = calc_ackley(trans_x);
00329 transform_norm (7); norm_f[7] = calc_ackley(trans_x);
00330 transform_norm (8); norm_f[8] = calc_sphere(trans_x);
00331 transform_norm (9); norm_f[9] = calc_sphere(trans_x);
00332 return;
00333 }
00334
00335 long double calc_benchmark_func_f17(long double *x)
00336 {
00337 int i;
00338 int nfunc=10;
00339 long double res;
00340 transform (x, 0); basic_f[0] = calc_rastrigin(trans_x);
00341 transform (x, 1); basic_f[1] = calc_rastrigin(trans_x);
00342 for (i=0; i<nreal; i++)
00343 {
00344 norm_x[i] = 0.0;
00345 }
00346 transform (x, 2); basic_f[2] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00347 transform (x, 3); basic_f[3] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00348 transform (x, 4); basic_f[4] = calc_griewank(trans_x);
00349 transform (x, 5); basic_f[5] = calc_griewank(trans_x);
00350 transform (x, 6); basic_f[6] = calc_ackley(trans_x);
00351 transform (x, 7); basic_f[7] = calc_ackley(trans_x);
00352 transform (x, 8); basic_f[8] = calc_sphere(trans_x);
00353 transform (x, 9); basic_f[9] = calc_sphere(trans_x);
00354 for (i=0; i<nfunc; i++)
00355 {
00356 basic_f[i] *= C/norm_f[i];
00357 }
00358 calc_weight(x, nfunc);
00359 res = 0.0;
00360 for (i=0; i<nfunc; i++)
00361 {
00362 res += weight[i]*(basic_f[i]+bias[i]);
00363 }
00364 res = res*(1.0 + 0.2*fabs(randomnormaldeviate()));
00365 res += global_bias;
00366 return (res);
00367 }
00368
00369 void calc_benchmark_norm_f18()
00370 {
00371 int i;
00372 transform_norm (0); norm_f[0] = calc_ackley(trans_x);
00373 transform_norm (1); norm_f[1] = calc_ackley(trans_x);
00374 transform_norm (2); norm_f[2] = calc_rastrigin(trans_x);
00375 transform_norm (3); norm_f[3] = calc_rastrigin(trans_x);
00376 transform_norm (4); norm_f[4] = calc_sphere(trans_x);
00377 transform_norm (5); norm_f[5] = calc_sphere(trans_x);
00378 for (i=0; i<nreal; i++)
00379 {
00380 norm_x[i] = 0.0;
00381 }
00382 transform_norm (6); norm_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00383 transform_norm (7); norm_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00384 transform_norm (8); norm_f[8] = calc_griewank(trans_x);
00385 transform_norm (9); norm_f[9] = calc_griewank(trans_x);
00386 return;
00387 }
00388
00389 long double calc_benchmark_func_f18(long double *x)
00390 {
00391 int i;
00392 int nfunc=10;
00393 long double res;
00394 transform (x, 0); basic_f[0] = calc_ackley(trans_x);
00395 transform (x, 1); basic_f[1] = calc_ackley(trans_x);
00396 transform (x, 2); basic_f[2] = calc_rastrigin(trans_x);
00397 transform (x, 3); basic_f[3] = calc_rastrigin(trans_x);
00398 transform (x, 4); basic_f[4] = calc_sphere(trans_x);
00399 transform (x, 5); basic_f[5] = calc_sphere(trans_x);
00400 for (i=0; i<nreal; i++)
00401 {
00402 norm_x[i] = 0.0;
00403 }
00404 transform (x, 6); basic_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00405 transform (x, 7); basic_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00406 transform (x, 8); basic_f[8] = calc_griewank(trans_x);
00407 transform (x, 9); basic_f[9] = calc_griewank(trans_x);
00408 for (i=0; i<nfunc; i++)
00409 {
00410 basic_f[i] *= C/norm_f[i];
00411 }
00412 calc_weight(x, nfunc);
00413 res = global_bias;
00414 for (i=0; i<nfunc; i++)
00415 {
00416 res += weight[i]*(basic_f[i]+bias[i]);
00417 }
00418 return (res);
00419 }
00420
00421 void calc_benchmark_norm_f19()
00422 {
00423 int i;
00424 transform_norm (0); norm_f[0] = calc_ackley(trans_x);
00425 transform_norm (1); norm_f[1] = calc_ackley(trans_x);
00426 transform_norm (2); norm_f[2] = calc_rastrigin(trans_x);
00427 transform_norm (3); norm_f[3] = calc_rastrigin(trans_x);
00428 transform_norm (4); norm_f[4] = calc_sphere(trans_x);
00429 transform_norm (5); norm_f[5] = calc_sphere(trans_x);
00430 for (i=0; i<nreal; i++)
00431 {
00432 norm_x[i] = 0.0;
00433 }
00434 transform_norm (6); norm_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00435 transform_norm (7); norm_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00436 transform_norm (8); norm_f[8] = calc_griewank(trans_x);
00437 transform_norm (9); norm_f[9] = calc_griewank(trans_x);
00438 return;
00439 }
00440
00441 long double calc_benchmark_func_f19(long double *x)
00442 {
00443 int i;
00444 int nfunc=10;
00445 long double res;
00446 transform (x, 0); basic_f[0] = calc_ackley(trans_x);
00447 transform (x, 1); basic_f[1] = calc_ackley(trans_x);
00448 transform (x, 2); basic_f[2] = calc_rastrigin(trans_x);
00449 transform (x, 3); basic_f[3] = calc_rastrigin(trans_x);
00450 transform (x, 4); basic_f[4] = calc_sphere(trans_x);
00451 transform (x, 5); basic_f[5] = calc_sphere(trans_x);
00452 for (i=0; i<nreal; i++)
00453 {
00454 norm_x[i] = 0.0;
00455 }
00456 transform (x, 6); basic_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00457 transform (x, 7); basic_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00458 transform (x, 8); basic_f[8] = calc_griewank(trans_x);
00459 transform (x, 9); basic_f[9] = calc_griewank(trans_x);
00460 for (i=0; i<nfunc; i++)
00461 {
00462 basic_f[i] *= C/norm_f[i];
00463 }
00464 calc_weight(x, nfunc);
00465 res = global_bias;
00466 for (i=0; i<nfunc; i++)
00467 {
00468 res += weight[i]*(basic_f[i]+bias[i]);
00469 }
00470 return (res);
00471 }
00472
00473 void calc_benchmark_norm_f20()
00474 {
00475 int i;
00476 transform_norm (0); norm_f[0] = calc_ackley(trans_x);
00477 transform_norm (1); norm_f[1] = calc_ackley(trans_x);
00478 transform_norm (2); norm_f[2] = calc_rastrigin(trans_x);
00479 transform_norm (3); norm_f[3] = calc_rastrigin(trans_x);
00480 transform_norm (4); norm_f[4] = calc_sphere(trans_x);
00481 transform_norm (5); norm_f[5] = calc_sphere(trans_x);
00482 for (i=0; i<nreal; i++)
00483 {
00484 norm_x[i] = 0.0;
00485 }
00486 transform_norm (6); norm_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00487 transform_norm (7); norm_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00488 transform_norm (8); norm_f[8] = calc_griewank(trans_x);
00489 transform_norm (9); norm_f[9] = calc_griewank(trans_x);
00490 return;
00491 }
00492
00493 long double calc_benchmark_func_f20(long double *x)
00494 {
00495 int i;
00496 int nfunc=10;
00497 long double res;
00498 transform (x, 0); basic_f[0] = calc_ackley(trans_x);
00499 transform (x, 1); basic_f[1] = calc_ackley(trans_x);
00500 transform (x, 2); basic_f[2] = calc_rastrigin(trans_x);
00501 transform (x, 3); basic_f[3] = calc_rastrigin(trans_x);
00502 transform (x, 4); basic_f[4] = calc_sphere(trans_x);
00503 transform (x, 5); basic_f[5] = calc_sphere(trans_x);
00504 for (i=0; i<nreal; i++)
00505 {
00506 norm_x[i] = 0.0;
00507 }
00508 transform (x, 6); basic_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00509 transform (x, 7); basic_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00510 transform (x, 8); basic_f[8] = calc_griewank(trans_x);
00511 transform (x, 9); basic_f[9] = calc_griewank(trans_x);
00512 for (i=0; i<nfunc; i++)
00513 {
00514 basic_f[i] *= C/norm_f[i];
00515 }
00516 calc_weight(x, nfunc);
00517 res = global_bias;
00518 for (i=0; i<nfunc; i++)
00519 {
00520 res += weight[i]*(basic_f[i]+bias[i]);
00521 }
00522 return (res);
00523 }
00524
00525 void calc_benchmark_norm_f21()
00526 {
00527 int i;
00528 long double temp1, temp2, temp;
00529 transform_norm (0);
00530 norm_f[0] = 0.0;
00531 for (i=0; i<nreal-1; i++)
00532 {
00533 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00534 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00535 norm_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00536 }
00537 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00538 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00539 norm_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00540 transform_norm (1);
00541 norm_f[1] = 0.0;
00542 for (i=0; i<nreal-1; i++)
00543 {
00544 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00545 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00546 norm_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00547 }
00548 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00549 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00550 norm_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00551 transform_norm (2); norm_f[2] = calc_rastrigin(trans_x);
00552 transform_norm (3); norm_f[3] = calc_rastrigin(trans_x);
00553 transform_norm(4);
00554 norm_f[4] = 0.0;
00555 for (i=0; i<nreal-1; i++)
00556 {
00557 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00558 norm_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00559 }
00560 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00561 norm_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00562 transform_norm(5);
00563 norm_f[5] = 0.0;
00564 for (i=0; i<nreal-1; i++)
00565 {
00566 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00567 norm_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00568 }
00569 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00570 norm_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00571 for (i=0; i<nreal; i++)
00572 {
00573 norm_x[i] = 0.0;
00574 }
00575 transform_norm (6); norm_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00576 transform_norm (7); norm_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00577 transform_norm (8); norm_f[8] = calc_griewank(trans_x);
00578 transform_norm (9); norm_f[9] = calc_griewank(trans_x);
00579 return;
00580 }
00581
00582 long double calc_benchmark_func_f21(long double *x)
00583 {
00584 int i;
00585 long double temp1, temp2, temp;
00586 int nfunc=10;
00587 long double res;
00588 transform (x, 0);
00589 basic_f[0] = 0.0;
00590 for (i=0; i<nreal-1; i++)
00591 {
00592 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00593 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00594 basic_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00595 }
00596 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00597 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00598 basic_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00599 transform (x, 1);
00600 basic_f[1] = 0.0;
00601 for (i=0; i<nreal-1; i++)
00602 {
00603 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00604 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00605 basic_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00606 }
00607 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00608 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00609 basic_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00610 transform (x, 2); basic_f[2] = calc_rastrigin(trans_x);
00611 transform (x, 3); basic_f[3] = calc_rastrigin(trans_x);
00612 transform (x, 4);
00613 basic_f[4] = 0.0;
00614 for (i=0; i<nreal-1; i++)
00615 {
00616 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00617 basic_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00618 }
00619 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00620 basic_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00621 transform(x, 5);
00622 basic_f[5] = 0.0;
00623 for (i=0; i<nreal-1; i++)
00624 {
00625 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00626 basic_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00627 }
00628 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00629 basic_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00630 for (i=0; i<nreal; i++)
00631 {
00632 norm_x[i] = 0.0;
00633 }
00634 transform (x, 6); basic_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00635 transform (x, 7); basic_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00636 transform (x, 8); basic_f[8] = calc_griewank(trans_x);
00637 transform (x, 9); basic_f[9] = calc_griewank(trans_x);
00638 for (i=0; i<nfunc; i++)
00639 {
00640 basic_f[i] *= C/norm_f[i];
00641 }
00642 calc_weight(x, nfunc);
00643 res = global_bias;
00644 for (i=0; i<nfunc; i++)
00645 {
00646 res += weight[i]*(basic_f[i]+bias[i]);
00647 }
00648 return (res);
00649 }
00650
00651 void calc_benchmark_norm_f22()
00652 {
00653 int i;
00654 long double temp1, temp2, temp;
00655 transform_norm (0);
00656 norm_f[0] = 0.0;
00657 for (i=0; i<nreal-1; i++)
00658 {
00659 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00660 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00661 norm_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00662 }
00663 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00664 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00665 norm_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00666 transform_norm (1);
00667 norm_f[1] = 0.0;
00668 for (i=0; i<nreal-1; i++)
00669 {
00670 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00671 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00672 norm_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00673 }
00674 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00675 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00676 norm_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00677 transform_norm (2); norm_f[2] = calc_rastrigin(trans_x);
00678 transform_norm (3); norm_f[3] = calc_rastrigin(trans_x);
00679 transform_norm(4);
00680 norm_f[4] = 0.0;
00681 for (i=0; i<nreal-1; i++)
00682 {
00683 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00684 norm_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00685 }
00686 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00687 norm_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00688 transform_norm(5);
00689 norm_f[5] = 0.0;
00690 for (i=0; i<nreal-1; i++)
00691 {
00692 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00693 norm_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00694 }
00695 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00696 norm_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00697 for (i=0; i<nreal; i++)
00698 {
00699 norm_x[i] = 0.0;
00700 }
00701 transform_norm (6); norm_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00702 transform_norm (7); norm_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00703 transform_norm (8); norm_f[8] = calc_griewank(trans_x);
00704 transform_norm (9); norm_f[9] = calc_griewank(trans_x);
00705 return;
00706 }
00707
00708 long double calc_benchmark_func_f22(long double *x)
00709 {
00710 int i;
00711 long double temp1, temp2, temp;
00712 int nfunc=10;
00713 long double res;
00714 transform (x, 0);
00715 basic_f[0] = 0.0;
00716 for (i=0; i<nreal-1; i++)
00717 {
00718 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00719 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00720 basic_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00721 }
00722 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00723 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00724 basic_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00725 transform (x, 1);
00726 basic_f[1] = 0.0;
00727 for (i=0; i<nreal-1; i++)
00728 {
00729 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00730 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00731 basic_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00732 }
00733 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00734 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00735 basic_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00736 transform (x, 2); basic_f[2] = calc_rastrigin(trans_x);
00737 transform (x, 3); basic_f[3] = calc_rastrigin(trans_x);
00738 transform (x, 4);
00739 basic_f[4] = 0.0;
00740 for (i=0; i<nreal-1; i++)
00741 {
00742 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00743 basic_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00744 }
00745 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00746 basic_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00747 transform(x, 5);
00748 basic_f[5] = 0.0;
00749 for (i=0; i<nreal-1; i++)
00750 {
00751 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00752 basic_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00753 }
00754 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00755 basic_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00756 for (i=0; i<nreal; i++)
00757 {
00758 norm_x[i] = 0.0;
00759 }
00760 transform (x, 6); basic_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00761 transform (x, 7); basic_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00762 transform (x, 8); basic_f[8] = calc_griewank(trans_x);
00763 transform (x, 9); basic_f[9] = calc_griewank(trans_x);
00764 for (i=0; i<nfunc; i++)
00765 {
00766 basic_f[i] *= C/norm_f[i];
00767 }
00768 calc_weight(x, nfunc);
00769 res = global_bias;
00770 for (i=0; i<nfunc; i++)
00771 {
00772 res += weight[i]*(basic_f[i]+bias[i]);
00773 }
00774 return (res);
00775 }
00776
00777 void calc_benchmark_norm_f23()
00778 {
00779 int i;
00780 long double temp1, temp2, temp;
00781 transform_norm (0);
00782 norm_f[0] = 0.0;
00783 for (i=0; i<nreal-1; i++)
00784 {
00785 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00786 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00787 norm_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00788 }
00789 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00790 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00791 norm_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00792 transform_norm (1);
00793 norm_f[1] = 0.0;
00794 for (i=0; i<nreal-1; i++)
00795 {
00796 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00797 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00798 norm_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00799 }
00800 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00801 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00802 norm_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00803 transform_norm (2); norm_f[2] = calc_rastrigin(trans_x);
00804 transform_norm (3); norm_f[3] = calc_rastrigin(trans_x);
00805 transform_norm(4);
00806 norm_f[4] = 0.0;
00807 for (i=0; i<nreal-1; i++)
00808 {
00809 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00810 norm_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00811 }
00812 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00813 norm_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00814 transform_norm(5);
00815 norm_f[5] = 0.0;
00816 for (i=0; i<nreal-1; i++)
00817 {
00818 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00819 norm_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00820 }
00821 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00822 norm_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00823 for (i=0; i<nreal; i++)
00824 {
00825 norm_x[i] = 0.0;
00826 }
00827 transform_norm (6); norm_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00828 transform_norm (7); norm_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00829 transform_norm (8); norm_f[8] = calc_griewank(trans_x);
00830 transform_norm (9); norm_f[9] = calc_griewank(trans_x);
00831 return;
00832 }
00833
00834 long double calc_benchmark_func_f23(long double *x)
00835 {
00836 int i;
00837 int nfunc=10;
00838 long double temp1, temp2, temp;
00839 long double res;
00840 int a;
00841 long double b;
00842 for (i=0; i<nreal; i++)
00843 {
00844 if (fabs(x[i]-o[0][i]) >= 0.5)
00845 {
00846 res = 2.0*x[i];
00847 a = (int) res;
00848 b = fabs(res-a);
00849 if (b<0.5)
00850 {
00851 temp_x4[i] = a/2.0;
00852 }
00853 else
00854 {
00855 if (res<=0.0)
00856 {
00857 temp_x4[i] = (a-1.0)/2.0;
00858 }
00859 else
00860 {
00861 temp_x4[i] = (a+1.0)/2.0;
00862 }
00863 }
00864 }
00865 else
00866 {
00867 temp_x4[i] = x[i];
00868 }
00869 }
00870 transform (temp_x4, 0);
00871 basic_f[0] = 0.0;
00872 for (i=0; i<nreal-1; i++)
00873 {
00874 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00875 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00876 basic_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00877 }
00878 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00879 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00880 basic_f[0] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00881 transform (temp_x4, 1);
00882 basic_f[1] = 0.0;
00883 for (i=0; i<nreal-1; i++)
00884 {
00885 temp1 = pow((sin(sqrt(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0)))),2.0);
00886 temp2 = 1.0 + 0.001*(pow(trans_x[i],2.0)+pow(trans_x[i+1],2.0));
00887 basic_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00888 }
00889 temp1 = pow((sin(sqrt(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0)))),2.0);
00890 temp2 = 1.0 + 0.001*(pow(trans_x[nreal-1],2.0)+pow(trans_x[0],2.0));
00891 basic_f[1] += 0.5 + (temp1-0.5)/(pow(temp2,2.0));
00892 transform (temp_x4, 2); basic_f[2] = calc_rastrigin(trans_x);
00893 transform (temp_x4, 3); basic_f[3] = calc_rastrigin(trans_x);
00894 transform (temp_x4, 4);
00895 basic_f[4] = 0.0;
00896 for (i=0; i<nreal-1; i++)
00897 {
00898 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00899 basic_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00900 }
00901 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00902 basic_f[4] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00903 transform(temp_x4, 5);
00904 basic_f[5] = 0.0;
00905 for (i=0; i<nreal-1; i++)
00906 {
00907 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00908 basic_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00909 }
00910 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00911 basic_f[5] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00912 for (i=0; i<nreal; i++)
00913 {
00914 norm_x[i] = 0.0;
00915 }
00916 transform (temp_x4, 6); basic_f[6] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00917 transform (temp_x4, 7); basic_f[7] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00918 transform (temp_x4, 8); basic_f[8] = calc_griewank(trans_x);
00919 transform (temp_x4, 9); basic_f[9] = calc_griewank(trans_x);
00920 for (i=0; i<nfunc; i++)
00921 {
00922 basic_f[i] *= C/norm_f[i];
00923 }
00924 calc_weight(temp_x4, nfunc);
00925 res = global_bias;
00926 for (i=0; i<nfunc; i++)
00927 {
00928 res += weight[i]*(basic_f[i]+bias[i]);
00929 }
00930 return (res);
00931 }
00932
00933 long double ExpandedF6(long double x, long double y) {
00934
00935 long double temp1 = pow(sin(sqrt(x*x+y*y)), 2.0);
00936
00937 long double temp2 = 1.0 + 0.001*(x*x+y*y);
00938 return 0.5 + (temp1-0.5)/(temp2*temp2);
00939 }
00940
00941 void calc_benchmark_norm_f24()
00942 {
00943 int i;
00944 long double temp;
00945 for (i=0; i<nreal; i++)
00946 {
00947 norm_x[i] = 0.0;
00948 }
00949 transform_norm (0); norm_f[0] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
00950 transform_norm (1);
00951
00952 norm_f[1] = 0.0;
00953 for (i=0; i<nreal-1; i++)
00954 {
00955 norm_f[1] += ExpandedF6(trans_x[i], trans_x[i+1]);
00956
00957
00958
00959 }
00960
00961
00962
00963 norm_f[1] += ExpandedF6(trans_x[nreal-1], trans_x[0]);
00964 transform_norm (2);
00965 norm_f[2] = 0.0;
00966 for (i=0; i<nreal-1; i++)
00967 {
00968 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
00969 norm_f[2] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00970 }
00971 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
00972 norm_f[2] += (temp*temp)/4000.0 - cos(temp) + 1.0;
00973 transform_norm (3); norm_f[3] = calc_ackley(trans_x);
00974 transform_norm (4); norm_f[4] = calc_rastrigin(trans_x);
00975 transform_norm (5); norm_f[5] = calc_griewank(trans_x);
00976 transform_norm (6);
00977 norm_f[6] = 0.0;
00978 for (i=0; i<nreal-1; i++)
00979 {
00980 norm_f[6] += nc_schaffer(trans_x[i], trans_x[i+1]);
00981 }
00982 norm_f[6] += nc_schaffer(trans_x[nreal-1], trans_x[0]);
00983 transform_norm(7); norm_f[7] = nc_rastrigin(trans_x);
00984 transform_norm (8);
00985 norm_f[8] = 0.0;
00986 for (i=0; i<nreal; i++)
00987 {
00988 norm_f[8] += trans_x[i]*trans_x[i]*pow(1.0e6,i/(nreal-1.0));
00989 }
00990 transform_norm (9); norm_f[9] = calc_sphere(trans_x)*(1.0 + 0.1*fabs(randomnormaldeviate()));
00991 return;
00992 }
00993
00994 long double calc_benchmark_func_f24(long double *x)
00995 {
00996 int i;
00997 int nfunc=10;
00998 long double temp;
00999 long double res;
01000 for (i=0; i<nreal; i++)
01001 {
01002 norm_x[i] = 0.0;
01003 }
01004
01005 transform (x, 0); basic_f[0] = calc_weierstrass(trans_x) - calc_weierstrass(norm_x);
01006
01007
01008 transform (x, 1);
01009 basic_f[1] = 0.0;
01010
01011 for (i=0; i<nreal-1; i++)
01012 {
01013 basic_f[1] += ExpandedF6(trans_x[i], trans_x[i+1]);
01014
01015
01016
01017 }
01018
01019
01020
01021 basic_f[1] += ExpandedF6(trans_x[nreal-1], trans_x[0]);
01022
01023
01024 transform (x, 2);
01025 basic_f[2] = 0.0;
01026 for (i=0; i<nreal-1; i++)
01027 {
01028 temp = 100.0*pow((trans_x[i]*trans_x[i]-trans_x[i+1]),2.0) + 1.0*pow((trans_x[i]-1.0),2.0);
01029 basic_f[2] += (temp*temp)/4000.0 - cos(temp) + 1.0;
01030 }
01031 temp = 100.0*pow((trans_x[nreal-1]*trans_x[nreal-1]-trans_x[0]),2.0) + 1.0*pow((trans_x[nreal-1]-1.0),2.0);
01032 basic_f[2] += (temp*temp)/4000.0 - cos(temp) + 1.0;
01033
01034 transform (x, 3); basic_f[3] = calc_ackley(trans_x);
01035 transform (x, 4); basic_f[4] = calc_rastrigin(trans_x);
01036 transform (x, 5); basic_f[5] = calc_griewank(trans_x);
01037
01038
01039 transform (x, 6);
01040 basic_f[6] = 0.0;
01041 for (i=0; i<nreal-1; i++)
01042 {
01043 basic_f[6] += nc_schaffer(trans_x[i], trans_x[i+1]);
01044 }
01045 basic_f[6] += nc_schaffer(trans_x[nreal-1], trans_x[0]);
01046
01047 transform (x, 7); basic_f[7] = nc_rastrigin(trans_x);
01048
01049 transform (x, 8);
01050 basic_f[8] = 0.0;
01051 for (i=0; i<nreal; i++)
01052 {
01053 basic_f[8] += trans_x[i]*trans_x[i]*pow(1.0e6,i/(nreal-1.0));
01054 }
01055 transform (x, 9); basic_f[9] = (calc_sphere(trans_x))*(1.0 + 0.1*fabs(randomnormaldeviate()));
01056 for (i=0; i<nfunc; i++)
01057 {
01058 basic_f[i] *= C/norm_f[i];
01059 }
01060 calc_weight(x, nfunc);
01061 res = global_bias;
01062 for (i=0; i<nfunc; i++)
01063 {
01064 res += weight[i]*(basic_f[i]+bias[i]);
01065 }
01066 return (res);
01067 }
01068
01069 long double calc_benchmark_func_f25(long double *x)
01070 {
01071 return calc_benchmark_func_f24(x);
01072 }
01073
01074 void calc_benchmark_norm_f25()
01075 {
01076 calc_benchmark_norm_f24();
01077 }
01078
01079
01080 typedef long double (*tBenchmark)(long double *);
01081
01082 static tBenchmark bench;
01083
01084 tBenchmark set_calc_benchmark_func(int num) {
01085 if (num == 1) {
01086 return calc_benchmark_func_f1;
01087 }
01088 else if (num == 2) {
01089 return calc_benchmark_func_f2;
01090 }
01091 else if (num == 3) {
01092 return calc_benchmark_func_f3;
01093 }
01094 else if (num == 4) {
01095 return calc_benchmark_func_f4;
01096 }
01097 else if (num == 5) {
01098 return calc_benchmark_func_f5;
01099 }
01100 else if (num == 6) {
01101 return calc_benchmark_func_f6;
01102 }
01103 else if (num == 7) {
01104 return calc_benchmark_func_f7;
01105 }
01106 else if (num == 8) {
01107 return calc_benchmark_func_f8;
01108 }
01109 else if (num == 9) {
01110 return calc_benchmark_func_f9;
01111 }
01112 else if (num == 10) {
01113 return calc_benchmark_func_f10;
01114 }
01115 else if (num == 11) {
01116 return calc_benchmark_func_f11;
01117 }
01118 else if (num == 12) {
01119 return calc_benchmark_func_f12;
01120 }
01121 else if (num == 13) {
01122 return calc_benchmark_func_f13;
01123 }
01124 else if (num == 14) {
01125 return calc_benchmark_func_f14;
01126 }
01127 else if (num == 15) {
01128 return calc_benchmark_func_f15;
01129 }
01130 else if (num == 16) {
01131 return calc_benchmark_func_f16;
01132 }
01133 else if (num == 17) {
01134 return calc_benchmark_func_f17;
01135 }
01136 else if (num == 18) {
01137 return calc_benchmark_func_f18;
01138 }
01139 else if (num == 19) {
01140 return calc_benchmark_func_f19;
01141 }
01142 else if (num == 20) {
01143 return calc_benchmark_func_f20;
01144 }
01145 else if (num == 21) {
01146 return calc_benchmark_func_f21;
01147 }
01148 else if (num == 22) {
01149 return calc_benchmark_func_f22;
01150 }
01151 else if (num == 23) {
01152 return calc_benchmark_func_f23;
01153 }
01154 else if (num == 24) {
01155 return calc_benchmark_func_f24;
01156 }
01157 else if (num == 25) {
01158 return calc_benchmark_func_f25;
01159 }
01160 else {
01161 printf("Error: num %d no válido\n", num);
01162 exit(1);
01163 }
01164
01165 return NULL;
01166 }
01167
01168 long double calc_benchmark_func(long double *x) {
01169 static int notinit = 1;
01170
01171 if (notinit) {
01172 bench = set_calc_benchmark_func(nfunc);
01173 }
01174
01175 return (*bench)(x);
01176 }