00001 #include <stdio.h>
00002 #include <stdlib.h>
00003 #include <math.h>
00004 #include <stdarg.h>
00005 #include <string.h>
00006 #include <time.h>
00007
00008 #include "benchmarksdeclare.h"
00009 #include "bbobStructures.h"
00010 #define TOL 1e-8
00011
00012 static int seed = -1;
00013 static int seedn = -1;
00014
00015 static double * gval;
00016 static double * gval2;
00017 static double * gvect;
00018 static double * uniftmp;
00019 static double * tmpvect;
00020
00021 double round(double a) {
00022 return floor(a + 0.5);
00023 }
00024 double fmin(double a, double b) {
00025 return b < a ? b : a;
00026 }
00027 double fmax(double a, double b) {
00028 return b > a ? b : a;
00029 }
00030
00031
00032
00033
00034 void setNoiseSeed(unsigned int _seed, unsigned int _seedn)
00035 {
00036 seed = _seed;
00037 seedn = _seedn;
00038 }
00039
00040 void unif(double* r, int N, int inseed)
00041 {
00042
00043 int aktseed;
00044 int tmp;
00045 int rgrand[32];
00046 int aktrand;
00047 int i;
00048
00049 if (inseed < 0)
00050 inseed = -inseed;
00051 if (inseed < 1)
00052 inseed = 1;
00053 aktseed = inseed;
00054
00055 for (i = 39; i >= 0; i--)
00056 {
00057 tmp = floor((double)aktseed/(double)127773);
00058 aktseed = 16807 * (aktseed - tmp * 127773) - 2836 * tmp;
00059 if (aktseed < 0)
00060 aktseed = aktseed + 2147483647;
00061 if (i < 32)
00062 rgrand[i] = aktseed;
00063 }
00064 aktrand = rgrand[0];
00065
00066 for (i = 0; i < N; i++)
00067 {
00068 tmp = floor((double)aktseed/(double)127773);
00069 aktseed = 16807 * (aktseed - tmp * 127773) - 2836 * tmp;
00070 if (aktseed < 0)
00071 aktseed = aktseed + 2147483647;
00072 tmp = floor((double)aktrand / (double)67108865);
00073 aktrand = rgrand[tmp];
00074 rgrand[tmp] = aktseed;
00075 r[i] = (double)aktrand/2.147483647e9;
00076 if (r[i] == 0.)
00077 {
00078 printf("Warning: zero sampled(?), set to 1e-99.\n");
00079 r[i] = 1e-99;
00080 }
00081 }
00082 return;
00083 }
00084
00085 void gauss(double * g, int N, int seed)
00086 {
00087
00088
00089 int i;
00090
00091 unif(uniftmp, 2*N, seed);
00092
00093 for (i = 0; i < N; i++)
00094 {
00095 g[i] = sqrt(-2*log(uniftmp[i])) * cos(2*M_PI*uniftmp[N+i]);
00096 if (g[i] == 0.)
00097 g[i] = 1e-99;
00098 }
00099 return;
00100 }
00101
00102 void computeXopt(int seed, int _DIM) {
00103 int i;
00104
00105 unif(tmpvect, _DIM, seed);
00106 for (i = 0; i < _DIM; i++)
00107 {
00108 Xopt[i] = 8 * floor(1e4 * tmpvect[i])/1e4 - 4;
00109 if (Xopt[i] == 0.0)
00110 Xopt[i] = -1e-5;
00111 }
00112 }
00113
00114 void monotoneTFosc(double* f) {
00115 double a = 0.1;
00116 int i;
00117 for (i = 0; i < DIM; i++)
00118 {
00119 if (f[i] > 0)
00120 {
00121 f[i] = log(f[i])/a;
00122 f[i] = pow(exp(f[i] + 0.49*(sin(f[i]) + sin(0.79*f[i]))), a);
00123 }
00124 else if (f[i] < 0)
00125 {
00126 f[i] = log(-f[i])/a;
00127 f[i] = -pow(exp(f[i] + 0.49*(sin(0.55 * f[i]) + sin(0.31*f[i]))), a);
00128 }
00129 }
00130 }
00131
00132 void freeStarStar(double** M, int m)
00133 {
00134 int i;
00135 for (i = 0; i < m; i++)
00136 {
00137 free(M[i]);
00138 }
00139 free(M);
00140 return;
00141 }
00142
00143 double** reshape(double** B, double* vector, int m, int n)
00144 {
00145 int i, j;
00146 for (i = 0; i < m; i++)
00147 {
00148 for (j = 0; j < n; j++)
00149 {
00150 B[i][j] = vector[j * m + i];
00151 }
00152 }
00153 return B;
00154 }
00155
00156
00157 void computeRotation(double ** B, int seed, int DIM)
00158 {
00159 double prod;
00160 int i, j, k;
00161
00162 gauss(gvect, DIM * DIM, seed);
00163 reshape(B, gvect, DIM, DIM);
00164
00165
00166 for (i = 0; i < DIM; i++)
00167 {
00168 for (j = 0; j < i; j++)
00169 {
00170 prod = 0;
00171 for (k = 0; k < DIM; k++)
00172 {
00173 prod += B[k][i] * B[k][j];
00174 }
00175 for (k = 0; k < DIM; k++)
00176 {
00177 B[k][i] -= prod * B[k][j];
00178 }
00179 }
00180 prod = 0;
00181 for (k = 0; k < DIM; k++)
00182 {
00183 prod += B[k][i] * B[k][i];
00184 }
00185 for (k = 0; k < DIM; k++)
00186 {
00187 B[k][i] /= sqrt(prod);
00188 }
00189 }
00190 }
00191
00192 double myrand() {
00193
00194 if (seed == -1)
00195 seed = time(NULL) % 1000000000;
00196
00197 seed ++;
00198 if (seed > 1e9)
00199 seed = 1;
00200 unif(uniftmp, 1, seed);
00201 return uniftmp[0];
00202 }
00203
00204 double randn() {
00205
00206 if (seedn == -1)
00207 seedn = time(NULL) % 1000000000;
00208
00209 seedn ++;
00210 if (seedn > 1e9)
00211 seedn = 1;
00212 gauss(uniftmp, 1, seedn);
00213 return uniftmp[0];
00214 }
00215
00216 double FGauss(double Ftrue, double beta)
00217 {
00218 double Fval = Ftrue * exp(beta * randn());
00219 Fval += 1.01 * TOL;
00220 if (Ftrue < TOL) {
00221 Fval = Ftrue;
00222 }
00223 return Fval;
00224 }
00225
00226 double FUniform(double Ftrue, double alpha, double beta)
00227 {
00228 double Fval = pow(myrand(), beta) * Ftrue * fmax(1., pow(1e9/(Ftrue+1e-99), alpha * myrand()));
00229 Fval += 1.01 * TOL;
00230 if (Ftrue < TOL) {
00231 Fval = Ftrue;
00232 }
00233 return Fval;
00234 }
00235
00236 double FCauchy(double Ftrue, double alpha, double p)
00237 {
00238 double Fval;
00239 double tmp = randn()/fabs(randn()+1e-199);
00240
00241
00242
00243 if (myrand() < p)
00244 Fval = Ftrue + alpha * fmax(0., 1e3 + tmp);
00245 else
00246 Fval = Ftrue + alpha * 1e3;
00247
00248 Fval += 1.01 * TOL;
00249 if (Ftrue < TOL) {
00250 Fval = Ftrue;
00251 }
00252 return Fval;
00253 }
00254
00255 int compare_doubles (const void *a, const void *b)
00256 {
00257 double temp = peaks[*(const int*)a] - peaks[*(const int*)b];
00258 if (temp > 0)
00259 return 1;
00260 else if (temp < 0)
00261 return -1;
00262 else
00263 return 0;
00264 }
00265
00266 double computeFopt(int _funcId, int _trialId) {
00267 int rseed, rrseed;
00268 if (_funcId == 4)
00269 rseed = 3;
00270 else if (_funcId == 18)
00271 rseed = 17;
00272 else if (_funcId == 101 || _funcId == 102 || _funcId == 103 || _funcId == 107 || _funcId == 108 || _funcId == 109)
00273 rseed = 1;
00274 else if (_funcId == 104 || _funcId == 105 || _funcId == 106 || _funcId == 110 || _funcId == 111 || _funcId == 112)
00275 rseed = 8;
00276 else if (_funcId == 113 || _funcId == 114 || _funcId == 115)
00277 rseed = 7;
00278 else if (_funcId == 116 || _funcId == 117 || _funcId == 118)
00279 rseed = 10;
00280 else if (_funcId == 119 || _funcId == 120 || _funcId == 121)
00281 rseed = 14;
00282 else if (_funcId == 122 || _funcId == 123 || _funcId == 124)
00283 rseed = 17;
00284 else if (_funcId == 125 || _funcId == 126 || _funcId == 127)
00285 rseed = 19;
00286 else if (_funcId == 128 || _funcId == 129 || _funcId == 130)
00287 rseed = 21;
00288 else
00289 rseed = _funcId;
00290
00291 rrseed = rseed + 10000 * _trialId;
00292 gauss(gval, 1, rrseed);
00293 gauss(gval2, 1, rrseed + 1);
00294 return fmin(1000., fmax(-1000., (round(100.*100.*gval[0]/gval2[0])/100.)));
00295 }
00296
00297 void setGlobalVariables(ParamStruct params) {
00298 DIM = params.DIM;
00299 trialid = params.instanceId;
00300 isInitDone = 0;
00301 return;
00302 }
00303
00304 void initbenchmarkshelper() {
00305 gval = malloc(sizeof(double) * 1);
00306 gval2 = malloc(sizeof(double) * 1);
00307 gvect = malloc(sizeof(double) * DIM * DIM);
00308 uniftmp = malloc(sizeof(double) * 2 * DIM * DIM);
00309 tmpvect = malloc(sizeof(double) * DIM);
00310 Xopt = malloc(sizeof(double) * DIM);
00311 return;
00312 }
00313
00314 void finibenchmarkshelper() {
00315 free(gval);
00316 free(gval2);
00317 free(gvect);
00318 free(uniftmp);
00319 free(tmpvect);
00320 free(Xopt);
00321 return;
00322 }
00323
00324
00325
00326 void ERROR(char *fmt, ...)
00327 {
00328 va_list argp;
00329 fprintf(stderr, "ERROR: ");
00330 va_start(argp, fmt);
00331 vfprintf(stderr, fmt, argp);
00332 va_end(argp);
00333 fprintf(stderr, "\n");
00334
00335 exit(1);
00336 }
00337
00338
00339 void WARNING(char *fmt, ...)
00340 {
00341 va_list argp;
00342 fprintf(stderr, "WARNING: ");
00343 va_start(argp, fmt);
00344 vfprintf(stderr, fmt, argp);
00345 va_end(argp);
00346 fprintf(stderr, "\n");
00347
00348 return;
00349 }
00350
00351
00352
00353
00354
00355 void createFullFileName(char *fullFileName, char *dirName, char *fileName)
00356 {
00357 char sLoc[1024];
00358 if ( (strlen(fileName) + strlen(dirName)) > 1022 )
00359 ERROR("FileName will be too long for %s + %s", dirName, fileName);
00360
00361 sprintf(sLoc, "%s/%s", dirName, fileName);
00362 strcpy(fullFileName, sLoc);
00363
00364 return;
00365 }
00366
00367
00368
00369
00370
00371
00372 void dirOK(char *sDir);
00373
00374
00375 int existFile(char * fileName)
00376 {
00377 FILE * fLoc = fopen(fileName, "r");
00378 if (fLoc == NULL)
00379 return 0;
00380 fclose(fLoc);
00381 return 1;
00382 }
00383
00384
00385 FILE * bbobOpenFile(char * fileName)
00386 {
00387 FILE * fileId;
00388
00389 fileId = fopen(fileName,"a");
00390 if (fileId == NULL)
00391 ERROR("Could not open %s", fileName);
00392 return fileId;
00393 }