rgl 0.5.1 → 0.5.7

data/examples/examples.rb

@@ -77,7 +77,7 @@ def bfs_example(g = cycle(5), start = g.detect { |x| true })
 end
 
 # Would like to have GraphXML here
-def graph_from_dotfile (file)
+def graph_from_dotfile(file)
   g = RGL::AdjacencyGraph.new
   pattern = /\s*([^\"]+)[\"\s]*--[\"\s]*([^\"\[\;]+)/ # ugly but works
   IO.foreach(file) { |line|
@@ -94,21 +94,23 @@ def graph_from_dotfile (file)
   g
 end
 
-# ruby -Ilib -r examples/examples.rb -rrgl/dot -e'bfs_example(module_graph,RGL::AdjacencyGraph).dotty'
-
+# ruby -Ilib examples/examples.rb
 if $0 == __FILE__
   require 'rgl/dot'
 
   dg = RGL::DirectedAdjacencyGraph[1,2, 2,3, 2,4, 4,5, 6,4, 1,6]
-  dg.dotty
   dg.write_to_graphic_file
-  bfs_example(dg, 1).dotty
-  bfs_example(graph_from_dotfile('dot/unix.dot'), 'Interdata').dotty({ 'label' => 'Interdata Nachfolger', 'fontsize' => 12 })
 
+  # BFS tree from 1 of dg:
+  bfs_example(dg, 1).write_to_graphic_file('png', 'bfs_example')
+
+  # Unix history as a graph:
+  g = bfs_example(graph_from_dotfile('examples/unix.dot'), 'Interdata')
+  g.write_to_graphic_file('png', 'unix', { 'label' => 'Interdata Nachfolger', 'fontsize' => 12 })
+
+  # Modules included by AdjacencyGraph:
   g = module_graph
   tree = bfs_example(module_graph, RGL::AdjacencyGraph)
   g = g.vertices_filtered_by { |v| tree.has_vertex? v }
-  g.write_to_graphic_file
-  g.dotty
+  g.write_to_graphic_file('png', 'module_graph')
 end
-

data/examples/unix.dot

@@ -0,0 +1,53 @@
+/* courtesy Ian Darwin and Geoff Collyer, Softquad Inc. */
+digraph unix {
+size="6,6";
+	"5th Edition" -> "6th Edition";
+	"5th Edition" -> "PWB 1.0";
+	"6th Edition" -> "LSX";
+	"6th Edition" -> "1 BSD";
+	"6th Edition" -> "Mini Unix";
+	"6th Edition" -> "Wollongong";
+	"6th Edition" -> "Interdata";
+	"Interdata" -> "Unix/TS 3.0";
+	"Interdata" -> "PWB 2.0";
+	"Interdata" -> "7th Edition";
+	"7th Edition" -> "8th Edition";
+	"7th Edition" -> "32V";
+	"7th Edition" -> "V7M";
+	"7th Edition" -> "Ultrix-11";
+	"7th Edition" -> "Xenix";
+	"7th Edition" -> "UniPlus+";
+	"V7M" -> "Ultrix-11";
+	"8th Edition" -> "9th Edition";
+	"1 BSD" -> "2 BSD";
+	"2 BSD" -> "2.8 BSD";
+	"2.8 BSD" -> "Ultrix-11";
+	"2.8 BSD" -> "2.9 BSD";
+	"32V" -> "3 BSD";
+	"3 BSD" -> "4 BSD";
+	"4 BSD" -> "4.1 BSD";
+	"4.1 BSD" -> "4.2 BSD";
+	"4.1 BSD" -> "2.8 BSD";
+	"4.1 BSD" -> "8th Edition";
+	"4.2 BSD" -> "4.3 BSD";
+	"4.2 BSD" -> "Ultrix-32";
+	"PWB 1.0" -> "PWB 1.2";
+	"PWB 1.0" -> "USG 1.0";
+	"PWB 1.2" -> "PWB 2.0";
+	"USG 1.0" -> "CB Unix 1";
+	"USG 1.0" -> "USG 2.0";
+	"CB Unix 1" -> "CB Unix 2";
+	"CB Unix 2" -> "CB Unix 3";
+	"CB Unix 3" -> "Unix/TS++";
+	"CB Unix 3" -> "PDP-11 Sys V";
+	"USG 2.0" -> "USG 3.0";
+	"USG 3.0" -> "Unix/TS 3.0";
+	"PWB 2.0" -> "Unix/TS 3.0";
+	"Unix/TS 1.0" -> "Unix/TS 3.0";
+	"Unix/TS 3.0" -> "TS 4.0";
+	"Unix/TS++" -> "TS 4.0";
+	"CB Unix 3" -> "TS 4.0";
+	"TS 4.0" -> "System V.0";
+	"System V.0" -> "System V.2";
+	"System V.2" -> "System V.3";
+}

data/lib/rgl/adjacency.rb

@@ -77,7 +77,7 @@ module RGL
     # Complexity is O(1), because the vertices are kept in a Hash containing
     # as values the lists of adjacent vertices of _v_.
     #
-    def has_vertex? (v)
+    def has_vertex?(v)
       @vertices_dict.has_key?(v)
     end
 
@@ -87,7 +87,7 @@ module RGL
     # ---
     # MutableGraph interface.
     #
-    def has_edge? (u, v)
+    def has_edge?(u, v)
       has_vertex?(u) && @vertices_dict[u].include?(v)
     end
 

data/lib/rgl/base.rb

@@ -4,9 +4,7 @@
 # library. The main module is RGL::Graph which defines the abstract behavior of
 # all graphs in the library.
 
-require 'rgl/enumerable_ext'
-
-RGL_VERSION = "0.5.1"
+RGL_VERSION = "0.5.7"
 
 module RGL
   class NotDirectedError < RuntimeError; end
@@ -77,6 +75,9 @@ module RGL
         "(#{source}-#{target})"
       end
 
+      # Since Ruby 2.0 #inspect no longer calls #to_s. So we alias it to to_s (fixes #22)
+      alias inspect to_s
+
       # Returns the array [source,target].
       #
       def to_a

data/lib/rgl/bellman_ford.rb

@@ -2,8 +2,7 @@ require 'rgl/dijkstra_visitor'
 require 'rgl/edge_properties_map'
 require 'rgl/path_builder'
 
-require 'delegate'
-require 'algorithms'
+require 'lazy_priority_queue'
 
 module RGL
 

data/lib/rgl/bipartite.rb

@@ -22,7 +22,7 @@ module RGL
         next if bfs.finished_vertex?(u)
 
         bfs.reset_start(u)
-        bfs.move_forward_until { @found_odd_cycle }
+        bfs.move_forward_until { bfs.found_odd_cycle }
 
         return if bfs.found_odd_cycle
       end
@@ -84,4 +84,4 @@ module RGL
 
   end # class BipartiteBFSIterator
 
-end # module RGL
+end # module RGL

data/lib/rgl/dijkstra.rb

@@ -2,8 +2,7 @@ require 'rgl/dijkstra_visitor'
 require 'rgl/edge_properties_map'
 require 'rgl/path_builder'
 
-require 'delegate'
-require 'algorithms'
+require 'lazy_priority_queue'
 
 module RGL
 
@@ -55,7 +54,7 @@ module RGL
     def init(source)
       @visitor.set_source(source)
 
-      @queue = Queue.new
+      @queue = MinPriorityQueue.new
       @queue.push(source, 0)
     end
 
@@ -82,8 +81,6 @@ module RGL
       new_v_distance = @distance_combinator.call(@visitor.distance_map[u], @edge_weights_map.edge_property(u, v))
 
       if new_v_distance < @visitor.distance_map[v]
-        old_v_distance = @visitor.distance_map[v]
-
         @visitor.distance_map[v] = new_v_distance
         @visitor.parents_map[v]  = u
 
@@ -91,7 +88,7 @@ module RGL
           @visitor.color_map[v] = :GRAY
           @queue.push(v, new_v_distance)
         elsif @visitor.color_map[v] == :GRAY
-          @queue.decrease_key(v, old_v_distance, new_v_distance)
+          @queue.decrease_key(v, new_v_distance)
         end
 
         @visitor.handle_edge_relaxed(u, v)
@@ -104,29 +101,6 @@ module RGL
       edge_weights_map.is_a?(EdgePropertiesMap) ? edge_weights_map : NonNegativeEdgePropertiesMap.new(edge_weights_map, @graph.directed?)
     end
 
-    class Queue < SimpleDelegator # :nodoc:
-
-      def initialize
-        @heap = Containers::Heap.new { |a, b| a.distance < b.distance }
-        super(@heap)
-      end
-
-      def push(vertex, distance)
-        @heap.push(vertex_key(vertex, distance), vertex)
-      end
-
-      def decrease_key(vertex, old_distance, new_distance)
-        @heap.change_key(vertex_key(vertex, old_distance), vertex_key(vertex, new_distance))
-      end
-
-      def vertex_key(vertex, distance)
-        VertexKey.new(vertex, distance)
-      end
-
-      VertexKey = Struct.new(:vertex, :distance)
-
-    end
-
   end # class DijkstraAlgorithm
 
   module Graph

data/lib/rgl/dot.rb

@@ -5,6 +5,9 @@
 # Minimal Dot support, based on Dave Thomas's dot module (included in rdoc).
 # rdot.rb is a modified version which also contains support for undirected
 # graphs.
+#
+# You need to have [GraphViz](http://www.graphviz.org) installed, because the
+# functions in this modul execute the GraphViz executables _dot_ or _dotty_.
 
 require 'rgl/rdot'
 
@@ -17,6 +20,10 @@ module RGL
       v.to_s
     end
 
+    def vertex_id(v)
+      v
+    end
+
     # Return a RGL::DOT::Digraph for directed graphs or a DOT::Graph for an
     # undirected Graph. _params_ can contain any graph property specified in
     # rdot.rb.
@@ -26,21 +33,29 @@ module RGL
       fontsize       = params['fontsize'] ? params['fontsize'] : '8'
       graph          = (directed? ? DOT::Digraph : DOT::Graph).new(params)
       edge_class     = directed? ? DOT::DirectedEdge : DOT::Edge
+      vertex_options = params['vertex'] || {}
+      edge_options   = params['edge'] || {}
 
       each_vertex do |v|
-        graph << DOT::Node.new(
-            'name'     => v.object_id,
-            'fontsize' => fontsize,
-            'label'    => vertex_label(v)
-        )
+        default_vertex_options =  {
+          'name'     => vertex_id(v),
+          'fontsize' => fontsize,
+          'label'    => vertex_label(v)
+        }
+        each_vertex_options = default_vertex_options.merge(vertex_options)
+        vertex_options.each{|option, val| each_vertex_options[option] = val.call(v) if val.is_a?(Proc)}
+        graph << DOT::Node.new(each_vertex_options)
       end
 
       each_edge do |u, v|
-        graph << edge_class.new(
-            'from'     => u.object_id,
-            'to'       => v.object_id,
-            'fontsize' => fontsize
-        )
+        default_edge_options = {
+          'from'     => vertex_id(u),
+          'to'       => vertex_id(v),
+          'fontsize' => fontsize
+        }
+        each_edge_options = default_edge_options.merge(edge_options)
+        edge_options.each{|option, val| each_edge_options[option] = val.call(u, v) if val.is_a?(Proc)}
+        graph << edge_class.new(each_edge_options)
       end
 
       graph
@@ -60,21 +75,25 @@ module RGL
       File.open(dotfile, "w") do |f|
         print_dotted_on(params, f)
       end
-      system("dotty", dotfile)
+      unless system("dotty", dotfile)
+        raise "Error executing dotty. Did you install GraphViz?"
+      end
     end
 
     # Use dot[http://www.graphviz.org] to create a graphical representation of
     # the graph. Returns the filename of the graphics file.
     #
-    def write_to_graphic_file(fmt='png', dotfile="graph")
+    def write_to_graphic_file(fmt='png', dotfile="graph", options={})
       src = dotfile + ".dot"
       dot = dotfile + "." + fmt
 
       File.open(src, 'w') do |f|
-        f << self.to_dot_graph.to_s << "\n"
+        f << self.to_dot_graph(options).to_s << "\n"
       end
 
-      system("dot -T#{fmt} #{src} -o #{dot}")
+      unless system("dot -T#{fmt} #{src} -o #{dot}")
+        raise "Error executing dot. Did you install GraphViz?"
+      end
       dot
     end
 

data/lib/rgl/edmonds_karp.rb

@@ -46,9 +46,9 @@ module RGL
             min_residual_capacity = [min_residual_capacity, @residual_capacity_map[u, v]].min
           end
 
-          augmenting_path.each_cons(2) do |(u, v)|
-            @flow_map[[u, v]] += min_residual_capacity
-            @flow_map[[v, u]] -= min_residual_capacity
+          augmenting_path.each_cons(2) do |(uu, vv)|
+            @flow_map[[uu, vv]] += min_residual_capacity
+            @flow_map[[vv, uu]] -= min_residual_capacity
           end
         end
       end
@@ -133,4 +133,4 @@ module RGL
 
   end # module Graph
 
-end
+end

data/lib/rgl/graph_iterator.rb

@@ -10,6 +10,10 @@ module RGL
   module GraphIterator
     include Stream
     include GraphWrapper
+
+    def length
+      inject(0) { |sum| sum + 1 }
+    end
   end
 
 end # RGL

data/lib/rgl/graphxml.rb

@@ -1,7 +1,7 @@
 # graphxml.rb
 #
 # This file contains minimal support for creating RGL graphs from the GraphML
-# format (see http://www.graphdrawing.org/graphml). The main purpose is to
+# format (see http://graphml.graphdrawing.org/). The main purpose is to
 # have a rich set of example graphs to have some more tests.
 #
 # See the examples directory, which contains a subdirectory _north_ with the
@@ -48,7 +48,7 @@ module RGL
     end # class MutableGraphParser
 
     # Initializes an RGL graph from a subset of the GraphML format given in
-    # +source+ (see http://www.graphdrawing.org/graphml).
+    # +source+ (see http://graphml.graphdrawing.org/).
     #
     def from_graphxml(source)
       listener = MutableGraphParser.new(self)

data/lib/rgl/path.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rgl/traversal'
+
+module RGL
+  module Graph
+    # Checks whether a path exists between _source_ and _target_ vertices
+    # in the graph.
+    #
+    def path?(source, target)
+      return false unless has_vertex?(source)
+
+      bfs_iterator = bfs_iterator(source)
+      bfs_iterator.include?(target)
+    end
+  end
+end

data/lib/rgl/rdot.rb

@@ -328,7 +328,7 @@ module RGL
       # :call-seq:
       #   graph << element -> graph
       #
-      def << (element)
+      def <<(element)
         @elements << element
         self
       end

data/lib/rgl/traversal.rb

@@ -58,9 +58,12 @@ module RGL
     # Reset the iterator to the initial state (i.e. at_beginning? == true).
     #
     def set_to_begin
+      # Reset color_map
+      @color_map = Hash.new(:WHITE)
       color_map[@start_vertex] = :GRAY
-      @waiting = [@start_vertex] # a queue
+      @waiting = [@start_vertex]           # a queue
       handle_tree_edge(nil, @start_vertex) # discovers start vertex
+      self
     end
 
     def basic_forward # :nodoc:
@@ -169,6 +172,10 @@ module RGL
     # it is called on each _finish_vertex_ event. See
     # strongly_connected_components for an example usage.
     #
+    # Note that this traversal does not garantee, that roots are at the top of
+    # each spanning subtree induced by the DFS search on a directed graph (see
+    # also the discussion in issue #20[https://github.com/monora/rgl/issues/20]).
+    #
     def depth_first_search(vis = DFSVisitor.new(self), &b)
       each_vertex do |u|
         unless vis.finished_vertex?(u)

data/test/components_test.rb

@@ -61,7 +61,7 @@ i -> h j e c
 
     assert_equal(4, vis.num_comp)
 
-    res = vis.comp_map.to_a.sort.reduce({}) { |res, a|
+    result = vis.comp_map.to_a.sort.reduce({}) { |res, a|
       if res.key?(a[1])
         res[a[1]] << a[0]
       else
@@ -70,7 +70,7 @@ i -> h j e c
       res
     }
 
-    std_res = res.to_a.map {
+    std_res = result.to_a.map {
         |a|
       [a[1][0], a[1]]
     }.sort

data/test/dijkstra_issue24_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+require 'rgl/dijkstra'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestDijkstraIssue24 < Test::Unit::TestCase
+
+  def setup
+    @graph = RGL::AdjacencyGraph[2,53, 2,3, 3,8, 3,28, 3,39, 29,58, 8,35, 12,39, 10,29, 62,15, 15,32,  32,58, 58,44, 44,53]
+
+  end
+
+  def test_shortest_path_search
+    assert_equal([53, 44, 58, 32, 15, 62], shortest_path(53, 62))
+  end
+
+  def shortest_path(v,w)
+    @graph.dijkstra_shortest_path(Hash.new(1), v, w)
+  end
+
+end