graphunk 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4575d6b7451a1081528ebc8c930b54bf69f115f3
-  data.tar.gz: 28a716ec22511dc7c9ec3618c0c57583dc912231
+  metadata.gz: cc9f2d167dfb88b6c0b630bb57e537af41f1551a
+  data.tar.gz: 515300ca5d54dda0d0ba4c61c32dcd568c569f5f
 SHA512:
-  metadata.gz: 653e5ae559782293971fc577d837de76c871fc05cefc915f538c83fe36dc36dab32154fbfadb0682a098c0285109ed6e0d19a3801a4884fc62be6592294cc6c1
-  data.tar.gz: ccbc2d905bc14ba9ce85612c7b50404423f0da3a09cfa02ed1c2af01f004cd8e689e2517f27de5b05bfd65617fcaaa3929f249eaaae64dbec4b6244f7d673cd2
+  metadata.gz: 811bb6a91750487945b8b4098061c79f5a5038787d8306aefe1a97ea208b316710b6fe5b327a06e07579fbc4a24dd08135f4ba3cc7459075ce0d6ee47ee44319
+  data.tar.gz: 7e83dbe57d445d2729f0a68a3999c4ce85ad457102f4dac6d3f61d6f0c7ff56b2163188fe4264ae8bb14ecd6e1799edc1090498aaa7eedfdda7eb0f81e39e015

data/README.md

@@ -9,7 +9,7 @@ Graphunk defines simple and fully-tested graph classes in Ruby which you can use
 Graphs are internally represented as a hash, so you can define a graph similarly to how you would define a Hash:
 
 ```
-UndirectedGraph.new({
+Graphunk::UndirectedGraph.new({
   'a' => ['b','c'],
   'b' => ['c', 'd', 'e'],
   'c' => ['d'],
@@ -29,7 +29,7 @@ In a directed graph, the order in an edge matters. A construction of a directed
 might look like this:
 
 ```
