# Crate differential_evolution [−] [src]

Differential Evolution optimizer for rust.

Simple and powerful global optimization using a Self-Adapting Differential Evolution for Rust. See Wikipedia's article on Differential Evolution for more information.

## Usage

Add this to your `Cargo.toml`

:

```
[dependencies]
differential-evolution = "*"
```

and this to your crate root:

extern crate differential_evolution;

## Examples

Differential Evolution is a global optimization algorithm that tries to iteratively improve candidate solutions with regards to a user-defined cost function.

### Quick Start: Sum of Squares

This example finds the minimum of a simple 5-dimensional function.

extern crate differential_evolution; use differential_evolution::self_adaptive_de; fn main() { // create a self adaptive DE with an inital search area // from -10 to 10 in 5 dimensions. let mut de = self_adaptive_de(vec![(-10.0, 10.0); 5], |pos| { // cost function to minimize: sum of squares pos.iter().fold(0.0, |sum, x| sum + x*x) }); // perform 10000 cost evaluations de.iter().nth(10000); // show the result let (cost, pos) = de.best().unwrap(); println!("cost: {}", cost); println!("pos: {:?}", pos); }

### Tutorial: Rastrigin

The population supports an `Iterator`

for evaluating. Each call
of `next()`

evaluates the cost function and returns the
fitness value of the current global best. This way it is possible
to use all the iterator's features for optimizig. Here are a few
examples.

Let's say we have the Rastrigin cost function:

use std::f32::consts::PI; fn rastrigin(pos: &[f32]) -> f32 { pos.iter().fold(0.0, |sum, x| sum + x * x - 10.0 * (2.0 * PI * x).cos() + 10.0) }

We'd like to search for the minimum in the range -5.12 to 5.12, for 30 dimensions:

let initial_min_max = vec![(-5.12, 5.12); 30];

We can create a self adaptive DE, and search until the cost reaches a given minimum:

let mut de = self_adaptive_de(initial_min_max, rastrigin); de.iter().find(|&cost| cost < 0.1);

This is a bit dangerous though, because the optimizer might never reach that minimum. It is safer to just let it run for a given number of evaluations:

let mut de = self_adaptive_de(initial_min_max, rastrigin); de.iter().nth(10000);

If is possible to do some smart combinations: run until cost is below a threshold, or until the maximum number of iterations have been reached:

let mut de = self_adaptive_de(initial_min_max, sum_of_squares); de.iter().take(100000).find(|&cost| cost < 0.1);

When you are finished with iterating, you can extract the best solution found so far with
`de.best()`

. This retrieves the minimum cost and the position vector that has lead to this
cost:

let (cost, pos) = de.best().unwrap(); println!("{} best cost", cost); println!("{:?} best position", pos);

# Similar Crates

## Structs

PopIter |
Iterator for the differential evolution, to perform a single cost
evaluation every time |

Population |
Holds the population for the differential evolution based on the given settings. |

Settings |
Holds all settings for the self adaptive differential evolution algorithm. |

## Functions

self_adaptive_de |
Convenience function to create a fully configured self adaptive differential evolution population. |