Struct Population

pub struct Population<F, R>
where
    F: Fn(&[f32]) -> f32,
    R: Rng,
{ /* private fields */ }

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

Implementations

impl<F, R> Population<F, R>

where F: Fn(&[f32]) -> f32, R: Rng,

pub fn new(s: Settings<F, R>) -> Population<F, R>

Creates a new population based on the given settings.

pub fn best(&self) -> Option<(f32, &[f32])>

Gets a tuple of the best cost and best position found so far.

Examples found in repository

examples/simple.rs (line 25)

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);
}

examples/rastrigin.rs (line 41)

fn main() {
    // command line args: dimension, number of evaluations
    let args: Vec<String> = env::args().collect();
    let dim = args[1].parse::<usize>().unwrap();

    // initial search space for each dimension
    let initial_min_max = vec![(-5.12, 5.12); dim];

    // initialize differential evolution
    let mut de = self_adaptive_de(initial_min_max, rastrigin);

    // perform optimization for a maximum of 100000 cost evaluations,
    // or until best cost is below 0.1.
    de.iter().take(100000).find(|&cost| cost < 0.1);

    // see what we've found
    println!("{} evaluations done", de.num_cost_evaluations());
    
    let (cost, pos) = de.best().unwrap();
    println!("{} best cost", cost);
    println!("{:?} best position", pos);
}

pub fn num_cost_evaluations(&self) -> usize

Gets the total number of times the cost function has been evaluated.

Examples found in repository

examples/rastrigin.rs (line 39)

fn main() {
    // command line args: dimension, number of evaluations
    let args: Vec<String> = env::args().collect();
    let dim = args[1].parse::<usize>().unwrap();

    // initial search space for each dimension
    let initial_min_max = vec![(-5.12, 5.12); dim];

    // initialize differential evolution
    let mut de = self_adaptive_de(initial_min_max, rastrigin);

    // perform optimization for a maximum of 100000 cost evaluations,
    // or until best cost is below 0.1.
    de.iter().take(100000).find(|&cost| cost < 0.1);

    // see what we've found
    println!("{} evaluations done", de.num_cost_evaluations());
    
    let (cost, pos) = de.best().unwrap();
    println!("{} best cost", cost);
    println!("{:?} best position", pos);
}

pub fn eval(&mut self) -> Option<f32>

Performs a single cost evaluation, and updates best positions and evolves the population if the whole population has been evaluated. Returns the cost value of the current best solution found.

pub fn iter(&mut self) -> PopIter<'_, F, R>

Gets an iterator for this population. Each call to next() performs one cost evaluation.

Examples found in repository

examples/simple.rs (line 22)

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);
}

examples/rastrigin.rs (line 36)

fn main() {
    // command line args: dimension, number of evaluations
    let args: Vec<String> = env::args().collect();
    let dim = args[1].parse::<usize>().unwrap();

    // initial search space for each dimension
    let initial_min_max = vec![(-5.12, 5.12); dim];

    // initialize differential evolution
    let mut de = self_adaptive_de(initial_min_max, rastrigin);

    // perform optimization for a maximum of 100000 cost evaluations,
    // or until best cost is below 0.1.
    de.iter().take(100000).find(|&cost| cost < 0.1);

    // see what we've found
    println!("{} evaluations done", de.num_cost_evaluations());
    
    let (cost, pos) = de.best().unwrap();
    println!("{} best cost", cost);
    println!("{:?} best position", pos);
}