-DirectedGraph.new({
+Graphunk::DirectedGraph.new({
   'a' => ['b','c'],
   'b' => ['a'],
   'c' => ['d'],
@@ -40,7 +40,7 @@ DirectedGraph.new({
 Graphs can also be built by individually adding edges and vertices.
 
 ```
-graph = UndirectedGraph.new
+graph = Graphunk::UndirectedGraph.new
 graph.add_vertex('a')
 graph.add_vertex('b')
 graph.add_edge('a','b')
@@ -53,7 +53,7 @@ Weighted graphs have an additional property: each edge must specify a numerical
 To construct a weighted graph, you must pass in the vertex and edge information as well as the weights:
 
 ```
-WeightedUndirectedGraph.new({
+Graphunk::WeightedUndirectedGraph.new({
   'a' => ['b','c'],
   'b' => ['c', 'd', 'e'],
   'c' => ['d'],
@@ -73,13 +73,15 @@ WeightedUndirectedGraph.new({
 
 You can also build them by adding vertices and edges.
 ```
-  graph = WeightedUndirectedGraph.new
+  graph = Graphunk::WeightedUndirectedGraph.new
   graph.add_vertex('a')
   graph.add_vertex('b')
   graph.add_edge('a','b',3)
 ```
 Now the edge 'a-b' will have a weight of 3.
 
+WeightedDirectedGraph behaves similarly.
+
 ## Testing
 
 To run the test suite simply execute:
@@ -98,4 +100,4 @@ rspec
 
 All code (c) Evan Hemsley 2014
 
-Special thanks to Mitchell Gerrard for inpiring this project.
+Special thanks to Mitchell Gerrard for inspiring this project.

data/lib/graphunk/directed_graph.rb

@@ -1,107 +1,109 @@
-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)
-      @representation[first_vertex] << second_vertex
-    else
-      raise ArgumentError, "One of the vertices referenced does not exist in the graph"
+module Graphunk
+  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)
+        @representation[first_vertex] << second_vertex
+      else
+        raise ArgumentError, "One of the vertices referenced does not exist in the graph"
+      end
     end
-  end
 
-  def remove_edge(first_vertex, second_vertex)
-    if edge_exists?(first_vertex, second_vertex)
-      @representation[first_vertex].delete(second_vertex)
-    else
-      raise ArgumentError, "That edge does not exist in the graph"
+    def remove_edge(first_vertex, second_vertex)
+      if edge_exists?(first_vertex, second_vertex)
+        @representation[first_vertex].delete(second_vertex)
+      else
+        raise ArgumentError, "That edge does not exist in the graph"
+      end
     end
-  end
 
-  def neighbors_of_vertex(name)
-    if vertex_exists?(name)
-      @representation[name]
-    else
-      raise ArgumentError, "That vertex does not exist in the graph"
+    def neighbors_of_vertex(name)
+      if vertex_exists?(name)
+        @representation[name]
+      else
+        raise ArgumentError, "That vertex does not exist in the graph"
+      end
     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)
+    def edge_exists?(first_vertex, second_vertex)
+      edges.include?([first_vertex, second_vertex])
     end
-    graph
-  end
 
-  def transpose!
-    reversed_edges = []
-    edges.each do |edge|
-      remove_edge(edge.first, edge.last)
-      reversed_edges << [edge.last, edge.first]
+    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
-    reversed_edges.each do |edge|
-      add_edge(edge.first, edge.last)
+
+    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
-  end
 
-  def reachable_by_two_path(start)
-    if vertex_exists?(start)
-      reached_vertices = @representation[start]
-      reached_vertices.each do |vertex|
-        reached_vertices += @representation[vertex]
+    def reachable_by_two_path(start)
+      if vertex_exists?(start)
+        reached_vertices = @representation[start]
+        reached_vertices.each do |vertex|
+          reached_vertices += @representation[vertex]
+        end
+        reached_vertices.uniq
+      else
+        raise ArgumentError, "That vertex does not exist in the graph"
       end
-      reached_vertices.uniq
-    else
-      raise ArgumentError, "That vertex does not exist in the graph"
     end
-  end
 
-  def square
-    graph = self.clone
+    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)
+      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
 
-    graph
-  end
+    def dfs
+      discovered = []
+      time = 0
+      output = {}
+      vertices.each { |vertex| output[vertex] = {} }
 
-  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
 
-    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
 
-      neighbors_of_vertex(u).each do |neighbor|
-        dfs_helper.call neighbor unless discovered.include?(neighbor)
+        time += 1
+        output[u][:finish] = time
       end
 
-      time += 1
-      output[u][:finish] = time
-    end
+      vertices.each do |vertex|
+        dfs_helper.call vertex unless discovered.include?(vertex)
+      end
 
-    vertices.each do |vertex|
-      dfs_helper.call vertex unless discovered.include?(vertex)
+      output
     end
 
-    output
-  end
-
-  def topological_sort
-    dfs.sort_by { |vertex, times| times[:finish] }.map(&:first).reverse
+    def topological_sort
+      dfs.sort_by { |vertex, times| times[:finish] }.map(&:first).reverse
+    end
   end
 end

data/lib/graphunk/graph.rb

@@ -1,79 +1,81 @@
 # this class should not be invoked directly
-class Graph
-  def initialize(hash = {})
-    @representation = hash
-  end
+module Graphunk
+  class Graph
+    def initialize(hash = {})
+      @representation = hash
+    end
 
-  def vertices
-    @representation.keys
-  end
+    def vertices
+      @representation.keys
+    end
 
-  def edges
-    [].tap do |edge_constructor|
-      vertices.each do |vertex|
-        @representation[vertex].each do |neighbor|
-          edge_constructor << [vertex, neighbor]
+    def edges
+      [].tap do |edge_constructor|
+        vertices.each do |vertex|
+          @representation[vertex].each do |neighbor|
+            edge_constructor << [vertex, neighbor]
+          end
         end
       end
     end
-  end
 
-  def add_vertex(name)
-    unless vertex_exists?(name)
-      @representation[name] = []
-    else
-      raise ArgumentError, "Vertex already exists"
+    def add_vertex(name)
+      unless vertex_exists?(name)
+        @representation[name] = []
+      else
+        raise ArgumentError, "Vertex already exists"
+      end
     end
-  end
 
-  def add_vertices(*names)
-    if (names & vertices).count == 0
-      names.each { |name| add_vertex(name) }
-    else
-      raise ArgumentError, "One or more of the given vertices already exists"
+    def add_vertices(*names)
+      if (names & vertices).count == 0
+        names.each { |name| add_vertex(name) }
+      else
+        raise ArgumentError, "One or more of the given vertices already exists"
+      end
     end
-  end
 
-  def remove_vertex(name)
-    if vertex_exists?(name)
-      edges.each do |edge|
-        remove_edge(edge.first, edge.last) if edge.include?(name)
+    def remove_vertex(name)
+      if vertex_exists?(name)
+        edges.each do |edge|
+          remove_edge(edge.first, edge.last) if edge.include?(name)
+        end
+        @representation.delete(name)
+      else
+        raise ArgumentError, "That vertex does not exist in the graph"
       end
-      @representation.delete(name)
-    else
-      raise ArgumentError, "That vertex does not exist in the graph"
     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
+    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
-    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) }
-    else
-      raise ArgumentError, "That vertex does not exist in the graph"
+    def edges_on_vertex(name)
+      if vertex_exists?(name)
+        edges.select { |edge| edge.include?(name) }
+      else
+        raise ArgumentError, "That vertex does not exist in the graph"
+      end
     end
-  end
 
-  def edge_exists?(first_vertex, second_vertex)
-    edges.include?(order_vertices(first_vertex, second_vertex))
-  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
+    def vertex_exists?(name)
+      vertices.include?(name)
+    end
 
-  private
+    private
 
-  def order_vertices(v, u)
-    [v, u].sort
+    def order_vertices(v, u)
+      [v, u].sort
+    end
   end
 end

data/lib/graphunk/undirected_graph.rb

@@ -1,120 +1,120 @@
-require 'set'
-
-class UndirectedGraph < 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)
-      ordered_vertices = order_vertices(first_vertex, second_vertex)
-      @representation[ordered_vertices.first] << ordered_vertices.last
-    else
-      raise ArgumentError, "One of the vertices referenced does not exist in the graph"
+module Graphunk
+  class UndirectedGraph < 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)
+        ordered_vertices = order_vertices(first_vertex, second_vertex)
+        @representation[ordered_vertices.first] << ordered_vertices.last
+      else
+        raise ArgumentError, "One of the vertices referenced does not exist in the graph"
+      end
     end
-  end
 
-  def remove_edge(first_vertex, second_vertex)
-    if edge_exists?(first_vertex, second_vertex)
-      ordered_vertices = order_vertices(first_vertex, second_vertex)
-      @representation[ordered_vertices.first].delete(ordered_vertices.last)
-    else
-      raise ArgumentError, "That edge does not exist in the graph"
+    def remove_edge(first_vertex, second_vertex)
+      if edge_exists?(first_vertex, second_vertex)
+        ordered_vertices = order_vertices(first_vertex, second_vertex)
+        @representation[ordered_vertices.first].delete(ordered_vertices.last)
+      else
+        raise ArgumentError, "That edge does not exist in the graph"
+      end
     end
-  end
 
-  def lexicographic_bfs
-    sets = [vertices]
-    output_vertices = []
+    def lexicographic_bfs
+      sets = [vertices]
+      output_vertices = []
 
-    until sets.empty?
-      v = sets.first.delete_at(0)
-      sets.delete_at(0) if sets.first.empty?
-      output_vertices << v
-      replaced = []
-      neighbors_of_vertex(v).each do |neighbor|
-        s = sets.select{ |set| set.include?(neighbor) }.first
-        if s
-          if replaced.include?(s)
-            t = sets[sets.find_index(s)-1]
-          else
-            t = []
-            sets.insert(sets.find_index(s), t)
-            replaced << s
+      until sets.empty?
+        v = sets.first.delete_at(0)
+        sets.delete_at(0) if sets.first.empty?
+        output_vertices << v
+        replaced = []
+        neighbors_of_vertex(v).each do |neighbor|
+          s = sets.select{ |set| set.include?(neighbor) }.first
+          if s
+            if replaced.include?(s)
+              t = sets[sets.find_index(s)-1]
+            else
+              t = []
+              sets.insert(sets.find_index(s), t)
+              replaced << s
+            end
+            s.delete(neighbor)
+            t << neighbor
+            sets.delete(s) if s.empty?
           end
-          s.delete(neighbor)
-          t << neighbor
-          sets.delete(s) if s.empty?
         end
       end
-    end
 
-    output_vertices
-  end
+      output_vertices
+    end
 
-  def clique?(vertex_list)
-    clique = true
-    vertex_list.each do |vertex|
-      unless (neighbors_of_vertex(vertex) & vertex_list).sort == (vertex_list - [vertex]).sort
-        clique = false
-        break
+    def clique?(vertex_list)
+      clique = true
+      vertex_list.each do |vertex|
+        unless (neighbors_of_vertex(vertex) & vertex_list).sort == (vertex_list - [vertex]).sort
+          clique = false
+          break
+        end
       end
+      clique
     end
-    clique
-  end
 
-  def chordal?
-    chordal = true
-    (lexicographic_ordering = lexicographic_bfs.reverse).each_with_index do |v, i|
-      successors_of_v = lexicographic_ordering[i, lexicographic_ordering.size]
-      unless clique?([v] | (neighbors_of_vertex(v) & successors_of_v))
-        chordal = false
-        break
+    def chordal?
+      chordal = true
+      (lexicographic_ordering = lexicographic_bfs.reverse).each_with_index do |v, i|
+        successors_of_v = lexicographic_ordering[i, lexicographic_ordering.size]
+        unless clique?([v] | (neighbors_of_vertex(v) & successors_of_v))
+          chordal = false
+          break
+        end
       end
+      chordal
     end
-    chordal
-  end
-  alias_method :triangulated?, :chordal?
-
-  def complete?
-    n = vertices.count
-    edges.count == (n * (n-1) / 2)
-  end
+    alias_method :triangulated?, :chordal?
 
-  def bipartite?
-    colors = Hash.new
-    d = Hash.new
-    partition = Hash.new
-    vertices.each do |vertex|
-      colors[vertex] = "white"
-      d[vertex] = Float::INFINITY
-      partition[vertex] = 0
+    def complete?
+      n = vertices.count
+      edges.count == (n * (n-1) / 2)
     end
 
-    start = vertices.first
-    colors[start] = "gray"
-    partition[start] = 1
-    d[start] = 0
+    def bipartite?
+      colors = Hash.new
+      d = Hash.new
+      partition = Hash.new
+      vertices.each do |vertex|
+        colors[vertex] = "white"
+        d[vertex] = Float::INFINITY
+        partition[vertex] = 0
+      end
+
+      start = vertices.first
+      colors[start] = "gray"
+      partition[start] = 1
+      d[start] = 0
 
-    stack = []
-    stack.push(start)
+      stack = []
+      stack.push(start)
 
-    until stack.empty?
-      vertex = stack.pop
-      neighbors_of_vertex(vertex).each do |neighbor|
-        if partition[neighbor] == partition[vertex]
-          return false
-        else
-          if colors[neighbor] == "white"
-            colors[neighbor] == "gray"
-            d[neighbor] = d[vertex] + 1
-            partition[neighbor] = 3 - partition[vertex]
-            stack.push(neighbor)
+      until stack.empty?
+        vertex = stack.pop
+        neighbors_of_vertex(vertex).each do |neighbor|
+          if partition[neighbor] == partition[vertex]
+            return false
+          else
+            if colors[neighbor] == "white"
+              colors[neighbor] == "gray"
+              d[neighbor] = d[vertex] + 1
+              partition[neighbor] = 3 - partition[vertex]
+              stack.push(neighbor)
+            end
           end
         end
+        stack.pop
+        colors[vertex] = "black"
       end
-      stack.pop
-      colors[vertex] = "black"
-    end
 
-    true
+      true
+    end
   end
 end

data/lib/graphunk/weighted_directed_graph.rb

@@ -0,0 +1,116 @@
+module Graphunk
+  class WeightedDirectedGraph < 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)
+        @representation[v] << u
+        @weights[[v,u]] = 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)
+        @representation[v].delete(u)
+        @weights.delete([v,u])
+      else
+        raise ArgumentError, "That edge does not exist in the graph"
+      end
+    end
+
+    def edge_weight(v, u)
+      if edge_exists?(v,u)
+        @weights[[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
+
+    def neighbors_of_vertex(v)
+      if vertex_exists?(v)
+        @representation[v]
+      else
+        raise ArgumentError, "That vertex does not exist in the graph"
+      end
+    end
+
+    def shortest_path_distance(v, u)
+      if vertex_exists?(u)
+        single_source_shortest_path_distances(v)[u]
+      else
+        raise ArgumentError, "A specified vertex does not exist in the graph"
+      end
+    end
+
+    def shortest_path(v, u)
+      if vertex_exists?(u)
+        [].tap do |s|
+          previous = single_source_shortest_path_previous(v)
+          while previous[u]
+            s.insert(0, u)
+            u = previous[u]
+          end
+          s.insert(0, v)
+        end
+      else
+        raise ArgumentError, "A specified vertex does not exist in the graph"
+      end
+    end
+
+    private
+
+    # Dijsktra's Algorithm
+    def single_source_shortest_path(source)
+      raise ArgumentError, "A specified vertex does not exist in the graph" unless vertex_exists?(source)
+
+      distance = {}
+      previous = {}
+      vertices.each do |vertex|
+        distance[vertex] = Float::INFINITY
+        previous[vertex] = nil
+      end
+
+      distance[source] = 0
+      q = vertices
+
+      until q.empty?
+        u = q.delete(q.min_by { |vertex| distance[vertex] })
+        break if distance[u] == Float::INFINITY
+
+        neighbors_of_vertex(u).each do |v|
+          alt = distance[u] + edge_weight(u, v)
+          if alt < distance[v]
+            distance[v] = alt
+            previous[v] = u
+          end
+        end
+      end
+
+      {distance: distance, previous: previous}
+    end
+
+    def single_source_shortest_path_distances(source)
+      single_source_shortest_path(source)[:distance]
+    end
+
+    def single_source_shortest_path_previous(source)
+      single_source_shortest_path(source)[:previous]
+    end
+
+    def edge_exists?(v, u)
+      edges.include?([v,u])
+    end
+
+  end
+end

data/lib/graphunk/weighted_graph.rb

@@ -1,10 +1,13 @@
 #this class should not be invoked directly
-class WeightedGraph < Graph
+module Graphunk
+  class WeightedGraph < Graph
 
-  attr_reader :weights
+    attr_reader :weights
+
+    def initialize(hash = {}, weights = {})
+      @representation = hash
+      @weights = weights
+    end
 
-  def initialize(hash = {}, weights = {})
-    @representation = hash
-    @weights = weights
   end
 end

data/lib/graphunk/weighted_undirected_graph.rb

@@ -1,63 +1,69 @@
-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)
-      @representation[ordered_vertices.first] << ordered_vertices.last
-      @weights[ordered_vertices] = w
-    else
-      raise ArgumentError, "One of the vertices referenced does not exist in the graph"
+module Graphunk
+  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)
+        @representation[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
-  end
 
-  def remove_edge(v, u)
-    if edge_exists?(v, u)
-      ordered_vertices = order_vertices(v, u)
-      @representation[ordered_vertices.first].delete(ordered_vertices.last)
-      remove_weight(v, u)
-    else
-      raise ArgumentError, "That edge does not exist in the graph"
+    def remove_edge(v, u)
+      if edge_exists?(v, u)
+        ordered_vertices = order_vertices(v, u)
+        @representation[ordered_vertices.first].delete(ordered_vertices.last)
+        remove_weight(v, u)
+      else
+        raise ArgumentError, "That edge does not exist in the graph"
+      end
     end
-  end
 
-  def edge_weight(edge)
-    @weights[edge]
-  end
+    def edge_weight(v, u)
+      if edge_exists?(v,u)
+        @weights[order_vertices(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"
+    def adjust_weight(v, u, w)
+      if edge_exists?(v, u)
+        @weights[order_vertices(v,u)] = w
+      else
+        raise ArgumentError, "That edge does not exist in the graph"
+      end
     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])
+    # 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
-    forest
-  end
 
-  private
+    private
 
-  def edges_to_examine(vertices)
-    [].tap do |examinable|
-      edges.each do |edge|
-        examinable << edge if (edge & vertices).count == 1
+    def edges_to_examine(vertices)
+      [].tap do |examinable|
+        edges.each do |edge|
+          examinable << edge if (edge & vertices).count == 1
+        end
       end
     end
-  end
 
-  def remove_weight(v, u)
-    @weights.delete(order_vertices(v, u))
+    def remove_weight(v, u)
+      @weights.delete(order_vertices(v, u))
+    end
   end
 end

data/lib/graphunk.rb

@@ -3,3 +3,4 @@ require 'graphunk/undirected_graph'
 require 'graphunk/directed_graph'
 require 'graphunk/weighted_graph'
 require 'graphunk/weighted_undirected_graph'
+require 'graphunk/weighted_directed_graph'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphunk
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Evan Hemsley
@@ -62,6 +62,7 @@ files:
 - lib/graphunk/directed_graph.rb
 - lib/graphunk/graph.rb
 - lib/graphunk/undirected_graph.rb
+- lib/graphunk/weighted_directed_graph.rb
 - lib/graphunk/weighted_graph.rb
 - lib/graphunk/weighted_undirected_graph.rb
 - license.md