graphunk 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3484b513a6924db90db6cef1e4d1a3a0c998e888
-  data.tar.gz: ced748e00283f8199d5b63ae25d7239232e46439
+  metadata.gz: 2fbceaea640b3b555fba08b526a211d0078a3dfd
+  data.tar.gz: 63fd21c8a5e0bf2b5f90de2cc9c848780f7e520a
 SHA512:
-  metadata.gz: 0ec2a5140951c25f4d21bc1b12e03c304870151a29651c0b3e1ebc2a77657ccd9132acf93085e53d1e94c4dffc93d12be91fd34e68291ecfaa7f34847e805f1b
-  data.tar.gz: 4aed0d585553025fe18facdfb860683ded5344803539aaded60056e4309038f5047021af6f12e38a44df82394ae0a17a64cede86aa8fe36ec98142aa22c6f114
+  metadata.gz: ffd51fc13f3a6c5d9e24ed05ed97f5958c53921b4f28099a924c40fc03006e0fa1a8d618f870fad83e6600ca0975f992b6a343d7d66ec3facc0e5d69114ff99f
+  data.tar.gz: 91a642dc7941b6697855302dcb5a8924f6864d7401d1b6ad44de9a7a3f5eb89c2bf9a4a5f2fa2998ed0604df706341e6134cccda09c92e60735ada49103abd5f

data/README.md

@@ -0,0 +1,67 @@
+# Graphunk
+
+Graphunk defines simple and fully-tested graph classes in Ruby which you can use to perform graph-theoretical operations.
+
+## Defining a Graph
+
+There are two kinds of graphs supported by this system, directed graphs and undirected graphs.
+
+Graphs inherit from Hash, so you can define a graph in the same way you would define a Hash:
+
+```
+UndirectedGraph[
+  'a' => ['b','c'],
+  'b' => ['c', 'd', 'e'],
+  'c' => ['d'],
+  'd' => ['e'],
+  'e' => []
+]
+```
+
+Each key is a string representing a vertex, and the value is a list
+of strings which represent neighbor vertices of the key.
+
+In an undirected graph, edges are not represented redundantly, meaning
+that the edge a-b in the above case is defined by "b" being a member of "a's" list, but
+"a" is not a member of "b's" list. The add_edge method takes care of ordering automatically.
+
+In a directed graph, the order in an edge matters. A construction of a directed graph
+might look like this:
+
+```
+DirectedGraph[
+  'a' => ['b','c'],
+  'b' => ['a'],
+  'c' => ['d'],
+  'd' => []
+]
+```
+
+Graphs can also be built by individually adding edges and vertices.
+
+```
+graph = UndirectedGraph.new
+graph.add_vertex('a')
+graph.add_vertex('b')
+graph.add_edge('a','b')
+```
+
+## Testing
+
+To run the test suite simply execute:
+
+```
+rspec
+```
+
+## Future Work
+
+- More algorithms
+- Make the Graph constructor more "safe"
+- Support for flow networks
+
+## Credits
+
+All code (c) Evan Hemsley 2014
+
+Special thanks to Mitchell Gerrard for inpiring this project.

data/lib/graphunk/directed_graph.rb

