Free cookie consent management tool by TermsFeed Policy Generator

source: branches/OKBJavaConnector/ECJClient/src/ec/app/bbob/BBOBenchmarks.java @ 10617

Last change on this file since 10617 was 6152, checked in by bfarka, 14 years ago

added ecj and custom statistics to communicate with the okb services #1441
File size: 83.2 KB
Line 
1package ec.app.bbob;
2
3import java.util.HashMap;
4
5import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;
6
7import ec.EvolutionState;
8import ec.Individual;
9import ec.Initializer;
10import ec.Population;
11import ec.Problem;
12import ec.Subpopulation;
13import ec.gp.koza.HalfBuilder;
14import ec.simple.SimpleFitness;
15import ec.simple.SimpleProblemForm;
16import ec.util.MersenneTwisterFast;
17import ec.util.Parameter;
18import ec.util.QuickSort;
19import ec.vector.DoubleVectorIndividual;
20
21/*
22 * MultiObjectiveFitness.java
23 *
24 * Created: Fri Apr 2 09:00:00 2010
25 * By: Faisal Abidi
26 */
27
28/**
29 * The Black Box Optimization workshop (BBOB) has an annual competition for doing real-valued parameter optimization.
30 * The examples shown here are more or less faithful reproductions of the BBOB 2010 C code, only using Mersenne Twister
31 * instead of BBOB's random number generator.  Unfortunately, the original BBOB code has various magic numbers, unexplained
32 * variables, and unfortunate algorithmic decisions.  We've reproduced them exactly rather than attempt to convert to a
33 * standard ECJ template, and simply apologize beforehand.
34 *
35 * <p>
36 * <b>Parameters</b><br>
37 * <table>
38 * <tr>
39 * <td valign=top><i>base</i>.<tt>noise</tt><br>
40 * <font size=-1> String = <tt>none </tt>(default)
41 * <tt>, gauss, uniform, cauchy, gauss-moderate, uniform-moderate, cauchy-moderate</tt>
42 * </font></td>
43 * <td valign=top>(what type of noise (if any) to add to the function value)
44 * <tr>
45 * <td valign=top><i>base</i>.<tt>genome-size</tt><br>
46 * <font size=-1> integer &gt; 0 </tt>
47 * </font></td>
48 * <td valign=top>(genome size)
49 * <tr>
50 * <td valign=top><i>base</i>.<tt>noise</tt><br>
51 * <font size=-1> String = <tt>none </tt>(default)
52 * <tt>, sphere, ellipsoidal, rastrigin, buch-rastrigin, linear-slope, attractive-sector, step-elipsoidal, rosenbrock, rosenbrock-rotated, ellipsoidal-2, discus, bent-cigar, sharp-ridge, different-powers, rastrigin-2,
53 * weierstrass, schaffers-f7, schaffers-f7-2, griewak-rosenbrock, schwefel, gallagher-gaussian-101me, gallagher-gaussian-21hi, katsuura, lunacek</tt>
54 * </font></td>
55 * <td valign=top>(The particular function)
56 * </table>
57 *
58 *
59 * @author Faisal Abidi
60 * @version 1.0
61 */
62
63public class BBOBenchmarks extends Problem implements SimpleProblemForm
64    {
65    public static final String P_GENOME_SIZE = "genome-size";
66    public static final String P_WHICH_PROBLEM = "type";
67    public static final String P_NOISE = "noise";
68
69    final public String[] problemTypes =
70        { "sphere", "ellipsoidal", "rastrigin", "buche-rastrigin", "linear-slope", "attractive-sector", "step-ellipsoidal", "rosenbrock", "rosenbrock-rotated", "ellipsoidal-2", "discus", "bent-cigar", "sharp-ridge", "different-powers", "rastrigin-2",
71          "weierstrass", "schaffers-f7", "schaffers-f7-2", "griewank-rosenbrock", "schwefel", "gallagher-gaussian-101me", "gallagher-gaussian-21hi", "katsuura", "lunacek" };
72
73    final static public int SPHERE = 0;
74    final static public int ELLIPSOIDAL = 1;
75    final static public int RASTRIGIN = 2;
76    final static public int BUCHE_RASTRIGIN = 3;
77    final static public int LINEAR_SLOPE = 4;
78    final static public int ATTRACTIVE_SECTOR = 5;
79    final static public int STEP_ELLIPSOIDAL = 6;
80    final static public int ROSENBROCK = 7;
81    final static public int ROSENBROCK_ROTATED = 8;
82    final static public int ELLIPSOIDAL_2 = 9;
83    final static public int DISCUS = 10;
84    final static public int BENT_CIGAR = 11;
85    final static public int SHARP_RIDGE = 12;
86    final static public int DIFFERENT_POWERS = 13;
87    final static public int RASTRIGIN_2 = 14;
88    final static public int WEIERSTRASS = 15;
89    final static public int SCHAFFERS_F7 = 16;
90    final static public int SCHAFFERS_F7_2 = 17;
91    final static public int GRIEWANK_ROSENBROCK = 18;
92    final static public int SCHWEFEL = 19;
93    final static public int GALLAGHER_GAUSSIAN_101ME = 20;
94    final static public int GALLAGHER_GAUSSIAN_21HI = 21;
95    final static public int KATSUURA = 22;
96    final static public int LUNACEK = 23;
97
98    // Noise types
99    final public String[] noiseTypes =
100        { "none", "gauss", "uniform", "cauchy", "gauss-moderate", "uniform-moderate", "cauchy-moderate" };
101
102    final static public int NONE = 0;
103    final static public int GAUSSIAN = 1;
104    final static public int UNIFORM = 2;
105    final static public int CAUCHY = 3;
106    final static public int GAUSSIAN_MODERATE = 4;
107    final static public int UNIFORM_MODERATE = 5;
108    final static public int CAUCHY_MODERATE = 6;
109
110    public int problemType = 0; // defaults on SPHERE
111
112    public int noise = NONE; // defaults to NONE
113
114    final public int NHIGHPEAKS21 = 101;
115    final public int NHIGHPEAKS22 = 21;
116
117    // DO NOT MODIFY THESE VARIABLES except in the setup method: global
118    // variables are not threadsafe.
119    double fOpt;
120    double[] xOpt;
121    double fAdd_Init;
122
123    double f0;
124    double[][] rotation;
125    double[][] rot2;
126    double[][] linearTF;
127    double[] peaks21;
128    double[] peaks22;
129    int[] rperm;
130    int[] rperm21;
131    int[] rperm22;
132    double[][] xLocal;
133    double[][] xLocal21;
134    double[][] xLocal22;
135    double[][] arrScales;
136    double[][] arrScales21;
137    double[][] arrScales22;
138    double[] aK;
139    double[] bK;
140    double[] peakvalues;
141    double scales;
142
143
144    public void setup(final EvolutionState state, final Parameter base)
145        {
146        super.setup(state, base);
147        String wp = state.parameters.getStringWithDefault(base.push(P_WHICH_PROBLEM), null, "");
148        int i, j, k;
149        Parameter p = new Parameter(Initializer.P_POP);
150        int genomeSize = state.parameters.getInt(p.push(Population.P_SUBPOP).push("0").push(Subpopulation.P_SPECIES).push(P_GENOME_SIZE), null, 1);
151        String noiseStr = state.parameters.getString(new Parameter(P_NOISE), null);
152        for (i = 0; i < noiseTypes.length; i++)
153            if (noiseStr.equals(noiseTypes[i]))
154                noise = i;
155                               
156        double condition = 10.0;
157        double alpha = 100.0;
158        double tmp, tmp2, maxCondition;
159        double[] fitValues = { 1.1, 9.1 };
160
161        double[] arrCondition, peaks, tmpvect;
162
163        for (i = 0; i < problemTypes.length; i++)
164            if (wp.equals(problemTypes[i]))
165                problemType = i;
166
167        // common Initialization
168        fOpt = computeFopt(state.random[0]);
169        xOpt = new double[genomeSize];
170
171        switch (problemType)
172            {
173            case SPHERE:
174                /* INITIALIZATION */
175                computeXopt(xOpt, state.random[0]);
176                break;
177                       
178            case ELLIPSOIDAL: // f2
179                computeXopt(xOpt, state.random[0]);
180                rotation = new double[genomeSize][genomeSize];
181                computeRotation(rotation, state.random[0], genomeSize);
182                if (noise != NONE)
183                    {
184                    rot2 = new double[genomeSize][genomeSize];
185                    computeRotation(rot2, state.random[0], genomeSize);
186                    }
187                break;
188                       
189            case RASTRIGIN:
190                computeXopt(xOpt, state.random[0]);
191                break;
192                       
193            case BUCHE_RASTRIGIN:
194                computeXopt(xOpt, state.random[0]);
195                for (i = 0; i < genomeSize; i += 2)
196                    xOpt[i] = Math.abs(xOpt[i]); /* Skew */
197                break;
198                       
199            case LINEAR_SLOPE:
200                computeXopt(xOpt, state.random[0]);
201                for (i = 0; i < genomeSize; i++)
202                    {
203                    tmp = Math.pow(Math.sqrt(alpha), ((double) i) / ((double) (genomeSize - 1)));
204                    if (xOpt[i] > 0)
205                        {
206                        xOpt[i] = 5.;
207                        }
208                    else if (xOpt[i] < 0)
209                        {
210                        xOpt[i] = -5.;
211                        }
212                    fAdd_Init += 5. * tmp;
213                    }
214                break;
215                       
216            case ATTRACTIVE_SECTOR:
217                rotation = new double[genomeSize][genomeSize];
218                rot2 = new double[genomeSize][genomeSize];
219                linearTF = new double[genomeSize][genomeSize];
220                computeXopt(xOpt, state.random[0]);
221                computeRotation(rotation, state.random[0], genomeSize);
222                computeRotation(rot2, state.random[0], genomeSize);
223                /* decouple scaling from function definition */
224                for (i = 0; i < genomeSize; i++)
225                    {
226                    for (j = 0; j < genomeSize; j++)
227                        {
228                        linearTF[i][j] = 0.0;
229                        for (k = 0; k < genomeSize; k++)
230                            {
231                            linearTF[i][j] += rotation[i][k] * Math.pow(Math.sqrt(condition), ((double) k) / ((double) (genomeSize - 1))) * rot2[k][j];
232                            }
233                        }
234                    }
235                break;
236                       
237            case STEP_ELLIPSOIDAL:
238                rotation = new double[genomeSize][genomeSize];
239                rot2 = new double[genomeSize][genomeSize];
240                computeXopt(xOpt, state.random[0]);
241                computeRotation(rotation, state.random[0], genomeSize);
242                computeRotation(rot2, state.random[0], genomeSize);
243                break;
244                       
245            case ROSENBROCK:
246                computeXopt(xOpt, state.random[0]);
247                scales = Math.max(1.0, Math.sqrt(genomeSize) / 8.0);
248                if (noise == NONE)
249                    for (i = 0; i < genomeSize; i++)
250                        xOpt[i] *= 0.75;
251                break;
252                       
253            case ROSENBROCK_ROTATED:
254                /* INITIALIZATION */
255                linearTF = new double[genomeSize][genomeSize];
256                rotation = new double[genomeSize][genomeSize];
257                /* computeXopt(state.random[0], genomeSize); */
258                computeRotation(rotation, state.random[0], genomeSize);
259                scales = Math.max(1.0, Math.sqrt(genomeSize) / 8.);
260                for (i = 0; i < genomeSize; i++)
261                    {
262                    for (j = 0; j < genomeSize; j++)
263                        linearTF[i][j] = scales * rotation[i][j];
264                    }
265                break;
266                       
267            case ELLIPSOIDAL_2:
268                rotation = new double[genomeSize][genomeSize];
269                computeXopt(xOpt, state.random[0]);
270                computeRotation(rotation, state.random[0], genomeSize);
271                break;
272                       
273            case DISCUS:
274                rotation = new double[genomeSize][genomeSize];
275                computeXopt(xOpt, state.random[0]);
276                computeRotation(rotation, state.random[0], genomeSize);
277                break;
278                       
279            case BENT_CIGAR:
280                rotation = new double[genomeSize][genomeSize];
281                computeXopt(xOpt, state.random[0]);
282                computeRotation(rotation, state.random[0], genomeSize);
283                break;
284                       
285            case SHARP_RIDGE:
286                rotation = new double[genomeSize][genomeSize];
287                rot2 = new double[genomeSize][genomeSize];
288                linearTF = new double[genomeSize][genomeSize];
289                computeXopt(xOpt, state.random[0]);
290                computeRotation(rotation, state.random[0], genomeSize);
291                computeRotation(rot2, state.random[0], genomeSize);
292                for (i = 0; i < genomeSize; i++)
293                    {
294                    for (j = 0; j < genomeSize; j++)
295                        {
296                        linearTF[i][j] = 0.0;
297                        for (k = 0; k < genomeSize; k++)
298                            {
299                            linearTF[i][j] += rotation[i][k] * Math.pow(Math.sqrt(condition), ((double) k) / ((double) (genomeSize - 1))) * rot2[k][j];
300                            }
301                        }
302                    }
303                break;
304                       
305            case DIFFERENT_POWERS:
306                rotation = new double[genomeSize][genomeSize];
307                computeXopt(xOpt, state.random[0]);
308                computeRotation(rotation, state.random[0], genomeSize);
309                break;
310                       
311            case RASTRIGIN_2:
312                rotation = new double[genomeSize][genomeSize];
313                rot2 = new double[genomeSize][genomeSize];
314                linearTF = new double[genomeSize][genomeSize];
315                computeXopt(xOpt, state.random[0]);
316                computeRotation(rotation, state.random[0], genomeSize);
317                computeRotation(rot2, state.random[0], genomeSize);
318                for (i = 0; i < genomeSize; i++)
319                    {
320                    for (j = 0; j < genomeSize; j++)
321                        {
322                        linearTF[i][j] = 0.0;
323                        for (k = 0; k < genomeSize; k++)
324                            {
325                            linearTF[i][j] += rotation[i][k] * Math.pow(Math.sqrt(condition), ((double) k) / ((double) (genomeSize - 1))) * rot2[k][j];
326                            }
327                        }
328                    }
329                break;
330                       
331            case WEIERSTRASS:
332                rotation = new double[genomeSize][genomeSize];
333                rot2 = new double[genomeSize][genomeSize];
334                linearTF = new double[genomeSize][genomeSize];
335                aK = new double[12];
336                bK = new double[12];
337                computeXopt(xOpt, state.random[0]);
338                computeRotation(rotation, state.random[0], genomeSize);
339                computeRotation(rot2, state.random[0], genomeSize);
340
341                for (i = 0; i < genomeSize; i++)
342                    {
343                    for (j = 0; j < genomeSize; j++)
344                        {
345                        linearTF[i][j] = 0.0;
346                        for (k = 0; k < genomeSize; k++)
347                            {
348                            linearTF[i][j] += rotation[i][k] * Math.pow(1.0 / Math.sqrt(condition), ((double) k) / ((double) (genomeSize - 1))) * rot2[k][j];
349                            }
350                        }
351                    }
352
353                f0 = 0.0;
354                for (i = 0; i < 12; i++) /*
355                                          * number of summands, 20 in CEC2005, 10/12
356                                          * saves 30% of time
357                                          */
358                    {
359                    aK[i] = Math.pow(0.5, (double) i);
360                    bK[i] = Math.pow(3., (double) i);
361                    f0 += aK[i] * Math.cos(2 * Math.PI * bK[i] * 0.5);
362                    }
363                break;
364                       
365            case SCHAFFERS_F7:
366                rotation = new double[genomeSize][genomeSize];
367                rot2 = new double[genomeSize][genomeSize];
368                computeXopt(xOpt, state.random[0]);
369                computeRotation(rotation, state.random[0], genomeSize);
370                computeRotation(rot2, state.random[0], genomeSize);
371                break;
372                       
373            case SCHAFFERS_F7_2:
374                rotation = new double[genomeSize][genomeSize];
375                rot2 = new double[genomeSize][genomeSize];
376                linearTF = new double[genomeSize][genomeSize];
377                computeXopt(xOpt, state.random[0]);
378                computeRotation(rotation, state.random[0], genomeSize);
379                computeRotation(rot2, state.random[0], genomeSize);
380                break;
381                       
382            case GRIEWANK_ROSENBROCK:
383                rotation = new double[genomeSize][genomeSize];
384                scales = Math.max(1.0, Math.sqrt(genomeSize) / 8.0);
385                computeRotation(rotation, state.random[0], genomeSize);
386                if (noise == NONE)
387                    {
388                    rot2 = new double[genomeSize][genomeSize];
389                    linearTF = new double[genomeSize][genomeSize];
390                    for (i = 0; i < genomeSize; i++)
391                        {
392                        for (j = 0; j < genomeSize; j++)
393                            {
394                            linearTF[i][j] = scales * rotation[i][j];
395                            }
396                        }
397                    for (i = 0; i < genomeSize; i++)
398                        {
399                        xOpt[i] = 0.0;
400                        for (j = 0; j < genomeSize; j++)
401                            {
402                            xOpt[i] += linearTF[j][i] * 0.5 / scales / scales;
403                            }
404                        }
405                    }
406                else
407                    {
408                    // TODO
409                    }
410                break;
411                       
412            case SCHWEFEL:
413                /* INITIALIZATION */
414                tmpvect = new double[genomeSize];
415
416                for (i = 0; i < genomeSize; i++)
417                    tmpvect[i] = nextDoubleClosedInterval(state.random[0]);
418                for (i = 0; i < genomeSize; i++)
419                    {
420                    xOpt[i] = 0.5 * 4.2096874633;
421                    if (tmpvect[i] - 0.5 < 0)
422                        xOpt[i] *= -1.;
423                    }
424                break;
425                       
426            case GALLAGHER_GAUSSIAN_101ME:
427                rotation = new double[genomeSize][genomeSize];
428                maxCondition = 1000.0;
429                arrCondition = new double[NHIGHPEAKS21];
430                peaks21 = new double[genomeSize * NHIGHPEAKS21];
431                rperm21 = new int[Math.max(genomeSize, NHIGHPEAKS21)];
432                peaks = peaks21;
433                peakvalues = new double[NHIGHPEAKS21];
434                arrScales21 = new double[NHIGHPEAKS21][genomeSize];
435                xLocal21 = new double[genomeSize][NHIGHPEAKS21];
436                computeRotation(rotation, state.random[0], genomeSize);
437
438                for (i = 0; i < NHIGHPEAKS21 - 1; i++)
439                    peaks[i] = nextDoubleClosedInterval(state.random[0]);
440                rperm = rperm21;
441                for (i = 0; i < NHIGHPEAKS21 - 1; i++)
442                    rperm[i] = i;
443                QuickSort.qsort(rperm);
444
445                /* Random permutation */
446
447                arrCondition[0] = Math.sqrt(maxCondition);
448                peakvalues[0] = 10;
449                for (i = 1; i < NHIGHPEAKS21; i++)
450                    {
451                    arrCondition[i] = Math.pow(maxCondition, (double) (rperm[i - 1]) / ((double) (NHIGHPEAKS21 - 2)));
452                    peakvalues[i] = (double) (i - 1) / (double) (NHIGHPEAKS21 - 2) * (fitValues[1] - fitValues[0]) + fitValues[0];
453                    }
454                arrScales = arrScales21;
455                for (i = 0; i < NHIGHPEAKS21; i++)
456                    {
457                    for (j = 0; j < genomeSize; j++)
458                        peaks[j] = nextDoubleClosedInterval(state.random[0]);
459                    for (j = 0; j < genomeSize; j++)
460                        rperm[j] = j;
461                    // qsort(rperm, genomeSize, sizeof(int), compare_doubles);
462                    QuickSort.qsort(rperm);
463                    for (j = 0; j < genomeSize; j++)
464                        {
465                        arrScales[i][j] = Math.pow(arrCondition[i], ((double) rperm[j]) / ((double) (genomeSize - 1)) - 0.5);
466                        }
467                    }
468
469                for (i = 0; i < genomeSize * NHIGHPEAKS21; i++)
470                    peaks[i] = nextDoubleClosedInterval(state.random[0]);
471                xLocal = xLocal21;
472                for (i = 0; i < genomeSize; i++)
473                    {
474                    xOpt[i] = 0.8 * (10. * peaks[i] - 5.);
475                    for (j = 0; j < NHIGHPEAKS21; j++)
476                        {
477                        xLocal[i][j] = 0.0;
478                        for (k = 0; k < genomeSize; k++)
479                            {
480                            xLocal[i][j] += rotation[i][k] * (10. * peaks[j * genomeSize + k] - 5.);
481                            }
482                        if (j == 0)
483                            xLocal[i][j] *= 0.8;
484                        }
485                    }
486                break;
487                       
488            case GALLAGHER_GAUSSIAN_21HI:
489                rotation = new double[genomeSize][genomeSize];
490                maxCondition = 1000.0;
491                arrCondition = new double[NHIGHPEAKS22];
492                peaks22 = new double[genomeSize * NHIGHPEAKS22];
493                rperm22 = new int[Math.max(genomeSize, NHIGHPEAKS22)];
494                arrScales22 = new double[NHIGHPEAKS22][genomeSize];
495                xLocal22 = new double[genomeSize][NHIGHPEAKS22];
496                peaks = peaks22;
497                peakvalues = new double[NHIGHPEAKS22];
498                computeRotation(rotation, state.random[0], genomeSize);
499                peaks = peaks22;
500                for (i = 0; i < NHIGHPEAKS22 - 1; i++)
501                    peaks[i] = nextDoubleClosedInterval(state.random[0]);
502                rperm = rperm22;
503                for (i = 0; i < NHIGHPEAKS22 - 1; i++)
504                    rperm[i] = i;
505                // NOTE: confirm if this is a valid java conversion.
506                QuickSort.qsort(rperm);
507                /* Random permutation */
508                arrCondition[0] = maxCondition;
509                peakvalues[0] = 10;
510                for (i = 1; i < NHIGHPEAKS22; i++)
511                    {
512                    arrCondition[i] = Math.pow(maxCondition, (double) (rperm[i - 1]) / ((double) (NHIGHPEAKS22 - 2)));
513                    peakvalues[i] = (double) (i - 1) / (double) (NHIGHPEAKS22 - 2) * (fitValues[1] - fitValues[0]) + fitValues[0];
514                    }
515                arrScales = arrScales22;
516                for (i = 0; i < NHIGHPEAKS22; i++)
517                    {
518                    for (j = 0; j < genomeSize; j++)
519                        peaks[j] = nextDoubleClosedInterval(state.random[0]);
520                    for (j = 0; j < genomeSize; j++)
521                        rperm[j] = j;
522                    // qsort(rperm, genomeSize, sizeof(int), compare_doubles);
523                    // NOTE: confirm if converted correctly
524                    QuickSort.qsort(rperm);
525                    for (j = 0; j < genomeSize; j++)
526                        {
527                        arrScales[i][j] = Math.pow(arrCondition[i], ((double) rperm[j]) / ((double) (genomeSize - 1)) - 0.5);
528                        }
529                    }
530
531                for (i = 0; i < genomeSize * NHIGHPEAKS22; i++)
532                    peaks[i] = nextDoubleClosedInterval(state.random[0]);
533                xLocal = xLocal22;
534                for (i = 0; i < genomeSize; i++)
535                    {
536                    xOpt[i] = 0.8 * (9.8 * peaks[i] - 4.9);
537                    for (j = 0; j < NHIGHPEAKS22; j++)
538                        {
539                        xLocal[i][j] = 0.0;
540                        for (k = 0; k < genomeSize; k++)
541                            {
542                            xLocal[i][j] += rotation[i][k] * (9.8 * peaks[j * genomeSize + k] - 4.9);
543                            }
544                        if (j == 0)
545                            xLocal[i][j] *= 0.8;
546                        }
547                    }
548                break;
549                       
550            case KATSUURA:
551                rotation = new double[genomeSize][genomeSize];
552                rot2 = new double[genomeSize][genomeSize];
553                linearTF = new double[genomeSize][genomeSize];
554                computeXopt(xOpt, state.random[0]);
555                computeRotation(rotation, state.random[0], genomeSize);
556                computeRotation(rot2, state.random[0], genomeSize);
557                for (i = 0; i < genomeSize; i++)
558                    {
559                    for (j = 0; j < genomeSize; j++)
560                        {
561                        linearTF[i][j] = 0.0;
562                        for (k = 0; k < genomeSize; k++)
563                            {
564                            linearTF[i][j] += rotation[i][k] * Math.pow(Math.sqrt(condition), ((double) k) / (double) (genomeSize - 1)) * rot2[k][j];
565                            }
566                        }
567                    }
568                break;
569                       
570            case LUNACEK:
571                rotation = new double[genomeSize][genomeSize];
572                rot2 = new double[genomeSize][genomeSize];
573                tmpvect = new double[genomeSize];
574                linearTF = new double[genomeSize][genomeSize];
575                double mu1 = 2.5;
576                computeXopt(xOpt, state.random[0]);
577                computeRotation(rotation, state.random[0], genomeSize);
578                computeRotation(rot2, state.random[0], genomeSize);
579                gauss(tmpvect, state.random[0]);
580                for (i = 0; i < genomeSize; i++)
581                    {
582                    xOpt[i] = 0.5 * mu1;
583                    if (tmpvect[i] < 0.)
584                        xOpt[i] *= -1.;
585                    }
586
587                for (i = 0; i < genomeSize; i++)
588                    {
589                    for (j = 0; j < genomeSize; j++)
590                        {
591                        linearTF[i][j] = 0.0;
592                        for (k = 0; k < genomeSize; k++)
593                            {
594                            linearTF[i][j] += rotation[i][k] * Math.pow(Math.sqrt(condition), ((double) k) / ((double) (genomeSize - 1))) * rot2[k][j];
595                            }
596                        }
597                    }
598                break;
599                       
600            default:
601                String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
602                for (i = 0; i < problemTypes.length; i++)
603                    outputStr += problemTypes[i] + "\n";
604                state.output.fatal(outputStr, base.push(P_WHICH_PROBLEM));
605            }
606
607        }
608
609    public void evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
610        {
611        if (!(ind instanceof DoubleVectorIndividual))
612            state.output.fatal("The individuals for this problem should be DoubleVectorIndividuals.");
613        DoubleVectorIndividual temp = (DoubleVectorIndividual) ind;
614        double[] genome = temp.genome;
615        int genomeSize = genome.length;
616        double value = 0;
617        float fit;
618        int i, j;
619        double condition, alpha, beta, tmp = 0.0, tmp2, fAdd, fPen = 0.0, x1, fac, a, f = 0.0, f2;
620        double[] tmx = new double[genomeSize];
621        double[] tmpvect = new double[genomeSize];
622        switch (problemType)
623            {
624            case SPHERE:// f1
625                        /* Sphere function */
626                fAdd = fOpt;
627                if (noise != NONE)
628                    {
629                    for (i = 0; i < genomeSize; i++)
630                        {
631                        tmp = Math.abs(genome[i]) - 5.;
632                        if (tmp > 0.0)
633                            {
634                            fPen += tmp * tmp;
635                            }
636                        }
637                    fAdd += 100. * fPen;
638                    }
639                /* COMPUTATION core */
640                for (i = 0; i < genomeSize; i++)
641                    {
642                    tmp = genome[i] - xOpt[i];
643                    value += tmp * tmp;
644                    }
645                switch (noise)
646                    {
647                    case NONE:
648                        break;
649                    case GAUSSIAN:
650                        value = fGauss(value, 1.0, state.random[threadnum]);
651                        break;
652                    case UNIFORM:
653                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
654                        break;
655                    case CAUCHY:
656                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
657                        break;
658                    case GAUSSIAN_MODERATE:
659                        value = fGauss(value, 0.01, state.random[threadnum]);
660                        break;
661                    case UNIFORM_MODERATE:
662                        value = fUniform(value, 0.01 * (0.49 + 1. / genomeSize), 0.01, state.random[threadnum]);
663                        break;
664                    case CAUCHY_MODERATE:
665                        value = fCauchy(value, 0.01, 0.05, state.random[threadnum]);
666                        break;
667                    default:
668                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
669                        for (i = 0; i < noiseTypes.length; i++)
670                            outputStr += noiseTypes[i] + "\n";
671                        state.output.fatal(outputStr, new Parameter(P_NOISE));
672                        break;
673                    }
674                value += fAdd;
675                fit = (float) (-value);
676                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
677            break;
678                       
679                       
680                       
681            case ELLIPSOIDAL:// f2
682                /*
683                 * separable ellipsoid with monotone transformation with noiseless
684                 * condition 1e6 and noisy condition 1e4
685                 */
686                fAdd = fOpt;
687                if (noise == NONE)
688                    {
689                    condition = 1e6;
690                    for (i = 0; i < genomeSize; i++)
691                        {
692                        tmx[i] = genome[i] - xOpt[i];
693                        }
694                    }
695                else
696                    {
697                    condition = 1e4;
698                    fAdd = fOpt;
699
700                    /* BOUNDARY HANDLING */
701                    for (i = 0; i < genomeSize; i++)
702                        {
703                        tmp = Math.abs(genome[i]) - 5.;
704                        if (tmp > 0.)
705                            {
706                            fPen += tmp * tmp;
707                            }
708                        }
709                    fAdd += 100. * fPen;
710
711                    /* TRANSFORMATION IN SEARCH SPACE */
712                    for (i = 0; i < genomeSize; i++)
713                        {
714                        tmx[i] = 0.;
715                        for (j = 0; j < genomeSize; j++)
716                            {
717                            tmx[i] += rotation[i][j] * (genome[j] - xOpt[j]);
718                            }
719                        }
720                    }
721
722                monotoneTFosc(tmx);
723                /* COMPUTATION core */
724                for (i = 0; i < genomeSize; i++)
725                    {
726                    value += Math.pow(condition, ((double) i) / ((double) (genomeSize - 1))) * tmx[i] * tmx[i];
727                    }
728
729                switch (noise)
730                    {
731                    case NONE:
732                        break;
733                    case GAUSSIAN:
734                        value = fGauss(value, 1.0, state.random[threadnum]);
735                        break;
736                    case UNIFORM:
737                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
738                        break;
739                    case CAUCHY:
740                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
741                        break;
742                    default:
743                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
744                        for (i = 0; i < 4; i++)
745                            outputStr += noiseTypes[i] + "\n";
746                        state.output.fatal(outputStr, new Parameter(P_NOISE));
747                        break;
748                    }
749                value += fAdd;
750                fit = (float) (-value);
751                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
752            break;
753                       
754                       
755
756            case RASTRIGIN:// f3
757                /* Rastrigin with monotone transformation separable "condition" 10 */
758                condition = 10;
759                beta = 0.2;
760                fAdd = fOpt;
761                for (i = 0; i < genomeSize; i++)
762                    {
763                    tmx[i] = genome[i] - xOpt[i];
764                    }
765                monotoneTFosc(tmx);
766                for (i = 0; i < genomeSize; i++)
767                    {
768                    tmp = ((double) i) / ((double) (genomeSize - 1));
769                    if (tmx[i] > 0)
770                        tmx[i] = Math.pow(tmx[i], 1 + beta * tmp * Math.sqrt(tmx[i]));
771                    tmx[i] = Math.pow(Math.sqrt(condition), tmp) * tmx[i];
772                    }
773                /* COMPUTATION core */
774                tmp = 0;
775                tmp2 = 0;
776                for (i = 0; i < genomeSize; i++)
777                    {
778                    tmp += Math.cos(2 * Math.PI * tmx[i]);
779                    tmp2 += tmx[i] * tmx[i];
780                    }
781                value = 10 * (genomeSize - tmp) + tmp2;
782                value += fAdd;
783
784                fit = (float) (-value);
785                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
786            break;
787                       
788                       
789                       
790            case BUCHE_RASTRIGIN:// f4
791                /* skew Rastrigin-Bueche, condition 10, skew-"condition" 100 */
792                condition = 10.0;
793                alpha = 100;
794                fAdd = fOpt;
795                for (i = 0; i < genomeSize; i++)
796                    {
797                    tmp = Math.abs(genome[i]) - 5.;
798                    if (tmp > 0.)
799                        fPen += tmp * tmp;
800                    }
801                fPen *= 1e2;
802                fAdd += fPen;
803
804                for (i = 0; i < genomeSize; i++)
805                    {
806                    tmx[i] = genome[i] - xOpt[i];
807                    }
808
809                monotoneTFosc(tmx);
810                for (i = 0; i < genomeSize; i++)
811                    {
812                    if (i % 2 == 0 && tmx[i] > 0)
813                        tmx[i] = Math.sqrt(alpha) * tmx[i];
814                    tmx[i] = Math.pow(Math.sqrt(condition), ((double) i) / ((double) (genomeSize - 1))) * tmx[i];
815                    }
816                /* COMPUTATION core */
817                tmp = 0.0;
818                tmp2 = 0.0;
819                for (i = 0; i < genomeSize; i++)
820                    {
821                    tmp += Math.cos(2 * Math.PI * tmx[i]);
822                    tmp2 += tmx[i] * tmx[i];
823                    }
824                value = 10 * (genomeSize - tmp) + tmp2;
825                value += fAdd;
826
827                fit = (float) (-value);
828                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
829            break;
830                       
831                       
832                       
833            case LINEAR_SLOPE:// f5
834                /* linear slope */
835                alpha = 100;
836                fAdd = fOpt;
837                /* BOUNDARY HANDLING */
838                /* move "too" good coordinates back into domain */
839                for (i = 0; i < genomeSize; i++)
840                    {
841                    if ((xOpt[i] == 5.) && (genome[i] > 5))
842                        tmx[i] = 5.;
843                    else if ((xOpt[i] == -5.) && (genome[i] < -5))
844                        tmx[i] = -5.;
845                    else
846                        tmx[i] = genome[i];
847                    }
848
849                /* COMPUTATION core */
850                for (i = 0; i < genomeSize; i++)
851                    {
852                    if (xOpt[i] > 0)
853                        {
854                        value -= Math.pow(Math.sqrt(alpha), ((double) i) / ((double) (genomeSize - 1))) * tmx[i];
855                        }
856                    else
857                        {
858                        value += Math.pow(Math.sqrt(alpha), ((double) i) / ((double) (genomeSize - 1))) * tmx[i];
859                        }
860                    }
861                value += fAdd;
862
863                fit = (float) (-value);
864                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
865            break;
866                       
867                       
868                       
869            case ATTRACTIVE_SECTOR:// f6
870                /* attractive sector function */
871                alpha = 100.0;
872                fAdd = fOpt;
873
874                /* BOUNDARY HANDLING */
875                /* TRANSFORMATION IN SEARCH SPACE */
876                for (i = 0; i < genomeSize; i++)
877                    {
878
879                    tmx[i] = 0.0;
880                    for (j = 0; j < genomeSize; j++)
881                        {
882                        tmx[i] += linearTF[i][j] * (genome[j] - xOpt[j]);
883                        }
884                    }
885
886                /* COMPUTATION core */
887                for (i = 0; i < genomeSize; i++)
888                    {
889                    if (tmx[i] * xOpt[i] > 0)
890                        tmx[i] *= alpha;
891                    value += tmx[i] * tmx[i];
892                    }
893
894                /* monotoneTFosc... */
895                if (value > 0)
896                    {
897                    value = Math.pow(Math.exp(Math.log(value) / 0.1 + 0.49 * (Math.sin(Math.log(value) / 0.1) + Math.sin(0.79 * Math.log(value) / 0.1))), 0.1);
898                    }
899                else if (value < 0)
900                    {
901                    value = -Math.pow(Math.exp(Math.log(-value) / 0.1 + 0.49 * (Math.sin(0.55 * Math.log(-value) / 0.1) + Math.sin(0.31 * Math.log(-value) / 0.1))), 0.1);
902                    }
903                value = Math.pow(value, 0.9);
904                value += fAdd;
905                fit = (float) (-value);
906                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
907            break;
908                       
909                       
910                       
911            case STEP_ELLIPSOIDAL:// f7
912                /* step-ellipsoid, condition 100 */
913                condition = 100.0;
914                alpha = 10.0;
915                fAdd = fOpt;
916                /* BOUNDARY HANDLING */
917                for (i = 0; i < genomeSize; i++)
918                    {
919                    tmp = Math.abs(genome[i]) - 5.0;
920                    if (tmp > 0.0)
921                        {
922                        fPen += tmp * tmp;
923                        }
924                    }
925                if (noise == NONE)
926                    fAdd += fPen;
927                else
928                    fAdd += 100. * fPen;
929
930                /* TRANSFORMATION IN SEARCH SPACE */
931                for (i = 0; i < genomeSize; i++)
932                    {
933
934                    tmpvect[i] = 0.0;
935                    tmp = Math.sqrt(Math.pow(condition / 10., ((double) i) / ((double) (genomeSize - 1))));
936                    for (j = 0; j < genomeSize; j++)
937                        {
938                        tmpvect[i] += tmp * rot2[i][j] * (genome[j] - xOpt[j]);
939                        }
940
941                    }
942                x1 = tmpvect[0];
943
944                for (i = 0; i < genomeSize; i++)
945                    {
946                    if (Math.abs(tmpvect[i]) > 0.5)
947                        tmpvect[i] = Math.round(tmpvect[i]);
948                    else
949                        tmpvect[i] = Math.round(alpha * tmpvect[i]) / alpha;
950                    }
951
952                for (i = 0; i < genomeSize; i++)
953                    {
954                    tmx[i] = 0.0;
955                    for (j = 0; j < genomeSize; j++)
956                        {
957                        tmx[i] += rotation[i][j] * tmpvect[j];
958                        }
959                    }
960
961                /* COMPUTATION core */
962                for (i = 0; i < genomeSize; i++)
963                    {
964                    value += Math.pow(condition, ((double) i) / ((double) (genomeSize - 1))) * tmx[i] * tmx[i];
965                    }
966                value = 0.1 * Math.max(1e-4 * Math.abs(x1), value);
967                switch (noise)
968                    {
969                    case NONE:
970                        break;
971                    case GAUSSIAN:
972                        value = fGauss(value, 1.0, state.random[threadnum]);
973                        break;
974                    case UNIFORM:
975                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
976                        break;
977                    case CAUCHY:
978                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
979                        break;
980                    default:
981                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
982                        for (i = 0; i < 4; i++)
983                            outputStr += noiseTypes[i] + "\n";
984                        state.output.fatal(outputStr, new Parameter(P_NOISE));
985                        break;
986                    }
987                value += fAdd;
988                fit = (float) (-value);
989                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
990            break;
991                       
992                       
993                       
994            case ROSENBROCK:// f8
995                /* Rosenbrock, non-rotated */
996                fAdd = fOpt;
997                if (noise == NONE)
998                    {
999                    /* TRANSFORMATION IN SEARCH SPACE */
1000                    for (i = 0; i < genomeSize; i++)
1001                        {
1002                        tmx[i] = scales * (genome[i] - xOpt[i]) + 1;
1003                        }
1004                    }
1005                else
1006                    {
1007                    /* BOUNDARY HANDLING */
1008                    for (i = 0; i < genomeSize; i++)
1009                        {
1010                        tmp = Math.abs(genome[i]) - 5.;
1011                        if (tmp > 0.)
1012                            {
1013                            fPen += tmp * tmp;
1014                            }
1015                        }
1016                    fAdd += 100.0 * fPen;
1017                    /* TRANSFORMATION IN SEARCH SPACE */
1018                    for (i = 0; i < genomeSize; i++)
1019                        {
1020                        tmx[i] = scales * (genome[i] - 0.75 * xOpt[i]) + 1;
1021                        }
1022                    }
1023
1024                /* COMPUTATION core */
1025                for (i = 0; i < genomeSize - 1; i++)
1026                    {
1027                    tmp = (tmx[i] * tmx[i] - tmx[i + 1]);
1028                    value += tmp * tmp;
1029                    }
1030                value *= 1e2;
1031                for (i = 0; i < genomeSize - 1; i++)
1032                    {
1033                    tmp = (tmx[i] - 1.);
1034                    value += tmp * tmp;
1035                    }
1036
1037                switch (noise)
1038                    {
1039                    case NONE:
1040                        break;
1041                    case GAUSSIAN:
1042                        value = fGauss(value, 1.0, state.random[threadnum]);
1043                        break;
1044                    case UNIFORM:
1045                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
1046                        break;
1047                    case CAUCHY:
1048                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
1049                        break;
1050                    case GAUSSIAN_MODERATE:
1051                        value = fGauss(value, 0.01, state.random[threadnum]);
1052                        break;
1053                    case UNIFORM_MODERATE:
1054                        value = fUniform(value, 0.01 * (0.49 + 1. / genomeSize), 0.01, state.random[threadnum]);
1055                        break;
1056                    case CAUCHY_MODERATE:
1057                        value = fCauchy(value, 0.01, 0.05, state.random[threadnum]);
1058                        break;
1059                    default:
1060                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
1061                        for (i = 0; i < noiseTypes.length; i++)
1062                            outputStr += noiseTypes[i] + "\n";
1063                        state.output.fatal(outputStr, new Parameter(P_NOISE));
1064                        break;
1065                    }                       
1066                       
1067                value += fAdd;
1068
1069                fit = (float) (-value);
1070                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1071            break;
1072
1073                       
1074                       
1075                       
1076            case ROSENBROCK_ROTATED:// f9
1077                /* Rosenbrock, rotated */
1078                fAdd = fOpt;
1079
1080                /* BOUNDARY HANDLING */
1081
1082                /* TRANSFORMATION IN SEARCH SPACE */
1083                for (i = 0; i < genomeSize; i++)
1084                    {
1085                    tmx[i] = 0.5;
1086                    for (j = 0; j < genomeSize; j++)
1087                        {
1088                        tmx[i] += linearTF[i][j] * genome[j];
1089                        }
1090                    }
1091
1092                /* COMPUTATION core */
1093                for (i = 0; i < genomeSize - 1; i++)
1094                    {
1095                    tmp = (tmx[i] * tmx[i] - tmx[i + 1]);
1096                    value += tmp * tmp;
1097                    }
1098                value *= 1e2;
1099                for (i = 0; i < genomeSize - 1; i++)
1100                    {
1101                    tmp = (tmx[i] - 1.);
1102                    value += tmp * tmp;
1103                    }
1104
1105                value += fAdd;
1106                fit = (float) (-value);
1107                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1108            break;
1109                       
1110                       
1111                       
1112            case ELLIPSOIDAL_2:// f10
1113                /* ellipsoid with monotone transformation, condition 1e6 */
1114                condition = 1e6;
1115
1116                fAdd = fOpt;
1117                /* BOUNDARY HANDLING */
1118
1119                /* TRANSFORMATION IN SEARCH SPACE */
1120                for (i = 0; i < genomeSize; i++)
1121                    {
1122                    tmx[i] = 0.0;
1123                    for (j = 0; j < genomeSize; j++)
1124                        {
1125                        tmx[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1126                        }
1127                    }
1128
1129                monotoneTFosc(tmx);
1130                /* COMPUTATION core */
1131                for (i = 0; i < genomeSize; i++)
1132                    {
1133                    fAdd += Math.pow(condition, ((double) i) / ((double) (genomeSize - 1))) * tmx[i] * tmx[i];
1134                    }
1135                value = fAdd;
1136                fit = (float) (-value);
1137                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1138            break;
1139                       
1140                       
1141                       
1142            case DISCUS:// f11
1143                        /* DISCUS (tablet) with monotone transformation, condition 1e6 */
1144                condition = 1e6;
1145                fAdd = fOpt;
1146                /* BOUNDARY HANDLING */
1147
1148                /* TRANSFORMATION IN SEARCH SPACE */
1149                for (i = 0; i < genomeSize; i++)
1150                    {
1151                    tmx[i] = 0.0;
1152                    for (j = 0; j < genomeSize; j++)
1153                        {
1154                        tmx[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1155                        }
1156                    }
1157
1158                monotoneTFosc(tmx);
1159
1160                /* COMPUTATION core */
1161                value = condition * tmx[0] * tmx[0];
1162                for (i = 1; i < genomeSize; i++)
1163                    {
1164                    value += tmx[i] * tmx[i];
1165                    }
1166                value += fAdd; /* without noise */
1167                fit = (float) (-value);
1168                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1169            break;
1170                       
1171                       
1172                       
1173            case BENT_CIGAR:// f12
1174                /* bent cigar with asymmetric space distortion, condition 1e6 */
1175                condition = 1e6;
1176                beta = 0.5;
1177                fAdd = fOpt;
1178                /* BOUNDARY HANDLING */
1179
1180                /* TRANSFORMATION IN SEARCH SPACE */
1181                for (i = 0; i < genomeSize; i++)
1182                    {
1183                    tmpvect[i] = 0.0;
1184                    for (j = 0; j < genomeSize; j++)
1185                        {
1186                        tmpvect[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1187                        }
1188                    if (tmpvect[i] > 0)
1189                        {
1190                        tmpvect[i] = Math.pow(tmpvect[i], 1 + beta * ((double) i) / ((double) (genomeSize - 1)) * Math.sqrt(tmpvect[i]));
1191                        }
1192                    }
1193
1194                for (i = 0; i < genomeSize; i++)
1195                    {
1196                    tmx[i] = 0.0;
1197                    for (j = 0; j < genomeSize; j++)
1198                        {
1199                        tmx[i] += rotation[i][j] * tmpvect[j];
1200                        }
1201                    }
1202
1203                /* COMPUTATION core */
1204                value = tmx[0] * tmx[0];
1205                for (i = 1; i < genomeSize; i++)
1206                    {
1207                    value += condition * tmx[i] * tmx[i];
1208                    }
1209                value += fAdd;
1210                fit = (float) (-value);
1211                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1212            break;
1213                       
1214                       
1215                       
1216            case SHARP_RIDGE:// f13
1217                /* sharp ridge */
1218                condition = 10.0;
1219                alpha = 100.0;
1220
1221                fAdd = fOpt;
1222                /* BOUNDARY HANDLING */
1223
1224                /* TRANSFORMATION IN SEARCH SPACE */
1225                for (i = 0; i < genomeSize; i++)
1226                    {
1227                    tmx[i] = 0.0;
1228                    for (j = 0; j < genomeSize; j++)
1229                        {
1230                        tmx[i] += linearTF[i][j] * (genome[j] - xOpt[j]);
1231                        }
1232                    }
1233
1234                /* COMPUTATION core */
1235                for (i = 1; i < genomeSize; i++)
1236                    {
1237                    value += tmx[i] * tmx[i];
1238                    }
1239                value = alpha * Math.sqrt(value);
1240                value += tmx[0] * tmx[0];
1241                value += fAdd;
1242                fit = (float) (-value);
1243                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1244            break;
1245                       
1246                       
1247                       
1248            case DIFFERENT_POWERS:// f14
1249                /* sum of different powers, between x^2 and x^6 */
1250                alpha = 4.0;
1251                fAdd = fOpt;
1252                if (noise != NONE)
1253                    {
1254                    /* BOUNDARY HANDLING */
1255                    for (i = 0; i < genomeSize; i++)
1256                        {
1257                        tmp = Math.abs(genome[i]) - 5.;
1258                        if (tmp > 0.)
1259                            {
1260                            fPen += tmp * tmp;
1261                            }
1262                        }
1263                    fAdd += 100. * fPen;
1264                    }
1265
1266                /* TRANSFORMATION IN SEARCH SPACE */
1267                for (i = 0; i < genomeSize; i++)
1268                    {
1269                    tmx[i] = 0.0;
1270                    for (j = 0; j < genomeSize; j++)
1271                        {
1272                        tmx[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1273                        }
1274                    }
1275
1276                /* COMPUTATION core */
1277                for (i = 0; i < genomeSize; i++)
1278                    {
1279                    value += Math.pow(Math.abs(tmx[i]), 2. + alpha * ((double) i) / ((double) (genomeSize - 1)));
1280                    }
1281                value = Math.sqrt(value);
1282                switch (noise)
1283                    {
1284                    case NONE:
1285                        break;
1286                    case GAUSSIAN:
1287                        value = fGauss(value, 1.0, state.random[threadnum]);
1288                        break;
1289                    case UNIFORM:
1290                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
1291                        break;
1292                    case CAUCHY:
1293                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
1294                        break;
1295                    default:
1296                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
1297                        for (i = 0; i < 4; i++)
1298                            outputStr += noiseTypes[i] + "\n";
1299                        state.output.fatal(outputStr, new Parameter(P_NOISE));
1300                        break;
1301                    }
1302                value += fAdd;
1303                fit = (float) (-value);
1304                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1305            break;
1306                       
1307                       
1308                       
1309            case RASTRIGIN_2:// f15
1310                /* Rastrigin with asymmetric non-linear distortion, "condition" 10 */
1311                condition = 10.0;
1312                beta = 0.2;
1313                tmp = tmp2 = 0;
1314
1315                fAdd = fOpt;
1316                /* BOUNDARY HANDLING */
1317
1318                /* TRANSFORMATION IN SEARCH SPACE */
1319                for (i = 0; i < genomeSize; i++)
1320                    {
1321                    tmpvect[i] = 0.0;
1322                    for (j = 0; j < genomeSize; j++)
1323                        {
1324                        tmpvect[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1325                        }
1326                    }
1327
1328                monotoneTFosc(tmpvect);
1329                for (i = 0; i < genomeSize; i++)
1330                    {
1331                    if (tmpvect[i] > 0)
1332                        tmpvect[i] = Math.pow(tmpvect[i], 1 + beta * ((double) i) / ((double) (genomeSize - 1)) * Math.sqrt(tmpvect[i]));
1333                    }
1334                for (i = 0; i < genomeSize; i++)
1335                    {
1336                    tmx[i] = 0.0;
1337                    for (j = 0; j < genomeSize; j++)
1338                        {
1339                        tmx[i] += linearTF[i][j] * tmpvect[j];
1340                        }
1341                    }
1342                /* COMPUTATION core */
1343                for (i = 0; i < genomeSize; i++)
1344                    {
1345                    tmp += Math.cos(2. * Math.PI * tmx[i]);
1346                    tmp2 += tmx[i] * tmx[i];
1347                    }
1348                value = 10. * ((double) genomeSize - tmp) + tmp2;
1349                value += fAdd;
1350                fit = (float) (-value);
1351                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1352            break;
1353                       
1354                       
1355                       
1356            case WEIERSTRASS:// f16
1357                /* Weierstrass, condition 100 */
1358                condition = 100.0;
1359                fPen = 0;
1360
1361                fAdd = fOpt;
1362
1363                /* BOUNDARY HANDLING */
1364                for (i = 0; i < genomeSize; i++)
1365                    {
1366                    tmp = Math.abs(genome[i]) - 5.;
1367                    if (tmp > 0.)
1368                        {
1369                        fPen += tmp * tmp;
1370                        }
1371                    }
1372                fAdd += 10. / (double) genomeSize * fPen;
1373
1374                /* TRANSFORMATION IN SEARCH SPACE */
1375                for (i = 0; i < genomeSize; i++)
1376                    {
1377                    tmpvect[i] = 0.0;
1378                    for (j = 0; j < genomeSize; j++)
1379                        {
1380                        tmpvect[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1381                        }
1382                    }
1383
1384                monotoneTFosc(tmpvect);
1385                for (i = 0; i < genomeSize; i++)
1386                    {
1387                    tmx[i] = 0.0;
1388                    for (j = 0; j < genomeSize; j++)
1389                        {
1390                        tmx[i] += linearTF[i][j] * tmpvect[j];
1391                        }
1392                    }
1393                /* COMPUTATION core */
1394                for (i = 0; i < genomeSize; i++)
1395                    {
1396                    tmp = 0.0;
1397                    for (j = 0; j < 12; j++)
1398                        {
1399                        tmp += Math.cos(2 * Math.PI * (tmx[i] + 0.5) * bK[j]) * aK[j];
1400                        }
1401                    value += tmp;
1402                    }
1403                value = 10. * Math.pow(value / (double) genomeSize - f0, 3.);
1404                value += fAdd;
1405                ;
1406
1407                fit = (float) (-value);
1408                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1409            break;
1410                       
1411                       
1412                       
1413            case SCHAFFERS_F7:// f17
1414                /*
1415                 * Schaffers F7 with asymmetric non-linear transformation, condition
1416                 * 10
1417                 */
1418                condition = 10.0;
1419                beta = 0.5;
1420                fAdd = fOpt;
1421
1422                /* BOUNDARY HANDLING */
1423                for (i = 0; i < genomeSize; i++)
1424                    {
1425                    tmp = Math.abs(genome[i]) - 5.;
1426                    if (tmp > 0.)
1427                        {
1428                        fPen += tmp * tmp;
1429                        }
1430                    }
1431                fAdd += 10. * fPen;
1432
1433                /* TRANSFORMATION IN SEARCH SPACE */
1434                for (i = 0; i < genomeSize; i++)
1435                    {
1436                    tmpvect[i] = 0.0;
1437                    for (j = 0; j < genomeSize; j++)
1438                        {
1439                        tmpvect[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1440                        }
1441                    if (tmpvect[i] > 0)
1442                        tmpvect[i] = Math.pow(tmpvect[i], 1 + beta * ((double) i) / ((double) (genomeSize - 1)) * Math.sqrt(tmpvect[i]));
1443                    }
1444
1445                for (i = 0; i < genomeSize; i++)
1446                    {
1447                    tmx[i] = 0.0;
1448                    tmp = Math.pow(Math.sqrt(condition), ((double) i) / ((double) (genomeSize - 1)));
1449                    for (j = 0; j < genomeSize; j++)
1450                        {
1451                        tmx[i] += tmp * rot2[i][j] * tmpvect[j];
1452                        }
1453                    }
1454
1455                /* COMPUTATION core */
1456                for (i = 0; i < genomeSize - 1; i++)
1457                    {
1458                    tmp = tmx[i] * tmx[i] + tmx[i + 1] * tmx[i + 1];
1459                    value += Math.pow(tmp, 0.25) * (Math.pow(Math.sin(50 * Math.pow(tmp, 0.1)), 2.0) + 1.0);
1460                    }
1461                value = Math.pow(value / (double) (genomeSize - 1), 2.);
1462                switch (noise)
1463                    {
1464                    case NONE:
1465                        break;
1466                    case GAUSSIAN:
1467                        value = fGauss(value, 1.0, state.random[threadnum]);
1468                        break;
1469                    case UNIFORM:
1470                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
1471                        break;
1472                    case CAUCHY:
1473                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
1474                        break;
1475                    default:
1476                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
1477                        for (i = 0; i < 4; i++)
1478                            outputStr += noiseTypes[i] + "\n";
1479                        state.output.fatal(outputStr, new Parameter(P_NOISE));
1480                        break;
1481                    }
1482                value += fAdd;
1483                fit = (float) (-value);
1484                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1485            break;
1486                       
1487                       
1488                       
1489            case SCHAFFERS_F7_2:// f18
1490                /*
1491                 * Schaffers F7 with asymmetric non-linear transformation, condition
1492                 * 1000
1493                 */
1494                condition = 1e3;
1495                beta = 0.5;
1496                fPen = 0.0;
1497                fAdd = fOpt;
1498                /* BOUNDARY HANDLING */
1499                for (i = 0; i < genomeSize; i++)
1500                    {
1501                    tmp = Math.abs(genome[i]) - 5.;
1502                    if (tmp > 0.)
1503                        {
1504                        fPen += tmp * tmp;
1505                        }
1506                    }
1507                fAdd += 10. * fPen;
1508
1509                /* TRANSFORMATION IN SEARCH SPACE */
1510                for (i = 0; i < genomeSize; i++)
1511                    {
1512                    tmpvect[i] = 0.0;
1513                    for (j = 0; j < genomeSize; j++)
1514                        {
1515                        tmpvect[i] += rotation[i][j] * (genome[j] - xOpt[j]);
1516                        }
1517                    if (tmpvect[i] > 0)
1518                        tmpvect[i] = Math.pow(tmpvect[i], 1. + beta * ((double) i) / ((double) (genomeSize - 1)) * Math.sqrt(tmpvect[i]));
1519                    }
1520
1521                for (i = 0; i < genomeSize; i++)
1522                    {
1523                    tmx[i] = 0.0;
1524                    tmp = Math.pow(Math.sqrt(condition), ((double) i) / ((double) (genomeSize - 1)));
1525                    for (j = 0; j < genomeSize; j++)
1526                        {
1527                        tmx[i] += tmp * rot2[i][j] * tmpvect[j];
1528                        }
1529                    }
1530
1531                /* COMPUTATION core */
1532                for (i = 0; i < genomeSize - 1; i++)
1533                    {
1534                    tmp = tmx[i] * tmx[i] + tmx[i + 1] * tmx[i + 1];
1535                    value += Math.pow(tmp, 0.25) * (Math.pow(Math.sin(50. * Math.pow(tmp, 0.1)), 2.) + 1.);
1536                    }
1537                value = Math.pow(value / (double) (genomeSize - 1), 2.);
1538                value += fAdd;
1539                fit = (float) (-value);
1540                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1541            break;
1542                       
1543                       
1544                       
1545            case GRIEWANK_ROSENBROCK:// f19
1546                /* F8f2 sum of Griewank-Rosenbrock 2-D blocks */
1547                fAdd = fOpt;
1548                if (noise == NONE)
1549                    {
1550                    /* TRANSFORMATION IN SEARCH SPACE */
1551                    for (i = 0; i < genomeSize; i++)
1552                        {
1553                        tmx[i] = 0.5;
1554                        for (j = 0; j < genomeSize; j++)
1555                            {
1556                            tmx[i] += linearTF[i][j] * genome[j];
1557                            }
1558                        }
1559                    /* COMPUTATION core */
1560                    for (i = 0; i < genomeSize - 1; i++)
1561                        {
1562                        tmp2 = tmx[i] * tmx[i] - tmx[i + 1];
1563                        f2 = 100. * tmp2 * tmp2;
1564                        tmp2 = 1 - tmx[i];
1565                        f2 += tmp2 * tmp2;
1566                        tmp += f2 / 4000. - Math.cos(f2);
1567                        }
1568                    value = 10. + 10. * tmp / (double) (genomeSize - 1);
1569                    }
1570                else
1571                    {
1572                    /* BOUNDARY HANDLING */
1573                    for (i = 0; i < genomeSize; i++)
1574                        {
1575                        tmp = Math.abs(genome[i]) - 5.0;
1576                        if (tmp > 0.0)
1577                            {
1578                            fPen += tmp * tmp;
1579                            }
1580                        }
1581                    fAdd += 100.0 * fPen;
1582
1583                    /* TRANSFORMATION IN SEARCH SPACE */
1584                    for (i = 0; i < genomeSize; i++)
1585                        {
1586                        tmx[i] = 0.5;
1587                        for (j = 0; j < genomeSize; j++)
1588                            {
1589                            tmx[i] += scales * rotation[i][j] * genome[j];
1590                            }
1591                        }
1592                    /* COMPUTATION core */
1593                    tmp = 0.;
1594                    for (i = 0; i < genomeSize - 1; i++)
1595                        {
1596                        f2 = 100. * (tmx[i] * tmx[i] - tmx[i + 1]) * (tmx[i] * tmx[i] - tmx[i + 1]) + (1 - tmx[i]) * (1 - tmx[i]);
1597                        tmp += f2 / 4000. - Math.cos(f2);
1598                        }
1599                    value = 1. + 1. * tmp / (double) (genomeSize - 1);
1600                    }
1601                switch (noise)
1602                    {
1603                    case NONE:
1604                        break;
1605                    case GAUSSIAN:
1606                        value = fGauss(value, 1.0, state.random[threadnum]);
1607                        break;
1608                    case UNIFORM:
1609                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
1610                        break;
1611                    case CAUCHY:
1612                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
1613                        break;
1614                    default:
1615                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
1616                        for (i = 0; i < 4; i++)
1617                            outputStr += noiseTypes[i] + "\n";
1618                        state.output.fatal(outputStr, new Parameter(P_NOISE));
1619                        break;
1620                    }
1621                value += fAdd;
1622                fit = (float) (-value);
1623                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1624            break;
1625                       
1626                       
1627                       
1628            case SCHWEFEL:// f20
1629                /* Schwefel with tridiagonal variable transformation */
1630                condition = 10.0;
1631                fPen = 0.0;
1632                fAdd = fOpt;
1633
1634                /* TRANSFORMATION IN SEARCH SPACE */
1635                for (i = 0; i < genomeSize; i++)
1636                    {
1637                    tmpvect[i] = 2. * genome[i];
1638                    if (xOpt[i] < 0.)
1639                        tmpvect[i] *= -1.;
1640                    }
1641
1642                tmx[0] = tmpvect[0];
1643                for (i = 1; i < genomeSize; i++)
1644                    {
1645                    tmx[i] = tmpvect[i] + 0.25 * (tmpvect[i - 1] - 2. * Math.abs(xOpt[i - 1]));
1646                    }
1647
1648                for (i = 0; i < genomeSize; i++)
1649                    {
1650                    tmx[i] -= 2 * Math.abs(xOpt[i]);
1651                    tmx[i] *= Math.pow(Math.sqrt(condition), ((double) i) / ((double) (genomeSize - 1)));
1652                    tmx[i] = 100. * (tmx[i] + 2 * Math.abs(xOpt[i]));
1653                    }
1654
1655                /* BOUNDARY HANDLING */
1656                for (i = 0; i < genomeSize; i++)
1657                    {
1658                    tmp = Math.abs(tmx[i]) - 500.0;
1659                    if (tmp > 0.)
1660                        {
1661                        fPen += tmp * tmp;
1662                        }
1663                    }
1664                fAdd += 0.01 * fPen;
1665
1666                /* COMPUTATION core */
1667                for (i = 0; i < genomeSize; i++)
1668                    {
1669                    value += tmx[i] * Math.sin(Math.sqrt(Math.abs(tmx[i])));
1670                    }
1671                value = 0.01 * ((418.9828872724339) - value / (double) genomeSize);
1672                value += fAdd;/* without noise */
1673                fit = (float) (-value);
1674                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1675            break;
1676                       
1677                       
1678                       
1679            case GALLAGHER_GAUSSIAN_101ME:// f21
1680                /*
1681                 * Gallagher with 101 Gaussian peaks, condition up to 1000, one
1682                 * global rotation
1683                 */
1684                a = 0.1;
1685                fac = -0.5 / (double) genomeSize;
1686                fAdd = fOpt;
1687
1688                /* BOUNDARY HANDLING */
1689                for (i = 0; i < genomeSize; i++)
1690                    {
1691                    tmp = Math.abs(genome[i]) - 5.;
1692                    if (tmp > 0.)
1693                        {
1694                        fPen += tmp * tmp;
1695                        }
1696                    }
1697                if (noise == NONE)
1698                    fAdd += fPen;
1699                else
1700                    fAdd += 100. * fPen;
1701
1702                /* TRANSFORMATION IN SEARCH SPACE */
1703                for (i = 0; i < genomeSize; i++)
1704                    {
1705                    tmx[i] = 0.0;
1706                    for (j = 0; j < genomeSize; j++)
1707                        {
1708                        tmx[i] += rotation[i][j] * genome[j];
1709                        }
1710                    }
1711
1712                /* COMPUTATION core */
1713                if (noise == NONE)
1714                    for (i = 0; i < NHIGHPEAKS21; i++)
1715                        {
1716                        tmp2 = 0.0;
1717                        for (j = 0; j < genomeSize; j++)
1718                            {
1719                            tmp = (tmx[j] - xLocal[j][i]);
1720                            tmp2 += arrScales[i][j] * tmp * tmp;
1721                            }
1722                        tmp2 = peakvalues[i] * Math.exp(fac * tmp2);
1723                        f = Math.max(f, tmp2);
1724                        }
1725                else
1726                    /* COMPUTATION core */
1727                    for (i = 0; i < NHIGHPEAKS21; i++)
1728                        {
1729                        tmp2 = 0.;
1730                        for (j = 0; j < genomeSize; j++)
1731                            {
1732                            tmp2 += arrScales[i][j] * (tmx[j] - xLocal[j][i]) * (tmx[j] - xLocal[j][i]);
1733                            }
1734                        tmp2 = peakvalues[i] * Math.exp(fac * tmp2);
1735                        f = Math.max(f, tmp2);
1736                        }
1737
1738                f = 10.0 - f;
1739                /* monotoneTFosc */
1740                if (f > 0)
1741                    {
1742                    value = Math.log(f) / a;
1743                    value = Math.pow(Math.exp(value + 0.49 * (Math.sin(value) + Math.sin(0.79 * value))), a);
1744                    }
1745                else if (f < 0)
1746                    {
1747                    value = Math.log(-f) / a;
1748                    value = -Math.pow(Math.exp(value + 0.49 * (Math.sin(0.55 * value) + Math.sin(0.31 * value))), a);
1749                    }
1750                else
1751                    value = f;
1752
1753                value *= value;
1754                switch (noise)
1755                    {
1756                    case NONE:
1757                        break;
1758                    case GAUSSIAN:
1759                        value = fGauss(value, 1.0, state.random[threadnum]);
1760                        break;
1761                    case UNIFORM:
1762                        value = fUniform(value, 0.49 + 1.0 / genomeSize, 1.0, state.random[threadnum]);
1763                        break;
1764                    case CAUCHY:
1765                        value = fCauchy(value, 1.0, 0.2, state.random[threadnum]);
1766                        break;
1767                    default:
1768                        String outputStr = "Invalid value for parameter, or parameter not found.\n" + "Acceptable values are:\n";
1769                        for (i = 0; i < 4; i++)
1770                            outputStr += noiseTypes[i] + "\n";
1771                        state.output.fatal(outputStr, new Parameter(P_NOISE));
1772                        break;
1773                    }
1774                value += fAdd;
1775                ; /* without noise */
1776
1777                fit = (float) (-value);
1778                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1779            break;
1780                       
1781                       
1782                       
1783            case GALLAGHER_GAUSSIAN_21HI:// f22
1784                /*
1785                 * Gallagher with 21 Gaussian peaks, condition up to 1000, one
1786                 * global rotation
1787                 */
1788                a = 0.1;
1789                f = 0;
1790                fac = -0.5 / (double) genomeSize;
1791                fPen = 0.0;
1792
1793                fAdd = fOpt;
1794
1795                /* BOUNDARY HANDLING */
1796                for (i = 0; i < genomeSize; i++)
1797                    {
1798                    tmp = Math.abs(genome[i]) - 5.;
1799                    if (tmp > 0.)
1800                        {
1801                        fPen += tmp * tmp;
1802                        }
1803                    }
1804                fAdd += fPen;
1805
1806                /* TRANSFORMATION IN SEARCH SPACE */
1807                for (i = 0; i < genomeSize; i++)
1808                    {
1809                    tmx[i] = 0.0;
1810                    for (j = 0; j < genomeSize; j++)
1811                        {
1812                        tmx[i] += rotation[i][j] * genome[j];
1813                        }
1814                    }
1815
1816                /* COMPUTATION core */
1817                for (i = 0; i < NHIGHPEAKS22; i++)
1818                    {
1819                    tmp2 = 0.0;
1820                    for (j = 0; j < genomeSize; j++)
1821                        {
1822                        tmp = (tmx[j] - xLocal[j][i]);
1823                        tmp2 += arrScales[i][j] * tmp * tmp;
1824                        }
1825                    tmp2 = peakvalues[i] * Math.exp(fac * tmp2);
1826                    f = Math.max(f, tmp2);
1827                    }
1828
1829                f = 10. - f;
1830                if (f > 0)
1831                    {
1832                    value = Math.log(f) / a;
1833                    value = Math.pow(Math.exp(value + 0.49 * (Math.sin(value) + Math.sin(0.79 * value))), a);
1834                    }
1835                else if (f < 0)
1836                    {
1837                    value = Math.log(-f) / a;
1838                    value = -Math.pow(Math.exp(value + 0.49 * (Math.sin(0.55 * value) + Math.sin(0.31 * value))), a);
1839                    }
1840                else
1841                    value = f;
1842
1843                value *= value;
1844                value += fAdd;
1845                ; /* without noise */
1846
1847                fit = (float) (-value);
1848                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1849            break;
1850                       
1851                       
1852                       
1853            case KATSUURA:// f23
1854                /* Katsuura function */
1855                condition = 100.0;
1856                fAdd = 0;
1857                fPen = 0;
1858                double arr;
1859                double prod = 1.0;
1860                double[] ptmx,
1861                    plinTF,
1862                    ptmp;
1863
1864                fAdd = fOpt;
1865
1866                /* BOUNDARY HANDLING */
1867                for (i = 0; i < genomeSize; i++)
1868                    {
1869                    tmp = Math.abs(genome[i]) - 5.;
1870                    if (tmp > 0.)
1871                        {
1872                        fPen += tmp * tmp;
1873                        }
1874                    }
1875                fAdd += fPen;
1876
1877                /* TRANSFORMATION IN SEARCH SPACE */
1878                /* write rotated difference vector into tmx */
1879                for (j = 0; j < genomeSize; j++)
1880                    /* store difference vector */
1881                    tmpvect[j] = genome[j] - xOpt[j];
1882                for (i = 0; i < genomeSize; i++)
1883                    {
1884                    tmx[i] = 0.0;
1885                    ptmx = tmx;
1886                    plinTF = linearTF[i];
1887                    ptmp = tmpvect;
1888                    for (j = 0; j < genomeSize; j++)
1889                        {
1890                        // *ptmx += *plinTF++ * *ptmp++;
1891                        ptmx[j] += plinTF[j] * ptmp[j];
1892                        }
1893                    }
1894
1895                /*
1896                 * for (i = 0; i < genomeSize; i++) { tmx[i] = 0.0; for (j = 0; j <
1897                 * genomeSize; j++) { tmx[i] += linearTF[i][j] * (genome[j] -
1898                 * xOpt[j]); } }
1899                 */
1900
1901                /* COMPUTATION core */
1902                for (i = 0; i < genomeSize; i++)
1903                    {
1904                    tmp = 0.0;
1905                    for (j = 1; j < 33; j++)
1906                        {
1907                        tmp2 = Math.pow(2., (double) j);
1908                        arr = tmx[i] * tmp2;
1909                        tmp += Math.abs(arr - Math.round(arr)) / tmp2;
1910                        }
1911                    tmp = 1. + tmp * (double) (i + 1);
1912                    prod *= tmp;
1913                    }
1914                value = 10. / (double) genomeSize / (double) genomeSize * (-1. + Math.pow(prod, 10. / Math.pow((double) genomeSize, 1.2)));
1915                value += fAdd;
1916                fit = (float) (-value);
1917                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1918            break;
1919                       
1920                       
1921                       
1922            case LUNACEK:// f24
1923                /* Lunacek bi-Rastrigin, condition 100 */
1924                /* in PPSN 2008, Rastrigin part rotated and scaled */
1925                condition = 100.0;
1926                double mu1 = 2.5;
1927                double tmp3,
1928                    tmp4;
1929                fPen = tmp2 = tmp3 = tmp4 = 0.0;
1930                double s = 1. - 0.5 / (Math.sqrt((double) (genomeSize + 20)) - 4.1);
1931                double d = 1.;
1932                double mu2 = -Math.sqrt((mu1 * mu1 - d) / s);
1933
1934                fAdd = fOpt;
1935
1936                /* BOUNDARY HANDLING */
1937                for (i = 0; i < genomeSize; i++)
1938                    {
1939                    tmp = Math.abs(genome[i]) - 5.;
1940                    if (tmp > 0.)
1941                        {
1942                        fPen += tmp * tmp;
1943                        }
1944                    }
1945                fAdd += 1e4 * fPen;
1946
1947                /* TRANSFORMATION IN SEARCH SPACE */
1948                for (i = 0; i < genomeSize; i++)
1949                    {
1950                    tmx[i] = 2. * genome[i];
1951                    if (xOpt[i] < 0.)
1952                        tmx[i] *= -1.;
1953                    }
1954
1955                /* COMPUTATION core */
1956                tmp = 0.0;
1957                for (i = 0; i < genomeSize; i++)
1958                    {
1959                    tmp2 += (tmx[i] - mu1) * (tmx[i] - mu1);
1960                    tmp3 += (tmx[i] - mu2) * (tmx[i] - mu2);
1961                    tmp4 = 0.0;
1962                    for (j = 0; j < genomeSize; j++)
1963                        {
1964                        tmp4 += linearTF[i][j] * (tmx[j] - mu1);
1965                        }
1966                    tmp += Math.cos(2 * Math.PI * tmp4);
1967                    }
1968                value = Math.min(tmp2, d * (double) genomeSize + s * tmp3) + 10. * ((double) genomeSize - tmp);
1969                value += fAdd;
1970                fit = (float) (-value);
1971                ((SimpleFitness) (ind.fitness)).setFitness(state, fit, fit == 0.0f);
1972            break;
1973            default:
1974                break;
1975            }
1976        }
1977
1978
1979    final static public double TOL = 1e-8;
1980
1981    void gauss(double[] g, MersenneTwisterFast random)
1982        {
1983        /*
1984         * samples N standard normally distributed numbers being the same for a
1985         * given seed.
1986         */
1987        double[] uniftmp = new double[2 * g.length];
1988        int i;
1989        for (i = 0; i < uniftmp.length; i++)
1990            uniftmp[i] = nextDoubleClosedInterval(random);
1991        for (i = 0; i < g.length; i++)
1992            {
1993
1994            g[i] = Math.sqrt(-2 * Math.log(uniftmp[i])) * Math.cos(2 * Math.PI * uniftmp[g.length + i]);
1995            if (g[i] == 0.0)
1996                g[i] = 1e-99;
1997            }
1998        return;
1999        }
2000
2001    void gauss(double[] g, MersenneTwisterFast random, int n)
2002        {
2003        /*
2004         * samples N standard normally distributed numbers being the same for a
2005         * given seed.
2006         */
2007        double[] uniftmp = new double[2 * g.length];
2008        int i;
2009        for (i = 0; i < uniftmp.length; i++)
2010            uniftmp[i] = nextDoubleClosedInterval(random);
2011        for (i = 0; i < n; i++)
2012            {
2013            g[i] = Math.sqrt(-2 * Math.log(uniftmp[i])) * Math.cos(2 * Math.PI * uniftmp[n + i]);
2014            if (g[i] == 0.0)
2015                g[i] = 1e-99;
2016            }
2017        return;
2018        }
2019
2020    void computeXopt(double[] xOpt, MersenneTwisterFast random)
2021        {
2022        int i;
2023        int n = xOpt.length;
2024        for (i = 0; i < n; i++)
2025            {
2026            xOpt[i] = 8 * (int) Math.floor(1e4 * nextDoubleClosedInterval(random)) / 1e4 - 4;
2027            if (xOpt[i] == 0.0)
2028                xOpt[i] = -1e-5;
2029            }
2030        }
2031
2032    void monotoneTFosc(double[] f)
2033        {
2034        double a = 0.1;
2035        int i;
2036        int n = f.length;
2037        for (i = 0; i < n; i++)
2038            {
2039            if (f[i] > 0)
2040                {
2041                f[i] = Math.log(f[i]) / a;
2042                f[i] = Math.pow(Math.exp(f[i] + 0.49 * (Math.sin(f[i]) + Math.sin(0.79 * f[i]))), a);
2043                }
2044            else if (f[i] < 0)
2045                {
2046                f[i] = Math.log(-f[i]) / a;
2047                f[i] = -Math.pow(Math.exp(f[i] + 0.49 * (Math.sin(0.55 * f[i]) + Math.sin(0.31 * f[i]))), a);
2048                }
2049            }
2050        }
2051
2052    double[][] reshape(double[][] b, double[] vector, int m, int n)
2053        {
2054        int i, j;
2055        for (i = 0; i < m; i++)
2056            {
2057            for (j = 0; j < n; j++)
2058                {
2059                b[i][j] = vector[j * m + i];
2060                }
2061            }
2062        return b;
2063        }
2064
2065    void computeRotation(double[][] b, MersenneTwisterFast random, int genomeSize)
2066        {
2067        double[] gvect = new double[genomeSize * genomeSize];
2068        double prod;
2069        int i, j, k; /* Loop over pairs of column vectors */
2070
2071        gauss(gvect, random);
2072        reshape(b, gvect, genomeSize, genomeSize);
2073        /* 1st coordinate is row, 2nd is column. */
2074
2075        for (i = 0; i < genomeSize; i++)
2076            {
2077            for (j = 0; j < i; j++)
2078                {
2079                prod = 0;
2080                for (k = 0; k < genomeSize; k++)
2081                    {
2082                    prod += b[k][i] * b[k][j];
2083                    }
2084                for (k = 0; k < genomeSize; k++)
2085                    {
2086                    b[k][i] -= prod * b[k][j];
2087                    }
2088                }
2089            prod = 0;
2090            for (k = 0; k < genomeSize; k++)
2091                {
2092                prod += b[k][i] * b[k][i];
2093                }
2094            for (k = 0; k < genomeSize; k++)
2095                {
2096                b[k][i] /= Math.sqrt(prod);
2097                }
2098            }
2099        }
2100
2101    double fGauss(double fTrue, double beta, MersenneTwisterFast random)
2102        {
2103        double fVal = fTrue * Math.exp(beta * nextDoubleClosedInterval(random));
2104        fVal += 1.01 * TOL;
2105        if (fTrue < TOL)
2106            {
2107            fVal = fTrue;
2108            }
2109        return fVal;
2110        }
2111
2112    double fUniform(double fTrue, double alpha, double beta, MersenneTwisterFast random)
2113        {
2114        double fVal = Math.pow(nextDoubleClosedInterval(random), beta) * fTrue * Math.max(1.0, Math.pow(1e9 / (fTrue + 1e-99), alpha * nextDoubleClosedInterval(random)));
2115        fVal += 1.01 * TOL;
2116        if (fTrue < TOL)
2117            {
2118            fVal = fTrue;
2119            }
2120        return fVal;
2121        }
2122
2123    double fCauchy(double fTrue, double alpha, double p, MersenneTwisterFast random)
2124        {
2125        double fVal;
2126        double tmp = nextDoubleClosedInterval(random) / Math.abs(nextDoubleClosedInterval(random) + 1e-199);
2127        /*
2128         * tmp is so as to actually do the calls to randn in order for the
2129         * number of calls to be the same as in the Matlab code.
2130         */
2131        if (nextDoubleClosedInterval(random) < p)
2132            fVal = fTrue + alpha * Math.max(0., 1e3 + tmp);
2133        else
2134            fVal = fTrue + alpha * 1e3;
2135
2136        fVal += 1.01 * TOL;
2137        if (fTrue < TOL)
2138            {
2139            fVal = fTrue;
2140            }
2141        return fVal;
2142        }
2143
2144    double computeFopt(MersenneTwisterFast random)
2145        {
2146        double[] gval = new double[1];
2147        double[] gval2 = new double[1];
2148        gauss(gval, random, 1);
2149        gauss(gval2, random, 1);
2150        return Math.min(1000.0, Math.max(-1000.0, (Math.round(100.0 * 100.0 * gval[0] / gval2[0]) / 100.0)));
2151        }
2152
2153    double nextDoubleClosedInterval(MersenneTwisterFast random)
2154        {
2155        double tmp = random.nextDouble() * 2.0;
2156        while (tmp > 1.0)
2157            tmp = random.nextDouble() * 2.0;
2158        return tmp;
2159        }
2160    }
Note: See TracBrowser for help on using the repository browser.