Struct HiveBuilder

pub struct HiveBuilder<Ctx: Context> { /* private fields */ }

Manages the parameters of the ABC algorithm.

Implementations

impl<Ctx: Context> HiveBuilder<Ctx>

pub fn new(context: Ctx, workers: usize) -> HiveBuilder<Ctx>

Creates a new hive.

• context - Factory-like state that can be used while generating solutions.
• workers - Number of working solution candidates to maintain at a time.

Examples found in repository

examples/max_i32.rs (line 32)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_scaling(scaling::power_rank(10_f64));
    println!("{:?}", hive.build().unwrap().run_for_rounds(1_000));
}

examples/streaming.rs (line 32)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_observers(4)
        .set_scaling(scaling::power_rank(10_f64));
    for candidate in hive.build()
                         .unwrap()
                         .stream()
                         .iter()
                         .skip_while(|c| c.fitness < 200_f64)
                         .take(5) {
        println!("{:?}", candidate);
    }
}

pub fn set_observers(self, observers: usize) -> HiveBuilder<Ctx>

Sets the number of “bees” that will pick a candidate to work on at random.

This defaults to the number of workers.

Examples found in repository

examples/streaming.rs (line 34)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_observers(4)
        .set_scaling(scaling::power_rank(10_f64));
    for candidate in hive.build()
                         .unwrap()
                         .stream()
                         .iter()
                         .skip_while(|c| c.fitness < 200_f64)
                         .take(5) {
        println!("{:?}", candidate);
    }
}

pub fn set_retries(self, retries: usize) -> HiveBuilder<Ctx>

Sets the number of times a candidate can go unimproved before being reinitialized.

This defaults to the number of workers.

pub fn set_threads(self, threads: usize) -> HiveBuilder<Ctx>

Sets the number of worker threads to use while running.

Examples found in repository

examples/max_i32.rs (line 33)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_scaling(scaling::power_rank(10_f64));
    println!("{:?}", hive.build().unwrap().run_for_rounds(1_000));
}

examples/streaming.rs (line 33)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_observers(4)
        .set_scaling(scaling::power_rank(10_f64));
    for candidate in hive.build()
                         .unwrap()
                         .stream()
                         .iter()
                         .skip_while(|c| c.fitness < 200_f64)
                         .take(5) {
        println!("{:?}", candidate);
    }
}

pub fn set_scaling(self, scale: Box<ScalingFunction>) -> HiveBuilder<Ctx>

Sets the scaling function for observers to use.

Examples found in repository

examples/max_i32.rs (line 34)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_scaling(scaling::power_rank(10_f64));
    println!("{:?}", hive.build().unwrap().run_for_rounds(1_000));
}

examples/streaming.rs (line 35)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_observers(4)
        .set_scaling(scaling::power_rank(10_f64));
    for candidate in hive.build()
                         .unwrap()
                         .stream()
                         .iter()
                         .skip_while(|c| c.fitness < 200_f64)
                         .take(5) {
        println!("{:?}", candidate);
    }
}

pub fn build(self) -> AbcResult<Hive<Ctx>>

Activates the HiveBuilder to create a runnable object.

Examples found in repository

examples/max_i32.rs (line 35)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_scaling(scaling::power_rank(10_f64));
    println!("{:?}", hive.build().unwrap().run_for_rounds(1_000));
}

examples/streaming.rs (line 36)

fn main() {
    let hive = HiveBuilder::<Foo>::new(Foo, 5)
        .set_threads(5)
        .set_observers(4)
        .set_scaling(scaling::power_rank(10_f64));
    for candidate in hive.build()
                         .unwrap()
                         .stream()
                         .iter()
                         .skip_while(|c| c.fitness < 200_f64)
                         .take(5) {
        println!("{:?}", candidate);
    }
}