# Tutorial

After reading this tutorial you'll become an expert using `Metaheuristics`

module.

## Minimization Problem

Assume you want to optimize the following minimization problem:

Minimize:

\[f(x) = 10D + \sum_{i=1}^D x_i^2 - 10cos(2\pi x_i)\]

where $x\in [-5, 5]^D$, that is, each coordinate in $x$ is between -5 and 5. Use $D=10$.

Note that the global optimum is obtained when $x_i = 0$ for all $i$. Thus, $\min f(x) = 0$.

Objective function:

`f(x) = 10length(x) + sum( x.^2 - 10cos.(2pi*x) )`

Bounds:

`bounds = [-5ones(10) 5ones(10)]'`

## Providing Information

Since the optimum is known, then we can provide this information to the optimizer.

`information = Information(f_optimum = 0.0)`

## Common Settings

Usually users could require to limit the number of generation/iteration or the number of function evaluations. To do that, let's assume that the metaheuristic should evaluate at most $9000D$ times the objective function. Moreover, since `information`

is provided, then we can set the desired accuracy ($|f(x) - f(x^*)| $) to $10^{-5}$.

`options = Options(f_calls_limit = 9000*10, f_tol = 1e-5)`

## Choose a Metaheuristic

`Metaheuristics.jl`

provides different metaheuristics for optimization such as Evolutionary Centers Algorithm (ECA), Differential Evolution (DE), Particle Swarm Optimization (PSO), etc. In this tutorial we will use `ECA`

, but you can use another algorithm following but the same steps.

The metaheuristics accept its parameters but share two common and **optional** settings `information`

and `options`

.

`algorithm = ECA(information = information, options = options)`

## Optimize

Now, we are able to approximate the optimum. To do that is necessary to use the `optimize`

function as follows:

`result = optimize(f, bounds, algorithm)`

## Get the Results

Once `optimize`

stopped, then we can get the approximate solutions.

Approximated minimum:

`fx = minimum(result)`

Approximated minimizer:

`x = minimizer(result)`

## Get Information about the Resulting Population

Sometimes is useful to analyze the resulting population (for population-based metaheuristics). To do that you can use `fvals`

to get objective function evaluation and `positions`

to get their positions.

## Bonus

We recommend you to save your program in a function for performance purposes:

```
using Metaheuristics
function main()
# objective function
f(x) = 10length(x) + sum( x.^2 - 10cos.(2π*x) )
# limits/bounds
bounds = [-5ones(10) 5ones(10)]'
# information on the minimization problem
information = Information(f_optimum = 0.0)
# generic settings
options = Options(f_calls_limit = 9000*10, f_tol = 1e-5)
# metaheuristic used to optimize
algorithm = ECA(information = information, options = options)
# start the minimization proccess
result = optimize(f, bounds, algorithm)
fx = minimum(result)
x = minimizer(result)
@show fx
@show x
end
```

## Summary

Now you are able to approximate global optimum solutions using Metaheuristics.