Struct TerminatorBuilder 

pub struct TerminatorBuilder<Solution> { /* private fields */ }

Builder design pattern to construct termination criteria.

Implementations

impl<Solution> TerminatorBuilder<Solution>

pub fn build(self) -> Box<dyn TerminationCriteria<Solution>>

where Solution: 'static,

Build termination criteria on the stack.

Examples found in repository

examples/tsp.rs (line 69)

fn main() {
    // init
    let n = 100;
    let width = 100.;
    let height = 100.;
    let computation_time_max = Duration::new(2, 0);

    // create random cities
    let seed = 0;
    let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
    let cities: Vec<City> = (0..n)
        .map(|id| create_random_city(id, width, height, &mut rng))
        .collect();
    let cities = Box::new(cities);

    let now = SystemTime::now();
    let random_tour = construct_random_tour(&mut cities.clone().into_iter(), &mut rng);
    let duration_random = now.elapsed().unwrap();
    let random_outcome = Outcome::new(random_tour, duration_random);
    let now = SystemTime::now();
    let greedy_tour = construct_greedy_tour(&mut cities.clone().into_iter(), &mut rng);
    let duration_greedy = now.elapsed().unwrap();
    let greedy_outcome = Outcome::new(greedy_tour, duration_greedy);

    // optimize with VNS
    let operator1 = TwoOpt::new(cities.as_slice());
    let operator2 = Insertion::new(cities.as_slice());
    let vns = VariableNeighborhoodSearch::builder()
        .selector(
            SequentialSelector::new()
                .option(operator1)
                .option(operator2),
        )
        .terminator(TimeTerminator::new(computation_time_max))
        .build();
    let vns_outcome = vns.optimize_timed(random_outcome.solution().clone());

    // optimize with Simulated Annealing
    let temperature = 100.;
    let cooling_factor = 0.05;
    let minimum_acceptance_probability = 0.05;
    let schedule = FactorSchedule::new(temperature, cooling_factor);
    let operator = TwoOpt::new(cities.as_slice());
    let sa = SimulatedAnnealing::builder()
        .selector(RandomSelector::new(rng.clone()).option(operator))
        .operator(TwoOptRandom)
        .cooling_schedule(schedule)
        .terminator(
            Terminator::builder()
                .computation_time(computation_time_max)
                .build(),
        )
        .minimum_acceptance_probability(minimum_acceptance_probability)
        .rng(rng.clone())
        .build();
    let sa_outcome = sa.optimize_timed(random_outcome.solution().clone());

    // optimize with Large Neighborhood Search
    let n_destroyed_cities = 2;
    let destroyer = TSPDestroyer::new(n_destroyed_cities);
    let repairer = TSPRepairer::new(*cities.clone());
    let lns = LargeNeighborhoodSearch::builder()
        .selector_destroyer(SequentialSelector::new().option(destroyer))
        .selector_repairer(SequentialSelector::new().option(repairer))
        .terminator(
            Terminator::builder()
                .computation_time(computation_time_max)
                .build(),
        )
        .rng(rng.clone())
        .build();
    let lns_outcome = lns.optimize_timed(random_outcome.solution().clone());

    // optimize with adaptive VNS
    let decay = 0.5;
    let operator1 = TwoOpt::new(cities.as_slice());
    let operator2 = Insertion::new(cities.as_slice());
    let adaptive_vns = VariableNeighborhoodSearch::builder()
        .selector(
            AdaptiveSelector::default_weights(decay, rng)
                .operator(operator1)
                .operator(operator2),
        )
        .terminator(TimeTerminator::new(computation_time_max))
        .build();
    let adaptive_vns_outcome = adaptive_vns.optimize_timed(random_outcome.solution().clone());

    // display results
    show_solution(random_outcome, "random");
    show_solution(greedy_outcome, "greedy");
    show_solution(vns_outcome, "vns");
    show_solution(adaptive_vns_outcome, "adaptive vns");
    show_solution(sa_outcome, "sa");
    show_solution(lns_outcome, "lns");
}

pub fn criterium<T: TerminationCriteria<Solution> + 'static>( self, criterium: T, ) -> Self

