Formatting with rustfmt

nitsatiisc · nitsatiisc · commit ca1eb3cb01a6 · 2025-01-15T19:39:37.000+05:30
diff --git a/rustworkx-core/src/shortest_path/simple_shortest_paths.rs b/rustworkx-core/src/shortest_path/simple_shortest_paths.rs
@@ -10,59 +10,58 @@
 // License for the specific language governing permissions and limitations
 // under the License.
 
-use crate::petgraph::algo::{Measure};
+use crate::petgraph::algo::Measure;
 use crate::petgraph::graph::{Graph, Node, NodeIndex};
-use crate::petgraph::visit::{EdgeRef, IntoEdges, VisitMap, Visitable, IntoEdgeReferences};
+use crate::petgraph::visit::{EdgeRef, IntoEdgeReferences, IntoEdges, VisitMap, Visitable};
 use crate::petgraph::EdgeType;
 
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::collections::{BinaryHeap, HashMap, HashSet};
 use std::fmt::Debug;
 use std::hash::Hash;
 
+use crate::min_scored::MinScored;
 use petgraph::data::DataMap;
 use petgraph::graph::{Edge, EdgeIndex, EdgeReference, GraphIndex};
 use petgraph::visit::{GraphBase, GraphRef};
 use rand::Rng;
-use crate::min_scored::MinScored;
-
-
 
 #[derive(Debug)]
-struct NodeData<N, K>
-{
-    pub node_id: N,                             // node identifier
-    pub parent_id: Option<N>,                   // parent identifier
-    pub cost: K,                                // cost of minimum path from source
+struct NodeData<N, K> {
+    pub node_id: N,           // node identifier
+    pub parent_id: Option<N>, // parent identifier
+    pub cost: K,              // cost of minimum path from source
 }
 
-
-
 pub fn dijkstra_shortest_path_with_excluded_prefix<G, F, K>(
     graph: G,
     start: G::NodeId,
     target: G::NodeId,
-    mut edge_cost:F,
+    mut edge_cost: F,
     excluded_prefix: &HashSet<G::NodeId>,
 ) -> (Vec<G::NodeId>, K)
 where
     G: Visitable + IntoEdges,
     G::NodeId: Eq + Hash,
     F: FnMut(G::EdgeRef) -> K,
     K: Measure + Copy,
-    G::NodeId: Debug, <G as IntoEdgeReferences>::EdgeRef: PartialEq
+    G::NodeId: Debug,
+    <G as IntoEdgeReferences>::EdgeRef: PartialEq,
 {
     let mut visit_map = graph.visit_map();
     let mut scores: HashMap<G::NodeId, K> = HashMap::new();
-    let mut pathnodes: HashMap<G::NodeId, NodeData<G::NodeId,K>> = HashMap::new();
-    let mut visit_next: BinaryHeap<MinScored< K, G::NodeId> > = BinaryHeap::new();
+    let mut pathnodes: HashMap<G::NodeId, NodeData<G::NodeId, K>> = HashMap::new();
+    let mut visit_next: BinaryHeap<MinScored<K, G::NodeId>> = BinaryHeap::new();
     visit_next.push(MinScored(K::default(), start));
     scores.insert(start, K::default());
-    pathnodes.insert(start, NodeData {
-        node_id: start,
-        parent_id: None,
-        cost: K::default()
-    });
+    pathnodes.insert(
+        start,
+        NodeData {
+            node_id: start,
+            parent_id: None,
+            cost: K::default(),
+        },
+    );
 
     // In the loop below, all the nodes which have been assigned the shortest path from source
     // are marked as visited. The visisted nodes are not present in the heap, and hence we do not
@@ -75,7 +74,7 @@ where
             let v = edge.target();
 
             // don't traverse the nodes marked for exclusion, or which have been visited.
-            if visit_map.is_visited(&v) || excluded_prefix.contains(&v){
+            if visit_map.is_visited(&v) || excluded_prefix.contains(&v) {
                 continue;
             }
 
@@ -95,9 +94,12 @@ where
                                 cost: node_score + edge_weight,
                             };
                             pathnodes.insert(v_pnode.node_id, new_node);
-
                         } else {
-                            assert_eq!(true, false, "Invariant not satisfied, Node {:?} not present in pathnodes", v);
+                            assert_eq!(
+                                true, false,
+                                "Invariant not satisfied, Node {:?} not present in pathnodes",
+                                v
+                            );
                         }
                     }
                 }
