quick save

Makefile

@@ -0,0 +1,5 @@
+build:
+	cargo build --release
+
+run:
+	./target/release/graph_lib_rust ${mode} ${target}

src/graph/digraph.rs

@@ -0,0 +1,72 @@
+use crate::graph::vertex::{Vertex, VertexId};
+use crate::graph::edge::Edge;
+use crate::graph::Graph;
+use std::collections::HashSet;
+
+pub struct DiGraph {
+    vertices: Vec<Vertex>,
+    edges: Vec<Edge>,
+    strong_components: Vec<Vec<Vertex>>,
+}
+
+impl DiGraph {
+    pub fn new(vertices: Vec<Vertex>, edges: Vec<Edge>) -> DiGraph {
+        DiGraph {
+            vertices,
+            edges,
+            strong_components: Vec::new(),
+        }
+    }
+
+    fn search_forward(&self) -> Vec<Vertex> {
+        let mut visited: HashSet<VertexId> = HashSet::new();
+        let mut vertex_stack: Vec<VertexId> = Vec::new();
+        for vertex in &self.vertices {
+            if !visited.contains(&vertex.id()) {
+                let connected: Vec<VertexId> = self.visit_forward(&mut visited, &mut vertex_stack, vertex);
+            }
+        };
+
+        println!("{:?}", vertex_stack);
+
+        vertex_stack.iter().map(|&x| self.vertices[x].clone()).collect()
+    }
+
+    fn visit_forward(&self, visited: &mut HashSet<VertexId>, vertex_stack: &mut Vec<VertexId>, vertex: &Vertex) -> Vec<VertexId> {
+        println!("Visit {}", vertex.id());
+        visited.insert(*vertex.id());
+        let mut connected = vec![*vertex.id()];
+        let neighbours: Vec<&Vertex> = self.get_neighbours(vertex);
+        for neighbour in neighbours {
+            if !visited.contains(neighbour.id()) {
+                connected.append(&mut self.visit_forward(visited, vertex_stack, neighbour))
+            }
+        };
+        vertex_stack.push(*vertex.id());
+        println!("Adding thing {} to stack", vertex.id());
+        connected
+    }
+}
+
+impl Graph for DiGraph {
+    fn get_vertices(&self) -> &Vec<Vertex> {
+        &self.vertices
+    }
+
+    fn get_edges(&self) -> &Vec<Edge> {
+        &self.edges
+    }
+
+    fn get_vertices_as_mut(&mut self) -> &mut Vec<Vertex> {
+        &mut self.vertices
+    }
+
+    fn get_edges_as_mut(&mut self) -> &mut Vec<Edge> {
+        &mut self.edges
+    }
+
+    fn find_strongly_connected_components(&self) -> () {
+
+        self.search_forward();
+    }
+}

src/graph/edge.rs