Add a termination criterium, to be aggregated later.

pub fn iterations(self, n: usize) -> Self

Add a limit on the number of iterations.

pub fn computation_time(self, computation_time_max: Duration) -> Self

Add a time limit.

Examples found in repository

examples/tsp.rs (line 68)

fn main() {
    // init
    let n = 100;
    let width = 100.;
    let height = 100.;
    let computation_time_max = Duration::new(2, 0);

    // create random cities
    let seed = 0;
    let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
    let cities: Vec<City> = (0..n)
        .map(|id| create_random_city(id, width, height, &mut rng))
        .collect();
    let cities = Box::new(cities);

    let now = SystemTime::now();
    let random_tour = construct_random_tour(&mut cities.clone().into_iter(), &mut rng);
    let duration_random = now.elapsed().unwrap();
    let random_outcome = Outcome::new(random_tour, duration_random);
    let now = SystemTime::now();
    let greedy_tour = construct_greedy_tour(&mut cities.clone().into_iter(), &mut rng);
    let duration_greedy = now.elapsed().unwrap();
    let greedy_outcome = Outcome::new(greedy_tour, duration_greedy);

    // optimize with VNS
    let operator1 = TwoOpt::new(cities.as_slice());
    let operator2 = Insertion::new(cities.as_slice());
    let vns = VariableNeighborhoodSearch::builder()
        .selector(
            SequentialSelector::new()
                .option(operator1)
                .option(operator2),
        )
        .terminator(TimeTerminator::new(computation_time_max))
        .build();
    let vns_outcome = vns.optimize_timed(random_outcome.solution().clone());

    // optimize with Simulated Annealing
    let temperature = 100.;
    let cooling_factor = 0.05;
    let minimum_acceptance_probability = 0.05;
    let schedule = FactorSchedule::new(temperature, cooling_factor);
    let operator = TwoOpt::new(cities.as_slice());
    let sa = SimulatedAnnealing::builder()
        .selector(RandomSelector::new(rng.clone()).option(operator))
        .operator(TwoOptRandom)
        .cooling_schedule(schedule)
        .terminator(
            Terminator::builder()
                .computation_time(computation_time_max)
                .build(),
        )
        .minimum_acceptance_probability(minimum_acceptance_probability)
        .rng(rng.clone())
        .build();
    let sa_outcome = sa.optimize_timed(random_outcome.solution().clone());

    // optimize with Large Neighborhood Search
    let n_destroyed_cities = 2;
    let destroyer = TSPDestroyer::new(n_destroyed_cities);
    let repairer = TSPRepairer::new(*cities.clone());
    let lns = LargeNeighborhoodSearch::builder()
        .selector_destroyer(SequentialSelector::new().option(destroyer))
        .selector_repairer(SequentialSelector::new().option(repairer))
        .terminator(
            Terminator::builder()
                .computation_time(computation_time_max)
                .build(),
        )
        .rng(rng.clone())
        .build();
    let lns_outcome = lns.optimize_timed(random_outcome.solution().clone());

    // optimize with adaptive VNS
    let decay = 0.5;
    let operator1 = TwoOpt::new(cities.as_slice());
    let operator2 = Insertion::new(cities.as_slice());
    let adaptive_vns = VariableNeighborhoodSearch::builder()
        .selector(
            AdaptiveSelector::default_weights(decay, rng)
                .operator(operator1)
                .operator(operator2),
        )
        .terminator(TimeTerminator::new(computation_time_max))
        .build();
    let adaptive_vns_outcome = adaptive_vns.optimize_timed(random_outcome.solution().clone());

    // display results
    show_solution(random_outcome, "random");
    show_solution(greedy_outcome, "greedy");
    show_solution(vns_outcome, "vns");
    show_solution(adaptive_vns_outcome, "adaptive vns");
    show_solution(sa_outcome, "sa");
    show_solution(lns_outcome, "lns");
}

pub fn all(self) -> Self

Construct an aggregating termination criterium which only evaluates to true if all criteria do so.

pub fn any(self) -> Self

Construct an aggregating termination criterium which only evaluates to true if at least one criterium does so.