# Participating to the CEC2013 Competition#

In this tutorial we will show how to use pygmo to run algorithms on the test problem suite used in the Special Session & Competition on Real-Parameter Single Objective Optimization at CEC-2013, Cancun, Mexico 21-23 June 2013.

All of the CEC 2013 problems are box-bounded, continuous, single objective problems and are provided as UDP (user-defined problems) by pygmo in the class `cec2013`. Instantiating one of these problems is easy:

```>>> import pygmo as pg
>>> # The user-defined problem
>>> udp = pg.cec2013(prob_id = 24, dim = 10)
>>> # The pygmo problem
>>> prob = pg.problem(udp)
```

as usual, we can quickly inspect the `problem` printing it to screen:

```>>> print(prob)
Problem name: CEC2013 - f24(cf04)
C++ class name: ...

Global dimension:                       10
Integer dimension:                      0
Fitness dimension:                      1
Number of objectives:                   1
Equality constraints dimension:         0
Inequality constraints dimension:       0
Lower bounds: [-100, -100, -100, -100, -100, ... ]
Upper bounds: [100, 100, 100, 100, 100, ... ]
Has batch fitness evaluation: false

Has hessians: false
User implemented hessians sparsity: false

Fitness evaluations: 0

```

Let us assume we want to assess the performance of (say) the optimization algorithm `cmaes` (which implements as user-defined algorithm the Covariance Matrix Adaptation Evolutionary Strategy) on the whole `cec2013` problem suite at dimension D=2. Since the competition rules allowed D * 10000 fitness evaluations, we choose a population of 50 and 400 generations:    ```>>> # The cmaes pygmo algorithm
>>> algo = pg.algorithm(pg.cmaes(gen=1000, ftol=1e-9, xtol=1e-9))
>>> # Defining all 28 problems dimension
>>> D = 2
>>> # Running the algo on them multiple times
>>> error = []
>>> trials = 25
>>> for j in range(trials):
...         for i in range(28):
...                 prob = pg.problem(pg.cec2013(prob_id = i+1, dim = D))
...                 pop = pg.population(prob,50)
...                 pop = algo.evolve(pop)
...                 error.append(pop.get_f()[pop.best_idx()] + 1400 - 100*i - 100*(i>13))
```

At the end of the script, a matplotlib boxplot can be easily produced reporting the results for each of the 28 problem instances:

```>>> import matplotlib.pyplot as plt
>>> res = plt.boxplot([error[s::28] for s in range(28)])
>>> plt.text(5, 80, algo.__repr__(), fontsize=8)
>>> fig = plt.gcf()
>>> fig.set_size_inches(10,3, forward=True)
>>> plt.ylim([-1,350])
>>> plt.title("CEC2013: dimension = 2")
>>> plt.show()
```

The same can be done for different user-defined algorithms. In the various figures on the right we have reported only a few available from pygmo’s core. At this low dimension it can be seen how the particular instances choosen for `cmaes` and `sade` (jDE) are performing particularly well. It has to be noted here that `cmaes` results, in general, to spend less than the available budget of fitness evaluations so that a proper comparison at these low dimensionality should allow for restarts as to properly make use of the allowed budget.

The script above can be run again for higher problem dimensions, so that, for example, at D = 10 and using a larger population size as to allow for the larger available budget of fitness evaluations, the following plots are obtained for the chosen instances of `cmaes` and `sade`:  