@@ -5,40 +5,40 @@ pub type EdgeId = usize;
 #[derive(Debug)]
 pub struct Edge {
     id: EdgeId,
-    vertex_a: VertexId,
-    vertex_b: VertexId,
+    start: VertexId,
+    end: VertexId,
 }
 
 impl Edge {
     pub fn new(id: EdgeId, vertex_a: VertexId, vertex_b: VertexId) -> Self {
         Edge {
             id,
-            vertex_a,
-            vertex_b,
+            start: vertex_a,
+            end: vertex_b,
         }
     }
 
     pub fn id(&self) -> &EdgeId {
         &self.id
     }
 
-    pub fn vertex_a(&self) -> &VertexId {
-        &self.vertex_a
+    pub fn start(&self) -> &VertexId {
+        &self.start
     }
 
-    pub fn vertex_b(&self) -> &VertexId {
-        &self.vertex_b
+    pub fn end(&self) -> &VertexId {
+        &self.end
     }
 
     pub fn get_other_vertex(&self, vertex: VertexId) -> &VertexId {
-        if self.vertex_a == vertex {
-            &self.vertex_b
+        if self.start == vertex {
+            &self.end
         } else {
-            &self.vertex_a
+            &self.start
         }
     }
 
     fn is_adjacent(&self, vertex: VertexId) -> bool {
-        vertex == self.vertex_a || vertex == self.vertex_b
+        vertex == self.start || vertex == self.end
     }
 }

src/graph/mod.rs

@@ -1,77 +1,97 @@
-use std::collections::HashSet;
 use std::fs::File;
 use std::io;
 use std::io::{BufRead, BufReader};
 use std::time::Instant;
 
-use crate::graph::edge::Edge;
-use crate::graph::private_graph::PrivateGraph;
 use crate::graph::ugraph::UndirectedGraph;
-use crate::graph::vertex::{Vertex, VertexId};
+use crate::graph::vertex::{VertexId, Vertex};
+use crate::graph::edge::{Edge, EdgeId};
+use crate::graph::digraph::DiGraph;
 
 mod vertex;
 mod edge;
 
 pub mod ugraph;
+pub mod digraph;
 
 pub fn create_undirected_graph(file: File) -> UndirectedGraph {
     let now = Instant::now();
-    let graph: UndirectedGraph = Graph::new(&file);
+    let mut graph: UndirectedGraph = UndirectedGraph::new(Vec::new(), Vec::new());
+    graph.read_from_file(&file);
     println!("{}", now.elapsed().as_micros());
 
     graph
 }
 
-pub trait Graph {
-    fn new(file: &File) -> Self;
-    fn find_strong_connected_components(&self) -> ();
+pub fn create_directed_graph(file: File) -> DiGraph {
+    let now = Instant::now();
+    let mut graph: DiGraph = DiGraph::new(Vec::new(), Vec::new());
+    graph.read_from_file(&file);
+    println!("{}", now.elapsed().as_micros());
+
+    graph
 }
 
-mod private_graph {
-    use crate::graph::edge::{Edge, EdgeId};
-    use crate::graph::vertex::{Vertex, VertexId};
+pub trait Graph {
+    fn read_from_file(&mut self, file: &File) -> () {
+        let reader = BufReader::new(file);
+
+        let mut first = true;
+        for line in reader.lines().filter_map(io::Result::ok) {
+            if first {
+                let count: i32 = line.parse().unwrap();
+                for _ in 0..count {
+                    self.add_vertex();
+                }
+                first = false;
+            } else {
+                let vertices = line.trim().split(' ').flat_map(str::parse::<VertexId>).collect::<Vec<_>>();
+                self.add_edge(vertices[0], vertices[1]);
+            }
+        }
+    }
+    fn add_vertex(&mut self) -> VertexId {
+        let id = self.get_free_vertex_id();
+        let vertex = Vertex::new(id, Vec::new());
+        self.get_vertices_as_mut().push(vertex);
 
-    pub trait PrivateGraph {
-        fn get_vertices(&self) -> &Vec<Vertex>;
-        fn get_edges(&self) -> &Vec<Edge>;
+        id
+    }
 
-        fn get_vertices_as_mut(&mut self) -> &mut Vec<Vertex>;
-        fn get_edges_as_mut(&mut self) -> &mut Vec<Edge>;
+    fn add_edge(&mut self, vertex_a: VertexId, vertex_b: VertexId) -> EdgeId {
+        let id = self.get_free_edge_id();
+        let edge = Edge::new(id, vertex_a, vertex_b);
+        self.get_vertices_as_mut()[vertex_a].add_edge(id);
+        self.get_vertices_as_mut()[vertex_b].add_edge(id);
+        self.get_edges_as_mut().push(edge);
 
-        fn get_free_vertex_id(&mut self) -> VertexId {
-            self.get_vertices().len() as VertexId
-        }
+        id
+    }
 
-        fn get_free_edge_id(&mut self) -> EdgeId {
-            self.get_edges().len() as EdgeId
-        }
+    fn get_free_vertex_id(&mut self) -> VertexId {
+        self.get_vertices().len() as VertexId
+    }
 
-        fn get_neighbours(&self, vertex: &Vertex) -> Vec<&Vertex> {
-            let neighbours: Vec<&Vertex> = vertex.edges()
-                .iter()
-                .map(|&x| self.get_edges()[x].get_other_vertex(*vertex.id()))
-                .map(|&x| &self.get_vertices()[x])
-                .collect();
-            neighbours
-        }
+    fn get_free_edge_id(&mut self) -> EdgeId {
+        self.get_edges().len() as EdgeId
+    }
 
-        fn add_vertex(&mut self) -> VertexId {
-            let id = self.get_free_vertex_id();
-            let vertex = Vertex::new(id, Vec::new());
-            self.get_vertices_as_mut().push(vertex);
+    fn get_vertices(&self) -> &Vec<Vertex>;
+    fn get_edges(&self) -> &Vec<Edge>;
 
-            id
-        }
+    fn get_vertices_as_mut(&mut self) -> &mut Vec<Vertex>;
+    fn get_edges_as_mut(&mut self) -> &mut Vec<Edge>;
 
-        fn add_edge(&mut self, vertex_a: VertexId, vertex_b: VertexId) -> EdgeId {
-            let id = self.get_free_edge_id();
-            let edge = Edge::new(id, vertex_a, vertex_b);
-            self.get_vertices_as_mut()[vertex_a].add_edge(id);
-            self.get_vertices_as_mut()[vertex_b].add_edge(id);
-            self.get_edges_as_mut().push(edge);
 
-            id
-        }
+    fn get_neighbours(&self, vertex: &Vertex) -> Vec<&Vertex> {
+        let neighbours: Vec<&Vertex> = vertex.edges()
+            .iter()
+            .map(|&x| self.get_edges()[x].get_other_vertex(*vertex.id()))
+            .map(|&x| &self.get_vertices()[x])
+            .collect();
+        neighbours
     }
+
+    fn find_strongly_connected_components(&self) -> ();
 }
 

src/graph/ugraph.rs

@@ -1,12 +1,8 @@
 use std::collections::HashSet;
-use std::fs::File;
-use std::io::{BufRead, BufReader};
-use std::io;
 use std::time::Instant;
 
 use crate::graph::edge::Edge;
 use crate::graph::Graph;
-use crate::graph::private_graph::PrivateGraph;
 use crate::graph::vertex::{Vertex, VertexId};
 
 #[derive(Debug)]
@@ -16,79 +12,56 @@ pub struct UndirectedGraph {
 }
 
 impl UndirectedGraph {
+    pub(crate) fn new(vertices: Vec<Vertex>, edges: Vec<Edge>) -> UndirectedGraph {
+        UndirectedGraph {
+            vertices,
+            edges,
+        }
+    }
+
     fn visit_forward(&self, visited: &mut HashSet<VertexId>, vertex: &Vertex, connected: &mut Vec<VertexId>) -> () {
         visited.insert(*vertex.id());
-        let neighbors: Vec<&Vertex> = self.get_neighbours(vertex);
         connected.push(*vertex.id());
 
-        for neighbor in neighbors {
-            if !visited.contains(neighbor.id()) {
-                self.visit_forward(visited, neighbor, connected)
+        let neighbours: Vec<&Vertex> = self.get_neighbours(vertex);
+        for neighbour in neighbours {
+            if !visited.contains(neighbour.id()) {
+                self.visit_forward(visited, neighbour, connected)
             }
         };
     }
 }
 
 impl Graph for UndirectedGraph {
-    fn new(file: &File) -> UndirectedGraph {
-        let reader = BufReader::new(file);
-
-        let mut graph: UndirectedGraph = UndirectedGraph {
-            vertices: Vec::new(),
-            edges: Vec::new(),
-        };
+    fn get_vertices(&self) -> &Vec<Vertex> {
+        &self.vertices
+    }
 
-        let mut first = true;
-        for line in reader.lines().filter_map(io::Result::ok) {
-            if first {
-                let count: i32 = line.parse().unwrap();
-                for _ in 0..count {
-                    graph.add_vertex();
-                }
-                first = false;
-            } else {
-                let vertices = line.trim().split(' ').flat_map(str::parse::<VertexId>).collect::<Vec<_>>();
-                graph.add_edge(vertices[0], vertices[1]);
-            }
-        }
+    fn get_edges(&self) -> &Vec<Edge> {
+        &self.edges
+    }
 
-        graph
+    fn get_vertices_as_mut(&mut self) -> &mut Vec<Vertex> {
+        &mut self.vertices
+    }
+    fn get_edges_as_mut(&mut self) -> &mut Vec<Edge> {
+        &mut self.edges
     }
 
-    fn find_strong_connected_components(&self) -> () {
-        let index = 0;
+    fn find_strongly_connected_components(&self) -> () {
         let mut visited: HashSet<VertexId> = HashSet::new();
-
-        let mut connections: Vec<Vec<VertexId>> = Vec::new();
-
+        let mut components: Vec<Vec<VertexId>> = Vec::new();
         let now = Instant::now();
 
         for vertex in &self.vertices {
             if !visited.contains(&vertex.id()) {
                 let mut connected: Vec<VertexId> = Vec::new();
                 self.visit_forward(&mut visited, vertex, &mut connected);
-                connections.push(connected)
+                components.push(connected)
             }
         };
 
-        println!("{}", now.elapsed().as_micros());
-        println!("Found {} connections.", connections.len());
+        println!("{}", now.elapsed().as_micros() / 1_000_000);
+        println!("Found {} connections.", components.len());
     }
 }
-
-impl PrivateGraph for UndirectedGraph {
-    fn get_vertices(&self) -> &Vec<Vertex> {
-        &self.vertices
-    }
-
-    fn get_edges(&self) -> &Vec<Edge> {
-        &self.edges
-    }
-
-    fn get_vertices_as_mut(&mut self) -> &mut Vec<Vertex> {
-        &mut self.vertices
-    }
-    fn get_edges_as_mut(&mut self) -> &mut Vec<Edge> {
-        &mut self.edges
-    }
-}