[Improver] Added soft_objective_threshold. An improvement on the soft_objective must be bigger than this threshold. Set it to 10.0

Author: LeonSering

src/main.rs

@@ -5,12 +5,12 @@ use sbb::run;
 fn main() {
     // run("test_instances/21-06-tage-1/");
     // run("test_instances/21-06-tage-2/");
-    // run("test_instances/21-06-tage-7/");
+    run("test_instances/21-06-tage-7/");
     // run("test_instances/21-09-tage-7/");
     // run("test_instances/21-09-tage-14/");
     // run("test_instances/21-09-tage-21/");
     // run("test_instances/21-09-tage-28/");
     // run("test_instances/21-10-tage-1/");
-    run("test_instances/21-10-tage-2/");
+    // run("test_instances/21-10-tage-2/");
     // run("test_instances/21-10-tage-7/");
 }

src/schedule.rs

@@ -257,7 +257,7 @@ impl Schedule {
             };
 
             let mut node_sequence = remaining_path.consume();
-            remaining_path = Path::new(node_sequence.split_off(end_pos+1), self.nw.clone());
+            remaining_path = Path::new_trusted(node_sequence.split_off(end_pos+1), self.nw.clone());
             let sub_segment = Segment::new(sub_segment_start, sub_segment_end);
             let remove_result = new_tour_provider.remove(sub_segment);
 

src/schedule/objective.rs

@@ -71,6 +71,21 @@ impl ObjectiveValue {
     }
 }
 