@@ -0,0 +1,107 @@
+class DirectedGraph < Graph
+  def add_edge(first_vertex, second_vertex)
+    if edge_exists?(first_vertex, second_vertex)
+      raise ArgumentError, "This edge already exists"
+    elsif vertex_exists?(first_vertex) && vertex_exists?(second_vertex)
+      self[first_vertex] << second_vertex
+    else
+      raise ArgumentError, "One of the vertices referenced does not exist in the graph"
+    end
+  end
+
+  def remove_edge(first_vertex, second_vertex)
+    if edge_exists?(first_vertex, second_vertex)
+      self[first_vertex].delete(second_vertex)
+    else
+      raise ArgumentError, "That edge does not exist in the graph"
+    end
+  end
+
+  def neighbors_of_vertex(name)
+    if vertex_exists?(name)
+      self[name]
+    else
+      raise ArgumentError, "That vertex does not exist in the graph"
+    end
+  end
+
+  def edge_exists?(first_vertex, second_vertex)
+    edges.include?([first_vertex, second_vertex])
+  end
+
+  def transpose
+    graph = DirectedGraph.new
+    vertices.each do |vertex|
+      graph.add_vertex(vertex)
+    end
+    edges.each do |edge|
+      graph.add_edge(edge.last, edge.first)
+    end
+    graph
+  end
+
+  def transpose!
+    reversed_edges = []
+    edges.each do |edge|
+      remove_edge(edge.first, edge.last)
+      reversed_edges << [edge.last, edge.first]
+    end
+    reversed_edges.each do |edge|
+      add_edge(edge.first, edge.last)
+    end
+  end
+
+  def reachable_by_two_path(start)
+    if vertex_exists?(start)
+      reached_vertices = self[start]
+      reached_vertices.each do |vertex|
+        reached_vertices += self[vertex]
+      end
+      reached_vertices.uniq
+    else
+      raise ArgumentError, "That vertex does not exist in the graph"
+    end
+  end
+
+  def square
+    graph = self.clone
+
+    vertices.each do |vertex|
+      (reachable_by_two_path(vertex) - [vertex]).each do |reachable|
+        graph.add_edge(vertex, reachable) unless edge_exists?(vertex, reachable)
+      end
+    end
+
+    graph
+  end
+
+  def dfs
+    discovered = []
+    time = 0
+    output = {}
+    vertices.each { |vertex| output[vertex] = {} }
+
+    dfs_helper = lambda do |u| #only u can do u, so do it!
+      discovered << u
+      time += 1
+      output[u][:start] = time
+
+      neighbors_of_vertex(u).each do |neighbor|
+        dfs_helper.call neighbor unless discovered.include?(neighbor)
+      end
+
+      time += 1
+      output[u][:finish] = time
+    end
+
+    vertices.each do |vertex|
+      dfs_helper.call vertex unless discovered.include?(vertex)
+    end
+
+    output
+  end
+
+  def topological_sort
+    dfs.sort_by { |vertex, times| times[:finish] }.map(&:first).reverse
+  end
+end

data/lib/{graph.rb → graphunk/graph.rb}

@@ -24,8 +24,8 @@ class Graph < Hash
 
   def remove_vertex(name)
     if vertex_exists?(name)
-      self.each_pair do |key, value|
-        self[key].delete(name) if value.include?(name)
+      edges.each do |edge|
+        remove_edge(edge.first, edge.last) if edge.include?(name)
       end
       self.delete(name)
     else
@@ -33,6 +33,16 @@ class Graph < Hash
     end
   end
 
+  def neighbors_of_vertex(name)
+    if vertex_exists?(name)
+      edges.select { |edge| edge.include? name }.map do |edge|
+        edge.first == name ? edge.last : edge.first
+      end
+    else
+      raise ArgumentError, "That vertex does not exist in the graph"
+    end
+  end
+
   def edges_on_vertex(name)
     if vertex_exists?(name)
       edges.select { |edge| edge.include?(name) }
@@ -41,7 +51,17 @@ class Graph < Hash
     end
   end
 
+  def edge_exists?(first_vertex, second_vertex)
+    edges.include?(order_vertices(first_vertex, second_vertex))
+  end
+
   def vertex_exists?(name)
     vertices.include?(name)
   end
+
+  private
+
+  def order_vertices(v, u)
+    [v, u].sort
+  end
 end

data/lib/{undirected_graph.rb → graphunk/undirected_graph.rb}

@@ -1,4 +1,3 @@
-require 'graph'
 require 'set'
 
 class UndirectedGraph < Graph
@@ -22,24 +21,6 @@ class UndirectedGraph < Graph
     end
   end
 
-  def neighbors_of_vertex(name)
-    if vertex_exists?(name)
-      edges.select { |edge| edge.include? name }.map do |edge|
-        if edge.first == name
-          edge.last
-        else
-          edge.first
-        end
-      end
-    else
-      raise ArgumentError, "That vertex does not exist in the graph"
-    end
-  end
-
-  def edge_exists?(first_vertex, second_vertex)
-    edges.include?(order_vertices(first_vertex, second_vertex))
-  end
-
   def lexicographic_bfs
     sets = [vertices]
     output_vertices = []
@@ -136,10 +117,4 @@ class UndirectedGraph < Graph
 
     true
   end
-
-  private
-
-  def order_vertices(first_vertex, second_vertex)
-    [first_vertex, second_vertex].sort
-  end
 end

data/lib/graphunk/weighted_graph.rb

@@ -0,0 +1,10 @@
+#this class should not be invoked directly
+class WeightedGraph < Graph
+
+  attr_accessor :weights
+
+  def initialize
+    super
+    @weights = {}
+  end
+end

