Make simulated annealing use a struct

Closes #88

Author: adnathanail

benches/benchmarks.rs

@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use broute::graphs::algorithms::{
-    form_abstracted_graph, travelling_salesman, ConnectedComponents, Dijkstra,
+    form_abstracted_graph, SimulatedAnnealing, ConnectedComponents, Dijkstra,
 };
 use broute::graphs::datastructures::{Digraph, NodeIndex};
 use broute::graphs::input::{get_random_graph, load_pbf_file, load_tsplib_file, load_xgmml_file};
@@ -77,7 +77,10 @@ fn travelling_salesman_benchmark(c: &mut Criterion) {
     group.bench_with_input(
         BenchmarkId::new("DIMCAS d1291", &dimacs_g),
         &dimacs_g,
-        |b, g| b.iter(|| travelling_salesman(g, false)),
+        |b, g| b.iter(|| {
+            let mut sa = SimulatedAnnealing::new(g);
+            sa.run();
+        }),
     );
 
     let monaco_g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf").unwrap();
@@ -95,7 +98,10 @@ fn travelling_salesman_benchmark(c: &mut Criterion) {
     group.bench_with_input(
         BenchmarkId::new("OSM Monaco - 5 random nodes", &abstracted_graph),
         &abstracted_graph,
-        |b, g| b.iter(|| travelling_salesman(g, false)),
+        |b, g| b.iter(|| {
+            let mut sa = SimulatedAnnealing::new(g);
+            sa.run();
+        }),
     );
 
     group.finish();

src/graphs/algorithms/travelling_salesman.rs

@@ -34,97 +34,109 @@ pub fn form_abstracted_graph(g: &dyn Digraph, node_ids: &Vec<NodeID>) -> AMDigra
     abstracted_graph
 }
 
-fn get_potential_new_path(
-    rng: &mut ThreadRng,
-    g: &dyn Digraph,
-    current_path: &GraphPath,
-) -> GraphPath {
-    let mut potential_new_path = current_path.clone();
-
-    let node_index_to_mutate = rng.gen_range(0..(g.num_vertices() - 1));
+pub struct SimulatedAnnealing<'a> {
+    g: &'a dyn Digraph,
+    result_data: Vec<(f64, f64)>,
+    current_path: GraphPath,
+    path_length: f64,
+    best_path: GraphPath,
+    rng: ThreadRng,
+}
 
-    let reverse_or_transport: bool = rng.gen();
+impl<'a> SimulatedAnnealing<'a> {
+    pub fn new(g: &'a dyn Digraph) -> Self {
+        let mut rng = thread_rng();
 
-    if reverse_or_transport {
-        let node_index_to_swap_with = if node_index_to_mutate < (g.num_vertices() - 1) {
-            node_index_to_mutate + 1
-        } else {
-            0
+        let mut current_path = GraphPath {
+            path: (0..g.num_vertices()).map(NodeIndex).collect(),
         };
-        potential_new_path
-            .path
-            .swap(node_index_to_mutate, node_index_to_swap_with);
-    } else {
-        // Cyclic permutation
-        let node_to_move = potential_new_path.path[node_index_to_mutate];
-        // -2 because we are looking for new position with 1 node missing
-        let new_node_position = rng.gen_range(0..(g.num_vertices() - 2));
-        potential_new_path.path.remove(node_index_to_mutate);
-        potential_new_path
-            .path
-            .insert(new_node_position, node_to_move)
+        current_path.path.shuffle(&mut rng);
+
+        let path_length = current_path.get_length_on_graph(g);
+
+        let best_path = current_path.clone();
+        SimulatedAnnealing {
+            g,
+            result_data: vec![],
+            current_path,
+            path_length,
+            best_path,
+            rng,
+        }
     }
 
-    potential_new_path
-}
-
-pub fn travelling_salesman(g: &dyn Digraph, output_graph: bool) -> GraphPath {
-    let mut result_data: Vec<(f64, f64)> = vec![];
-
-    let mut rng = thread_rng();
+    pub fn run(&mut self) {
+        let mut temp = f64::sqrt(self.g.num_vertices() as f64);
+        let mut iterations = 0;
+        while temp > 1e-8_f64 && iterations < (100 * self.g.num_vertices()) {
+            let potential_new_path = self.get_potential_new_path();
+
+            let new_path_length = potential_new_path.get_length_on_graph(self.g);
+            if new_path_length < self.path_length {
+                self.current_path = potential_new_path;
+                self.best_path.clone_from(&self.current_path);
+                self.path_length = new_path_length;
+            } else {
+                // TODO: Is this between 0 and 1?
+                if f64::exp(-f64::abs(new_path_length - self.path_length) / temp) > self.rng.gen::<f64>() {
+                    self.current_path = potential_new_path;
+                    self.path_length = new_path_length;
+                }
+            }
 
-    let mut current_path = GraphPath {
-        path: (0..g.num_vertices()).map(NodeIndex).collect(),
-    };
-    current_path.path.shuffle(&mut rng);
-    let mut path_length = current_path.get_length_on_graph(g);
+            temp *= 0.995;
+            iterations += 1;
+            self.result_data.push((temp, self.path_length));
+        }
+    }
 
-    let mut best_path = current_path.clone();
+    fn get_potential_new_path(&mut self) -> GraphPath {
+        let mut potential_new_path = self.current_path.clone();
 
-    // println!("Initial state");
-    //
-    // println!("\t{:?}", best_path.path);
-    // println!("\t{}", path_length);
+        let node_index_to_mutate = self.rng.gen_range(0..(self.g.num_vertices() - 1));
 
-    let mut temp = f64::sqrt(g.num_vertices() as f64);
-    let mut iterations = 0;
-    while temp > 1e-8_f64 && iterations < (100 * g.num_vertices()) {
-        // println!("{}", temp);
-        let potential_new_path = get_potential_new_path(&mut rng, g, &current_path);
+        let reverse_or_transport: bool = self.rng.gen();
 
-        let new_path_length = potential_new_path.get_length_on_graph(g);
-        if new_path_length < path_length {
-            current_path = potential_new_path;
-            best_path.clone_from(&current_path);
-            path_length = new_path_length;
+        if reverse_or_transport {
+            let node_index_to_swap_with = if node_index_to_mutate < (self.g.num_vertices() - 1) {
+                node_index_to_mutate + 1
+            } else {
+                0
+            };
+            potential_new_path
+                .path
+                .swap(node_index_to_mutate, node_index_to_swap_with);
         } else {
-            // TODO: Is this between 0 and 1?
-            if f64::exp(-f64::abs(new_path_length - path_length) / temp) > rng.gen::<f64>() {
-                current_path = potential_new_path;
-                path_length = new_path_length;
-            }
+            // Cyclic permutation
+            let node_to_move = potential_new_path.path[node_index_to_mutate];
+            // -2 because we are looking for new position with 1 node missing
+            let new_node_position = self.rng.gen_range(0..(self.g.num_vertices() - 2));
+            potential_new_path.path.remove(node_index_to_mutate);
+            potential_new_path
+                .path
+                .insert(new_node_position, node_to_move)
         }
 
-        temp *= 0.995;
-        iterations += 1;
-        result_data.push((temp, path_length));
+        potential_new_path
+    }
+
+    pub fn get_best_path(&self) -> &GraphPath {
+        &self.best_path
     }
 
-    if output_graph {
+    pub fn output_graph(&self) {
         // We create our scatter plot from the data
         let s1: Plot =
-            Plot::new(result_data.clone()).line_style(LineStyle::new().colour("#DD3355"));
+            Plot::new(self.result_data.clone()).line_style(LineStyle::new().colour("#DD3355"));
 
         // The 'view' describes what set of data is drawn
         let v = ContinuousView::new()
             .add(s1)
             .x_label("Temperature")
             .y_label("Path length")
-            .y_range(0.0, result_data[0].1 + 100.0);
+            .y_range(0.0, self.result_data[0].1 + 100.0);
 
         // A page with a single view is then saved to an SVG file
         Page::single(&v).save("out/tsp_test_1.svg").unwrap();
     }
-
-    best_path
 }

src/main.rs

@@ -10,7 +10,7 @@ use rocket::serde::{Deserialize, Serialize};
 use rocket::serde::json::Json;
 
 use broute::graphs::algorithms::{
-    ConnectedComponents, Dijkstra, form_abstracted_graph, travelling_salesman,
+    ConnectedComponents, Dijkstra, form_abstracted_graph, SimulatedAnnealing,
 };
 use broute::graphs::datastructures::{ALDigraph, Digraph, LatLng, NodeID};
 use broute::graphs::input::load_pbf_file;
@@ -109,16 +109,17 @@ fn route_optimisation(
 
     println!("Abstracted graph constructed");
 
-    let p = travelling_salesman(&abstracted_graph, false);
+    let mut sa = SimulatedAnnealing::new(&abstracted_graph);
+    sa.run();
 
     println!("TSP ran");
 
     let mut p_node_ids = vec![];
-    for p_node_index in p.path {
+    for p_node_index in &sa.get_best_path().path {
         p_node_ids.push(
             abstracted_graph
                 .nodes_data()
-                .get_node_id_by_index(&p_node_index),
+                .get_node_id_by_index(p_node_index),
         )
     }
 

tests/graphs/shortest_path_tests.rs

@@ -46,7 +46,7 @@ fn simple_dijkstra_test() {
 #[test]
 fn osm_dijkstra_test() {
     // Load graph
-    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf");
+    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf").unwrap();
     // Get largest connected subgraph
     let mut cc = ConnectedComponents::new(&g);
     cc.run();

tests/graphs/travelling_salesman_tests.rs

@@ -1,4 +1,4 @@
-use broute::graphs::algorithms::{form_abstracted_graph, travelling_salesman, ConnectedComponents};
+use broute::graphs::algorithms::{form_abstracted_graph, SimulatedAnnealing, ConnectedComponents};
 use broute::graphs::datastructures::{Digraph, LatLng, NodeID, NodeIndex};
 use broute::graphs::input::load_pbf_file;
 
@@ -19,7 +19,7 @@ fn check_graph_adjacency(
 #[test]
 fn dijkstra_travelling_salesman_integration_test() {
     // Load graph
-    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf");
+    let g = load_pbf_file("test_data/geofabrik/monaco-latest.osm.pbf").unwrap();
 
     // Get largest connected subgraph
     let mut cc = ConnectedComponents::new(&g);
@@ -130,8 +130,9 @@ fn dijkstra_travelling_salesman_integration_test() {
     // Run TSP
     let mut path_lengths: Vec<f64> = vec![];
     for _ in 0..100 {
-        let best_path = travelling_salesman(&abstracted_graph, false);
-        path_lengths.push(best_path.get_length_on_graph(&abstracted_graph));
+        let mut sa = SimulatedAnnealing::new(&abstracted_graph);
+        sa.run();
+        path_lengths.push(sa.get_best_path().get_length_on_graph(&abstracted_graph));
     }
     assert!((path_lengths.into_iter().sum::<f64>() / 100.0) < 8.0);