+impl ObjectiveValue {
+    pub fn cmp_with_threshold(&self, other: &Self, threshold: Cost) -> Ordering {
+        self.overhead_time.cmp(&other.overhead_time)
+            .then(self.number_of_dummy_units.cmp(&other.number_of_dummy_units))
+            .then(self.dummy_overhead_time.cmp(&other.dummy_overhead_time))
+            .then(self.maintenance_penalty.cmp(&other.maintenance_penalty))
+            .then(
+                match self.soft_objective_cost - other.soft_objective_cost {
+                    diff if diff > threshold => Ordering::Greater,
+                    diff if diff < -threshold => Ordering::Less,
+                    _ => Ordering::Equal
+                })
+    }
+}
+
 impl Ord for ObjectiveValue {
     fn cmp(&self, other: &Self) -> Ordering {
         self.overhead_time.cmp(&other.overhead_time)

src/schedule/path.rs

@@ -32,7 +32,10 @@ impl Path {
     /// crates a new Path and asserts that it is a path in the network
     pub(crate) fn new(node_sequence: Vec<NodeId>, nw: Arc<Network>) -> Path {
         for (&a,&b) in node_sequence.iter().tuple_windows() {
-            assert!(nw.can_reach(a,b),"Not a valid Path");
+            assert!(nw.can_reach(a,b),"Not a valid Path: {} cannot reach {}.", a, b);
+            // if !nw.can_reach(a,b) {
+                // println!("Not a valid Path: {} cannot reach {}.", a, b);
+            // }
         }
         Path{node_sequence, nw}
     }

src/solver/local_search.rs

@@ -18,9 +18,6 @@ use local_improver::LocalImprover;
 // use local_improver::TakeFirstRecursion;
 // use local_improver::TakeFirstParallelRecursion;
 use local_improver::TakeAnyParallelRecursion;
-// use super::greedy_1::Greedy1;
-// use super::greedy_2::Greedy2;
-use super::greedy_3::Greedy3;
 
 
 
@@ -66,11 +63,12 @@ impl Solver for LocalSearch {
 
         let recursion_depth = 5;
         let recursion_width = 5;
+        let soft_objective_threshold = 10.0;
 
         // let limited_local_improver = Minimizer::new(swap_factory);
-        // let limited_local_improver = TakeFirstRecursion::new(swap_factory,recursion_depth, Some(25));
-        // let limited_local_improver = TakeFirstParallelRecursion::new(swap_factory,recursion_depth, Some(recursion_width));
-        let limited_local_improver = TakeAnyParallelRecursion::new(swap_factory,recursion_depth, Some(recursion_width));
+        // let limited_local_improver = TakeFirstRecursion::new(swap_factory,recursion_depth, Some(25), soft_objective_threshold);
+        // let limited_local_improver = TakeFirstParallelRecursion::new(swap_factory,recursion_depth, Some(recursion_width), soft_objective_threshold);
+        let limited_local_improver = TakeAnyParallelRecursion::new(swap_factory,recursion_depth, Some(recursion_width), soft_objective_threshold);
 
         schedule = self.find_local_optimum(schedule, limited_local_improver);
         // self.find_local_optimum(schedule, limited_local_improver)
@@ -82,9 +80,9 @@ impl Solver for LocalSearch {
         let swap_factory = LimitedExchanges::new(Some(segment_limit), None, false, self.nw.clone());
 
         // let unlimited_local_improver = Minimizer::new(swap_factory);
-        // let unlimited_local_improver = TakeFirstRecursion::new(swap_factory,0,None);
-        // let unlimited_local_improver = TakeFirstParallelRecursion::new(swap_factory,0,None);
-        let unlimited_local_improver = TakeAnyParallelRecursion::new(swap_factory,0,Some(recursion_width));
+        // let unlimited_local_improver = TakeFirstRecursion::new(swap_factory,0,None,soft_objective_threshold);
+        // let unlimited_local_improver = TakeFirstParallelRecursion::new(swap_factory,0,None,soft_objective_threshold);
+        let unlimited_local_improver = TakeAnyParallelRecursion::new(swap_factory,0,Some(recursion_width), soft_objective_threshold);
 
         self.find_local_optimum(schedule, unlimited_local_improver)
 

src/solver/local_search/local_improver.rs

@@ -1,4 +1,5 @@
 use crate::schedule::Schedule;
+use crate::base_types::Cost;
 
 use super::swap_factory::SwapFactory;
 use crate::schedule::objective::ObjectiveValue;
@@ -61,6 +62,7 @@ pub(crate) struct TakeFirstRecursion<F: SwapFactory> {
     swap_factory: F,
     recursion_depth: u8,
     recursion_width: Option<usize>, // number of schedule that are considered for recursion (the one with best value are taken)
+    soft_objective_threshold: Cost,
 }
 
 
@@ -73,8 +75,8 @@ impl<F: SwapFactory> LocalImprover for TakeFirstRecursion<F> {
 
 impl<F: SwapFactory> TakeFirstRecursion<F> {
 
-    pub(crate) fn new(swap_factory: F, recursion_depth: u8, recursion_width: Option<usize>) -> TakeFirstRecursion<F> {
-        TakeFirstRecursion{swap_factory, recursion_depth, recursion_width}
+    pub(crate) fn new(swap_factory: F, recursion_depth: u8, recursion_width: Option<usize>, soft_objective_threshold: Cost) -> TakeFirstRecursion<F> {
+        TakeFirstRecursion{swap_factory, recursion_depth, recursion_width, soft_objective_threshold}
     }
 
 
@@ -98,7 +100,7 @@ impl<F: SwapFactory> TakeFirstRecursion<F> {
                     schedules_for_recursion.truncate(width);
                 }
             }
-            new_sched.objective_value() < objective_to_beat
+            new_sched.objective_value().cmp_with_threshold(&objective_to_beat, self.soft_objective_threshold).is_lt()
         });
 
         if result.is_none() {
@@ -137,6 +139,7 @@ pub(crate) struct TakeFirstParallelRecursion<F: SwapFactory + Send + Sync> {
     swap_factory: F,
     recursion_depth: u8,
     recursion_width: Option<usize>, // number of schedule that are considered per schedule for the next recursion (the one with best objectivevalue are taken for each schedule, dublicates are removed)
+    soft_objective_threshold: Cost, // improvement must be better than this threshold
 }
 
 
@@ -149,8 +152,8 @@ impl<F: SwapFactory + Send + Sync> LocalImprover for TakeFirstParallelRecursion<
 
 impl<F: SwapFactory + Send + Sync> TakeFirstParallelRecursion<F> {
 
-    pub(crate) fn new(swap_factory: F, recursion_depth: u8, recursion_width: Option<usize>) -> TakeFirstParallelRecursion<F> {
-        TakeFirstParallelRecursion{swap_factory, recursion_depth, recursion_width}
+    pub(crate) fn new(swap_factory: F, recursion_depth: u8, recursion_width: Option<usize>, soft_objective_threshold: Cost) -> TakeFirstParallelRecursion<F> {
+        TakeFirstParallelRecursion{swap_factory, recursion_depth, recursion_width, soft_objective_threshold}
     }
 
 
@@ -194,7 +197,7 @@ impl<F: SwapFactory + Send + Sync> TakeFirstParallelRecursion<F> {
                         if let Ok(best_i) = found_receiver.try_recv() {
                             counter_limit = best_i;
                         }
-                        new_sched.objective_value() < objective_to_beat || *i > counter_limit
+                        new_sched.objective_value().cmp_with_threshold(&objective_to_beat, self.soft_objective_threshold).is_lt() || *i > counter_limit
                     });
 
                     match result {
@@ -267,7 +270,7 @@ impl<F: SwapFactory + Send + Sync> TakeFirstParallelRecursion<F> {
 
 
 ///////////////////////////////////////////////////////////
-/////////////////// TakeAnyParallelRecursion //////////////////////
+/////////////// TakeAnyParallelRecursion //////////////////
 ///////////////////////////////////////////////////////////
 
 /// This improver uses parallel computation at two steps. In the recursion when multiple schedules
@@ -283,6 +286,7 @@ pub(crate) struct TakeAnyParallelRecursion<F: SwapFactory + Send + Sync> {
     swap_factory: F,
     recursion_depth: u8,
     recursion_width: Option<usize>, // number of schedule that are considered per schedule for the next recursion (the one with best objectivevalue are taken for each schedule, dublicates are removed)
+    soft_objective_threshold: Cost, // improvement must be better than this threshold
 }
 
 
@@ -295,8 +299,8 @@ impl<F: SwapFactory + Send + Sync> LocalImprover for TakeAnyParallelRecursion<F>
 
 impl<F: SwapFactory + Send + Sync> TakeAnyParallelRecursion<F> {
 
-    pub(crate) fn new(swap_factory: F, recursion_depth: u8, recursion_width: Option<usize>) -> TakeAnyParallelRecursion<F> {
-        TakeAnyParallelRecursion{swap_factory, recursion_depth, recursion_width}
+    pub(crate) fn new(swap_factory: F, recursion_depth: u8, recursion_width: Option<usize>, soft_objective_threshold: Cost) -> TakeAnyParallelRecursion<F> {
+        TakeAnyParallelRecursion{swap_factory, recursion_depth, recursion_width, soft_objective_threshold}
     }
 
 
@@ -344,7 +348,7 @@ impl<F: SwapFactory + Send + Sync> TakeAnyParallelRecursion<F> {
 
                         let found_receiver_mutex = found_receiver_mutex.lock().unwrap();
                         let found = found_receiver_mutex.try_recv();
-                        new_sched.objective_value() < objective_to_beat || found.is_ok()
+                        new_sched.objective_value().cmp_with_threshold(&objective_to_beat, self.soft_objective_threshold).is_lt() || found.is_ok()
                     });