data/lib/graphunk/weighted_undirected_graph.rb

@@ -0,0 +1,59 @@
+class WeightedUndirectedGraph < WeightedGraph
+
+  def add_edge(v, u, w)
+    if edge_exists?(v, u)
+      raise ArgumentError, "This edge already exists"
+    elsif vertex_exists?(v) && vertex_exists?(u)
+      ordered_vertices = order_vertices(v, u)
+      self[ordered_vertices.first] << ordered_vertices.last
+      weights[ordered_vertices] = w
+    else
+      raise ArgumentError, "One of the vertices referenced does not exist in the graph"
+    end
+  end
+
+  def remove_edge(v, u)
+    if edge_exists?(v, u)
+      ordered_vertices = order_vertices(v, u)
+      self[ordered_vertices.first].delete(ordered_vertices.last)
+      remove_weight(v, u)
+    else
+      raise ArgumentError, "That edge does not exist in the graph"
+    end
+  end
+
+  def adjust_weight(v, u, w)
+    if edge_exists?(v, u)
+      weights[[v,u]] = w
+    else
+      raise ArgumentError, "That edge does not exist in the graph"
+    end
+  end
+
+  # Prim's Algorithm
+  def minimum_spanning_tree
+    forest = WeightedUndirectedGraph.new
+    forest.add_vertex(vertices.first)
+    until forest.vertices.sort == vertices.sort
+      minimum_edge = edges_to_examine(forest.vertices).min_by { |edge| weights[edge] }
+      vertex_to_add = forest.vertices.include?(minimum_edge.first) ? minimum_edge.last : minimum_edge.first
+      forest.add_vertex(vertex_to_add)
+      forest.add_edge(minimum_edge.first, minimum_edge.last, weights[minimum_edge])
+    end
+    forest
+  end
+
+  private
+
+  def edges_to_examine(vertices)
+    [].tap do |examinable|
+      edges.each do |edge|
+        examinable << edge if (edge & vertices).count == 1
+      end
+    end
+  end
+
+  def remove_weight(v, u)
+    weights.delete(order_vertices(v, u))
+  end
+end

data/lib/graphunk.rb

@@ -1,2 +1,5 @@
-require 'undirected_graph'
-require 'directed_graph'
+require 'graphunk/graph'
+require 'graphunk/undirected_graph'
+require 'graphunk/directed_graph'
+require 'graphunk/weighted_graph'
+require 'graphunk/weighted_undirected_graph'

data/license.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) [2014] [Evan Hemsley]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphunk
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Evan Hemsley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-27 00:00:00.000000000 Z
+date: 2014-03-04 00:00:00.000000000 Z
 dependencies: []
 description: This gem defines graph classes which are useful in various mathematical
   applications.
@@ -17,10 +17,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/directed_graph.rb
-- lib/graph.rb
+- README.md
 - lib/graphunk.rb
-- lib/undirected_graph.rb
+- lib/graphunk/directed_graph.rb
+- lib/graphunk/graph.rb
+- lib/graphunk/undirected_graph.rb
+- lib/graphunk/weighted_graph.rb
+- lib/graphunk/weighted_undirected_graph.rb
+- license.md
 homepage: https://github.com/ehemsley/graphunk
 licenses:
 - MIT

data/lib/directed_graph.rb

@@ -1,32 +0,0 @@
-require 'graph'
-class DirectedGraph < Graph
-  def add_edge(first_vertex, second_vertex)
-    if edge_exists?(first_vertex, second_vertex)
-      raise ArgumentError, "This edge already exists"
-    elsif vertex_exists?(first_vertex) && vertex_exists?(second_vertex)
-      self[first_vertex] << second_vertex
-    else
-      raise ArgumentError, "One of the vertices referenced does not exist in the graph"
-    end
-  end
-
-  def remove_edge(first_vertex, second_vertex)
-    if edge_exists?(first_vertex, second_vertex)
-      self[first_vertex].delete(second_vertex)
-    else
-      raise ArgumentError, "That edge does not exist in the graph"
-    end
-  end
-
-  def neighbors_of_vertex(name)
-    if vertex_exists?(name)
-      self[name]
-    else
-      raise ArgumentError, "That vertex does not exist in the graph"
-    end
-  end
-
-  def edge_exists?(first_vertex, second_vertex)
-    edges.include?([first_vertex, second_vertex])
-  end
-end