test(localsearch): pin forager, acceptor, recreate and seed behaviour

crates/solverforge-solver/src/builder/acceptor/tests.rs

@@ -341,3 +341,94 @@ fn simulated_annealing_rejects_calibration_beside_level_temperatures() {
     let error = build_acceptor::<TestSolution>(&config).expect_err("exclusive keys");
     assert_eq!(error.field(), "calibration");
 }
+
+/// Whether `acceptor` takes a move from `last_step` to `candidate`.
+fn accepts<S: PlanningSolution>(
+    acceptor: &mut AnyAcceptor<S>,
+    last_step: S::Score,
+    candidate: S::Score,
+) -> bool
+where
+    S::Score: Score,
+{
+    Acceptor::<S>::is_accepted(acceptor, &last_step, &candidate, None)
+}
+
+#[test]
+fn step_counting_hill_climbing_accepts_worse_moves_for_step_count_limit_steps() {
+    let config = AcceptorConfig::StepCountingHillClimbing(StepCountingHillClimbingConfig {
+        step_count_limit: Some(3),
+    });
+    let mut acceptor: AnyAcceptor<TestSolution> = build_acceptor(&config).unwrap();
+    let zero = SoftScore::of(0);
+    Acceptor::<TestSolution>::phase_started(&mut acceptor, &zero);
+    for _ in 0..2 {
+        Acceptor::<TestSolution>::step_ended(&mut acceptor, &zero, None);
+    }
+    assert!(accepts(&mut acceptor, zero, SoftScore::of(-1)));
+
+    Acceptor::<TestSolution>::step_ended(&mut acceptor, &zero, None);
+    assert!(!accepts(&mut acceptor, zero, SoftScore::of(-1)));
+    assert!(accepts(&mut acceptor, zero, SoftScore::of(1)));
+}
+
+#[test]
+fn great_deluge_raises_the_water_level_by_the_configured_ratio() {
+    // From -100 at a ratio of 0.5, one step raises the water level to -50.
+    let config = AcceptorConfig::GreatDeluge(GreatDelugeConfig {
+        water_level_increase_ratio: Some(0.5),
+    });
+    let mut acceptor: AnyAcceptor<TestSolution> = build_acceptor(&config).unwrap();
+    Acceptor::<TestSolution>::phase_started(&mut acceptor, &SoftScore::of(-100));
+    Acceptor::<TestSolution>::step_ended(&mut acceptor, &SoftScore::of(-40), None);
+
+    assert!(accepts(
+        &mut acceptor,
+        SoftScore::of(-40),
+        SoftScore::of(-50)
+    ));
+    assert!(!accepts(
+        &mut acceptor,
+        SoftScore::of(-40),
+        SoftScore::of(-51)
+    ));
+}
+
+#[test]
+fn simulated_annealing_hard_regression_policy_decides_hard_regressions() {
+    // At these temperatures a one-point regression is accepted with
+    // probability exp(-1e-12).
+    let hot = |policy| {
+        AcceptorConfig::SimulatedAnnealing(SimulatedAnnealingConfig {
+            level_temperatures: Some(vec![1.0e12, 1.0e12]),
+            hard_regression_policy: policy,
+            ..Default::default()
+        })
+    };
+    let regresses = |config: &AcceptorConfig| {
+        let mut acceptor: AnyAcceptor<HardSoftTestSolution> =
+            CompiledAcceptor::<HardSoftTestSolution>::compile(config)
+                .unwrap()
+                .build(Some(7));
+        let zero = HardSoftScore::of(0, 0);
+        Acceptor::<HardSoftTestSolution>::phase_started(&mut acceptor, &zero);
+        (
+            accepts(&mut acceptor, zero, HardSoftScore::of(-1, 0)),
+            accepts(&mut acceptor, zero, HardSoftScore::of(0, -1)),
+        )
+    };
+
+    assert_eq!(regresses(&hot(None)), (true, true));
+    assert_eq!(
+        regresses(&hot(Some(
+            HardRegressionPolicyConfig::TemperatureControlled
+        ))),
+        (true, true)
+    );
+    assert_eq!(
+        regresses(&hot(Some(
+            HardRegressionPolicyConfig::NeverAcceptHardRegression
+        ))),
+        (false, true)
+    );
+}

crates/solverforge-solver/src/builder/forager.rs

@@ -113,6 +113,9 @@ where
     }
 }
 
