Crate abc

Runs Karaboga's Artificial Bee Colony algorithm in parallel.

To take advantage of this crate, the user must implement the Solution trait for a type of their creation. A Hive of the appropriate type can then be built, which will search the solution space for the fittest candidate.

Examples

// ABC algorithm with canonical (proportionate) fitness scaling
// to minimize the 10-dimensional Rastrigin function.

extern crate abc;
extern crate rand;

use std::f32::consts::PI;
use rand::{random, Closed01, thread_rng, Rng};
use abc::{Context, Candidate, HiveBuilder};

const SIZE: usize = 10;

#[derive(Clone, Debug)]
struct S([f32;SIZE]);

// Not really necessary; we're using this mostly to demonstrate usage.
struct SBuilder {
    min: f32,
    max: f32,
    a: f32,
    p_min: f32,
    p_max: f32,
}

impl Context for SBuilder {
    type Solution = [f32;SIZE];

    fn make(&self) -> [f32;SIZE] {
        let mut new = [0.0;SIZE];
        for i in 0..SIZE {
            let Closed01(x) = random::<Closed01<f32>>();
            new[i] = (x * (self.max - self.min)) + self.min;
        }
        new
    }

    fn evaluate_fitness(&self, solution: &[f32;10]) -> f64 {
        let sum = solution.iter()
                          .map(|x| x.powf(2.0) - self.a * (*x * 2.0 * PI).cos())
                          .fold(0.0, |total, next| total + next);
        let rastrigin = ((self.a * SIZE as f32) + sum) as f64;

        // Minimize.
        if rastrigin >= 0.0 {
            1.0 / (1.0 + rastrigin)
        } else {
            1.0 + rastrigin.abs()
        }
    }

    fn explore(&self, field: &[Candidate<[f32;SIZE]>], index: usize) -> [f32;SIZE] {
        // new[i] = current[i] + Φ * (current[i] - other[i]), where:
        //      phi_min <= Φ <= phi_max
        //      other is a solution, other than current, chosen at random

        let ref current = field[index].solution;
        let mut new = [0_f32;SIZE];

        for i in 0..SIZE {
            // Choose a different vector at random.
            let mut rng = thread_rng();
            let mut index2 = rng.gen_range(0, current.len() - 1);
            if index2 >= index { index2 += 1; }
            let ref other = field[index2].solution;

            let phi = random::<Closed01<f32>>().0 * (self.p_max - self.p_min) + self.p_min;
            new[i] = current[i] + (phi * (current[i] - other[i]));
        }

        new
    }
}

fn main() {
    let mut builder = SBuilder {
        min: -5.12,
        max: 5.12,
        a: 10.0,
        p_min: -1.0,
        p_max: 1.0
    };
    let hive_builder = HiveBuilder::new(builder, 10);
    let hive = hive_builder.build().unwrap();

    // Once built, the hive can be run for a number of rounds.
    let best_after_10 = hive.run_for_rounds(10).unwrap();

    // As long as it's run some rounds at a time, you can keep running it.
    let best_after_20 = hive.run_for_rounds(10).unwrap();

    // The algorithm doesn't guarantee improvement in any number of rounds,
    // but it always keeps its all-time best.
    assert!(best_after_20.fitness >= best_after_10.fitness);

    // The hive can be consumed to create a Receiver object. This can be
    // iterated over indefinitely, and will receive successive improvements
    // on the best candidate so far.
    let mut current_best_fitness = best_after_20.fitness;
    for new_best in hive.stream().iter().take(3) {
        // The iterator will start with the best result so far; after that,
        // each new candidate will be an improvement.
        assert!(new_best.fitness >= current_best_fitness);
        current_best_fitness = new_best.fitness;
    }
}

Modules

scaling

Manipulates the probabilities of working on different solutions.

Structs

Candidate	One solution being explored by the hive, plus additional data.
Error	Unifies the errors thrown by a hive's operation.
Hive	Runs the ABC algorithm, maintaining any necessary state.
HiveBuilder	Manages the parameters of the ABC algorithm.

Traits

Context

Context for generating and evaluating solutions.

Type Definitions

Result

Encodes the possibility of a thread panicking and corruping a mutex.