@@ -107,11 +109,14 @@ where
                     // Create the entry in the priority queue and an entry in the pathnodes map.
                     scores.insert(v, node_score + edge_weight);
                     visit_next.push(MinScored(node_score + edge_weight, v));
-                    pathnodes.insert(v, NodeData {
-                        node_id: v,
-                        parent_id: Some(node),
-                        cost: node_score + edge_weight
-                    });
+                    pathnodes.insert(
+                        v,
+                        NodeData {
+                            node_id: v,
+                            parent_id: Some(node),
+                            cost: node_score + edge_weight,
+                        },
+                    );
                 }
             }
         }
@@ -136,8 +141,6 @@ where
     }
 }
 
-
-
 /// Implementation of Yen's Algorithm to find k shortest paths.
 pub fn get_smallest_k_paths_yen<N, K, T>(
     graph: &mut Graph<N, K, T>,
@@ -149,14 +152,14 @@ where
     K: Measure + Copy,
     T: EdgeType,
 {
-    let mut listA: Vec < Vec <NodeIndex > > = Vec::new(); // list to contain shortest paths
+    let mut listA: Vec<Vec<NodeIndex>> = Vec::new(); // list to contain shortest paths
     let (shortest_path, min_cost) = dijkstra_shortest_path_with_excluded_prefix(
         &*graph,
         start,
         target,
-        |e| {*e.weight()},
-        &HashSet::new());
-
+        |e| *e.weight(),
+        &HashSet::new(),
+    );
 
     println!("Inserting path of cost {:?} in listA", min_cost);
     listA.push(shortest_path);
@@ -180,38 +183,40 @@ where
         // A diverging path at x[j] is formed as union of current path till node x[j], and the shortest path
         // from x[j] to target after removing prohibited edges (see above).
 
-        let mut current_path = listA[i-1].to_owned();                                   // current path is the last added path in listA
-        let mut excluded_edges_map: HashMap<(NodeIndex, NodeIndex), K> = HashMap::new();                // map to keep track of removed edges, which are added back later
-        let mut root_cost = K::default();                                                           // keep track of the cost of current path till diversion point.
+        let mut current_path = listA[i - 1].to_owned(); // current path is the last added path in listA
+        let mut excluded_edges_map: HashMap<(NodeIndex, NodeIndex), K> = HashMap::new(); // map to keep track of removed edges, which are added back later
+        let mut root_cost = K::default(); // keep track of the cost of current path till diversion point.
 
         for j in 0usize..current_path.len() - 1 {
             // we are looking for diversion at current_path[j]
             let root_node = current_path[j];
-            let next_edge = graph.find_edge(root_node, current_path[j+1]).unwrap();
+            let next_edge = graph.find_edge(root_node, current_path[j + 1]).unwrap();
             let next_edge_cost = *graph.edge_weight(next_edge).unwrap();
 
             for path in listA.iter() {
                 // for each path that agrees with current path till node j,
                 // remove the neighbor of j^{th} node on that path.
-                if path.len() < j+1 {
+                if path.len() < j + 1 {
                     continue;
                 }
 
                 if path[0..=j] == current_path[0..=j] {
-                    if let Some(edge) = graph.find_edge(root_node, path[j+1]) {
-                        excluded_edges_map.insert((root_node, path[j + 1]), *graph.edge_weight(edge).unwrap());
+                    if let Some(edge) = graph.find_edge(root_node, path[j + 1]) {
+                        excluded_edges_map
+                            .insert((root_node, path[j + 1]), *graph.edge_weight(edge).unwrap());
                         graph.remove_edge(edge);
                     }
                 }
             }
             // find the shortest path form root_node to target in the graph after removing prohibited edges.
-            let (shortest_root_target_path, path_cost) = dijkstra_shortest_path_with_excluded_prefix(
-                &*graph,
-                root_node,
-                target,
-                |e| {*e.weight()},
-                &HashSet::from_iter(current_path[0..=j].to_vec().into_iter()),
-            );
+            let (shortest_root_target_path, path_cost) =
+                dijkstra_shortest_path_with_excluded_prefix(
+                    &*graph,
+                    root_node,
+                    target,
+                    |e| *e.weight(),
+                    &HashSet::from_iter(current_path[0..=j].to_vec().into_iter()),
+                );
 
             if shortest_root_target_path.len() > 0 {
                 // create new_path by appending current_path till divergence point and the shortest path after that.
@@ -228,7 +233,7 @@ where
 
             // add current edge cost to the root cost
             root_cost = root_cost + next_edge_cost;
-        };
+        }
 
         // finally restore the edges we removed to reset the graph for next iteration
         for (edge, wt) in &excluded_edges_map {
@@ -249,45 +254,12 @@ where
 }
 
 
-
-/// To return next possible target for the path.
-/// if all possible nodes are traced, then it picks the shortest endpoint and pick the nodes of next nodes.
-
-fn get_smallest_k_element<P>(scores : & HashMap<NodeIndex,P> , visited : &mut Vec<NodeIndex>) -> 
-Option<NodeIndex> where P: Copy + std::cmp::PartialOrd  + std::default::Default  + std::ops::Add<Output = P>  + std::fmt::Debug{
-    if scores.len() == 1 {
-        for (node,_score) in scores {
-            return Some(node.clone());
-        }
-    }
-    else {
-        let mut score_vec: Vec<_> = scores.iter().collect();
-        score_vec.sort_by(|&(_, &score1), &(_, &score2)| {
-            score1.partial_cmp(&score2).unwrap_or(std::cmp::Ordering::Equal)
-        });
-        let mut count = 0;
-        for (node,_score) in &score_vec {
-            if ! visited.contains(node) {
-                visited.push(**node);
-                return Some(**node); 
-            }  
-            count = count + 1;
-            if count == score_vec.len() {
-                return Some(*score_vec[0].0);
-            }
-        }
-
-    }
-    return None;
-}
-
-
 #[cfg(test)]
 mod tests {
-    use petgraph::{Graph, Undirected};
+    use crate::shortest_path::simple_shortest_paths::get_smallest_k_paths_yen;
     use petgraph::graph::NodeIndex;
+    use petgraph::{Graph, Undirected};
     use rand::Rng;
-    use crate::shortest_path::simple_shortest_paths::{get_smallest_k_paths_yen};
 
     // The function below generates a graph consisting of n hexagons between two terminal vertices.
     // All edges have weights 1. The illustration below shows the graph for n=2.
@@ -300,19 +272,26 @@ mod tests {
     //
     fn generate_n_cycle_example(n: usize) -> (Graph<usize, u32, Undirected>, Vec<NodeIndex>) {
         let mut g: Graph<usize, u32, Undirected> = Graph::new_undirected();
-        let num_nodes = 6*n + 2;
+        let num_nodes = 6 * n + 2;
         let mut node_names: Vec<usize> = Vec::new();
-        for i in 0.. num_nodes {
+        for i in 0..num_nodes {
             node_names.push(i);
         }
-        let mut nodes = (0..num_nodes).into_iter().map(|i| g.add_node(node_names[i])).collect::<Vec<_>>();
+        let mut nodes = (0..num_nodes)
+            .into_iter()
+            .map(|i| g.add_node(node_names[i]))
+            .collect::<Vec<_>>();
         // build cycles
-        for i in 0.. n {
+        for i in 0..n {
             let base = 6 * i + 1;
             for j in 0..6 {
-                g.add_edge(nodes[base + (j % 6)], nodes[base + ((j + 1) % 6)], (j+1) as u32);
+                g.add_edge(
+                    nodes[base + (j % 6)],
+                    nodes[base + ((j + 1) % 6)],
+                    (j + 1) as u32,
+                );
             }
-            g.add_edge(nodes[base + 3], nodes[base+6],1);
+            g.add_edge(nodes[base + 3], nodes[base + 6], 1);
         }
 
         g.add_edge(nodes[0], nodes[1], 1);
@@ -325,45 +304,48 @@ mod tests {
         let mut g: Graph<usize, u32, Undirected> = Graph::new_undirected();
         let num_nodes = n;
         let mut node_names: Vec<usize> = Vec::new();
-        for i in 0.. num_nodes {
+        for i in 0..num_nodes {
             node_names.push(i);
         }
-        let mut nodes = (0..num_nodes).into_iter().map(|i| g.add_node(node_names[i])).collect::<Vec<_>>();
+        let mut nodes = (0..num_nodes)
+            .into_iter()
+            .map(|i| g.add_node(node_names[i]))
+            .collect::<Vec<_>>();
         // build cycles
-        for i in 0.. n {
-            g.add_edge(nodes[i], nodes[(i+1) % n], 1);
+        for i in 0..n {
+            g.add_edge(nodes[i], nodes[(i + 1) % n], 1);
         }
         (g, nodes)
     }
 
     // This function generates an undirected n-gon as in previous example, with additional chords.
     // The argument step specifies the clockwise distance between vertices connected by the chords.
-    fn generate_n_gon_with_chords_example(n: usize, step: usize) -> (Graph<usize, u32, Undirected>, Vec<NodeIndex>) {
+    fn generate_n_gon_with_chords_example(
+        n: usize,
+        step: usize,
+    ) -> (Graph<usize, u32, Undirected>, Vec<NodeIndex>) {
         let mut g: Graph<usize, u32, Undirected> = Graph::new_undirected();
         let num_nodes = n;
         let mut node_names: Vec<usize> = Vec::new();
-        for i in 0.. num_nodes {
+        for i in 0..num_nodes {
             node_names.push(i);
         }
-        let mut nodes = (0..num_nodes).into_iter().map(|i| g.add_node(node_names[i])).collect::<Vec<_>>();
+        let mut nodes = (0..num_nodes)
+            .into_iter()
+            .map(|i| g.add_node(node_names[i]))
+            .collect::<Vec<_>>();
         // build cycles
-        for i in 0.. n {
-            g.add_edge(nodes[i], nodes[(i+1) % n], 1);
-            g.add_edge(nodes[i], nodes[(i+step) % n], 1);
+        for i in 0..n {
+            g.add_edge(nodes[i], nodes[(i + 1) % n], 1);
+            g.add_edge(nodes[i], nodes[(i + step) % n], 1);
         }
         (g, nodes)
     }
 
-
     #[test]
     fn test_k_shortest_paths() {
         let (mut graph, nodes) = generate_n_gon_with_chords_example(6, 2);
-        let paths = get_smallest_k_paths_yen(
-            &mut graph,
-            nodes[0],
-            nodes[1],
-             10
-        );
+        let paths = get_smallest_k_paths_yen(&mut graph, nodes[0], nodes[1], 10);
         for path in paths {
             println!("{:#?}", path);
         }
@@ -374,23 +356,23 @@ mod tests {
         let mut g = Graph::new_undirected();
         let nodes: Vec<NodeIndex> = (0..5000).map(|_| g.add_node(())).collect();
         let mut rng: rand::prelude::ThreadRng = rand::thread_rng();
-        for _ in 0..62291 { // Adjust the number of edges as desired
+        for _ in 0..62291 {
+            // Adjust the number of edges as desired
             let a = rng.gen_range(0..nodes.len());
             let b = rng.gen_range(0..nodes.len());
             let weight = rng.gen_range(1..100); // Random weight between 1 and 100
-            if a != b { // Prevent self-loops
-                g.add_edge(nodes[a], nodes[b], weight as f32);        }
+            if a != b {
+                // Prevent self-loops
+                g.add_edge(nodes[a], nodes[b], weight as f32);
+            }
         }
         println!("Graph created");
         let source = nodes[1];
         let target = nodes[4000];
-        let shortest_path_get :usize = 5;
+        let shortest_path_get: usize = 5;
         //println!(“{:?}“, g);
-        for p in get_smallest_k_paths_yen( &mut g,source,target,10) {
-            println!("Path:  {:#?} ",p);
+        for p in get_smallest_k_paths_yen(&mut g, source, target, 10) {
+            println!("Path:  {:#?} ", p);
         }
-
     }
 }
-
-