+#[cfg(test)]
+mod tests;
+
 /// Builds a forager from a configuration that passed [`CompiledForager::compile`].
 pub(super) fn build_validated_forager<S: PlanningSolution>(
     config: &ForagerConfig,

crates/solverforge-solver/src/builder/forager/tests.rs

@@ -0,0 +1,106 @@
+use solverforge_config::{ForagerConfig, ScoreTieBreak};
+use solverforge_core::domain::PlanningSolution;
+use solverforge_core::score::SoftScore;
+
+use crate::builder::{AnyForager, CompiledForager};
+use crate::heuristic::r#move::ChangeMove;
+use crate::heuristic::selector::move_selector::CandidateId;
+use crate::phase::localsearch::LocalSearchForager;
+
+#[derive(Clone, Debug)]
+struct Plan {
+    score: Option<SoftScore>,
+}
+
+impl PlanningSolution for Plan {
+    type Score = SoftScore;
+
+    fn score(&self) -> Option<Self::Score> {
+        self.score
+    }
+
+    fn set_score(&mut self, score: Option<Self::Score>) {
+        self.score = score;
+    }
+}
+
+type TestMove = ChangeMove<Plan, usize>;
+
+/// Starts a step at `best` and `last_step`, offers `scores` in order until the
+/// forager quits, and returns the picked candidate and how many were offered.
+fn forage(
+    forager: &mut AnyForager<Plan>,
+    best: i64,
+    last_step: i64,
+    step_seed: u64,
+    scores: &[i64],
+) -> (usize, usize) {
+    LocalSearchForager::<Plan, TestMove>::step_started(
+        forager,
+        SoftScore::of(best),
+        SoftScore::of(last_step),
+        step_seed,
+    );
+    let mut offered = 0;
+    for (index, score) in scores.iter().enumerate() {
+        offered += 1;
+        LocalSearchForager::<Plan, TestMove>::add_move_index(
+            forager,
+            CandidateId::new(index),
+            SoftScore::of(*score),
+        );
+        if LocalSearchForager::<Plan, TestMove>::is_quit_early(forager) {
+            break;
+        }
+    }
+    let (picked, _) = LocalSearchForager::<Plan, TestMove>::pick_move_index(forager)
+        .expect("an offered candidate is picked");
+    (picked.index(), offered)
+}
+
+/// The candidates a forager picks among four equally scored ones over 32 steps.
+fn tie_picks(forager: &mut AnyForager<Plan>) -> std::collections::BTreeSet<usize> {
+    (0..32)
+        .map(|seed| forage(forager, -1, -1, seed, &[-1, -1, -1, -1]).0)
+        .collect()
+}
+
+fn build(config: ForagerConfig, score_tie_break: ScoreTieBreak) -> AnyForager<Plan> {
+    CompiledForager::compile(&config)
+        .expect("the forager config is valid")
+        .build(score_tie_break)
+}
+
+#[test]
+fn first_accepted_takes_the_first_candidate() {
+    let mut forager = build(ForagerConfig::FirstAccepted {}, ScoreTieBreak::First);
+    assert_eq!(forage(&mut forager, -10, -10, 0, &[-12, -5, -1]), (0, 1));
+}
+
+#[test]
+fn first_best_score_improving_waits_for_a_new_best() {
+    // -15 improves the last step (-20) but not the best (-10); -5 improves both.
+    let mut forager = build(
+        ForagerConfig::FirstBestScoreImproving {},
+        ScoreTieBreak::First,
+    );
+    assert_eq!(forage(&mut forager, -10, -20, 0, &[-15, -5, -1]), (1, 2));
+}
+
+#[test]
+fn first_last_step_score_improving_stops_on_beating_the_last_step() {
+    let mut forager = build(
+        ForagerConfig::FirstLastStepScoreImproving {},
+        ScoreTieBreak::First,
+    );
+    assert_eq!(forage(&mut forager, -10, -20, 0, &[-15, -5, -1]), (0, 1));
+}
+
+#[test]
+fn a_random_score_tie_break_spreads_picks_over_equal_candidates() {
+    let mut random = build(ForagerConfig::BestScore {}, ScoreTieBreak::Random);
+    assert!(tie_picks(&mut random).len() > 1);
+
+    let mut first = build(ForagerConfig::BestScore {}, ScoreTieBreak::First);
+    assert_eq!(tie_picks(&mut first), [0].into());
+}

crates/solverforge-solver/src/runtime/compiler/executor/runner/local_search.rs

@@ -137,6 +137,9 @@ where
     }
 }
 
+#[cfg(test)]
+mod tests;
+
 pub(super) fn build_acceptor_and_forager<S>(
     components: DefaultLocalSearchComponents,
     configured_acceptor: Option<&CompiledAcceptor<S>>,

crates/solverforge-solver/src/runtime/compiler/executor/runner/local_search/tests.rs

@@ -0,0 +1,111 @@
+use solverforge_config::{AcceptorConfig, ScoreTieBreak, TabuSearchConfig};
+use solverforge_core::domain::PlanningSolution;
+use solverforge_core::score::SoftScore;
+
+use super::build_acceptor_and_forager;
+use crate::builder::{AnyForager, CompiledAcceptor};
+use crate::heuristic::r#move::ChangeMove;
+use crate::heuristic::selector::move_selector::CandidateId;
+use crate::phase::localsearch::LocalSearchForager;
+use crate::runtime::compiler::default_local_search::{
+    DefaultLocalSearchAcceptorPolicy, DefaultLocalSearchComponents, DefaultLocalSearchForagerPolicy,
+};
+
+#[derive(Clone, Debug)]
+struct Plan {
+    score: Option<SoftScore>,
+}
+
+impl PlanningSolution for Plan {
+    type Score = SoftScore;
+
+    fn score(&self) -> Option<Self::Score> {
+        self.score
+    }
+
+    fn set_score(&mut self, score: Option<Self::Score>) {
+        self.score = score;
+    }
+}
+
+type TestMove = ChangeMove<Plan, usize>;
+
+/// Starts a step at `best` and `last_step`, offers `scores` in order until the
+/// forager quits, and returns the picked candidate and how many were offered.
+fn forage(
+    forager: &mut AnyForager<Plan>,
+    best: i64,
+    last_step: i64,
+    step_seed: u64,
+    scores: &[i64],
+) -> (usize, usize) {
+    LocalSearchForager::<Plan, TestMove>::step_started(
+        forager,
+        SoftScore::of(best),
+        SoftScore::of(last_step),
+        step_seed,
+    );
+    let mut offered = 0;
+    for (index, score) in scores.iter().enumerate() {
+        offered += 1;
+        LocalSearchForager::<Plan, TestMove>::add_move_index(
+            forager,
+            CandidateId::new(index),
+            SoftScore::of(*score),
+        );
+        if LocalSearchForager::<Plan, TestMove>::is_quit_early(forager) {
+            break;
+        }
+    }
+    let (picked, _) = LocalSearchForager::<Plan, TestMove>::pick_move_index(forager)
+        .expect("an offered candidate is picked");
+    (picked.index(), offered)
+}
+
+/// The candidates a forager picks among four equally scored ones over 32 steps.
+fn tie_picks(forager: &mut AnyForager<Plan>) -> std::collections::BTreeSet<usize> {
+    (0..32)
+        .map(|seed| forage(forager, -1, -1, seed, &[-1, -1, -1, -1]).0)
+        .collect()
+}
+
+const COMPONENTS: DefaultLocalSearchComponents = DefaultLocalSearchComponents {
+    acceptor: DefaultLocalSearchAcceptorPolicy::LateAcceptance { history_size: 400 },
+    forager: DefaultLocalSearchForagerPolicy::AcceptedCount { limit: 4 },
+};
+
+#[test]
+fn the_default_forager_follows_the_score_tie_break() {
+    let (_, mut random) =
+        build_acceptor_and_forager::<Plan>(COMPONENTS, None, None, ScoreTieBreak::Random, Some(7));
+    assert!(tie_picks(&mut random).len() > 1);
+
+    let (_, mut first) =
+        build_acceptor_and_forager::<Plan>(COMPONENTS, None, None, ScoreTieBreak::First, Some(7));
+    assert_eq!(tie_picks(&mut first), [0].into());
+}
+
+#[test]
+fn the_tabu_search_default_forager_follows_the_score_tie_break() {
+    let tabu =
+        CompiledAcceptor::<Plan>::compile(&AcceptorConfig::TabuSearch(TabuSearchConfig::default()))
+            .expect("the default tabu search config is valid");
+
+    let (_, mut random) = build_acceptor_and_forager::<Plan>(
+        COMPONENTS,
+        Some(&tabu),
+        None,
+        ScoreTieBreak::Random,
+        Some(7),
+    );
+    assert!(tie_picks(&mut random).len() > 1);
+
+    let (_, mut first) = build_acceptor_and_forager::<Plan>(
+        COMPONENTS,
+        Some(&tabu),
+        None,
+        ScoreTieBreak::First,
+        Some(7),
+    );
+    assert_eq!(tie_picks(&mut first), [0].into());
+}