rgl 0.3.1 → 0.4.0

data/ChangeLog

@@ -1,6 +1,80 @@
+2008-08-28 01:36  javanthropus
+
+	* ChangeLog (tags: REL_0_4_0): pre-tag commit
+
+2008-08-28 01:36  javanthropus
+
+	* Rakefile (tags: REL_0_4_0): Update rdoc2rf task to use rsync and
+	  more generic remote path specification
+
+2008-08-27 23:30  javanthropus
+
+	* lib/rgl/base.rb (tags: REL_0_4_0): Preparing for 0.4.0 release
+
+2008-08-26 20:07  javanthropus
+
+	* lib/rgl/dot.rb, lib/rgl/rdot.rb, tests/TestRdot.rb: Move the DOT
+	  module into the RGL module
+
+	  * This eliminates a class conflict with the DOT module from rdoc
+	  when building RGL's documentation * Also remove the superfluous
+	  DOT prefixes from class names in the DOT module
+
+2008-08-24 06:16  javanthropus
+
+	* Rakefile: Remove some comments I accidentally left in while
+	  testing rdoc functionality
+
+2008-08-24 06:03  javanthropus
+
+	* Rakefile, lib/rgl/transitiv_closure.rb, lib/rgl/transitivity.rb,
+	  tests/TestTransitiveClosure.rb, tests/TestTransitivity.rb:
+	  Feature 21641: Added transitive reduction functionality
+
+	  * Updated the gem description to announce this functionality *
+	  Moved the transitive closure functionality into the
+	  transitivity.rb file along with the transitive reduction
+	  funtionality * Modifed the transitiv_closure.rb file to simply
+	  load the transitivity.rb file for backward compatibility * Moved
+	  all transitivity tests into TestTransitivity.rb
+
+2008-08-23 15:45  javanthropus
+
+	* lib/rgl/condensation.rb, lib/rgl/transitiv_closure.rb,
+	  tests/TestTransitiveClosure.rb: Defect 21630: Fixed transitive
+	  closure
+
+	  * The fix is based on the algorithm described in the
+	  documentation for the implementation of transitive closure in
+	  Boost * Along with the fix, performance is improved to O(|V||E|)
+	  * This implementation needs graph condensation, so that function
+	  was added as well * More tests were added to cover more corner
+	  cases
+
+2008-08-23 05:40  javanthropus
+
+	* tests/TestGraph.rb: Update basic graph tests to account for
+	  graphs with edgeless vertices Also clean up some minor formatting
+	  and assertion issues
+
+2008-08-23 05:37  javanthropus
+
+	* lib/rgl/adjacency.rb: Defect 21609: Fix the to_adjacency method
+	  to preserve edgeless vertices
+
+2008-03-18 15:03  javanthropus
+
+	* lib/rgl/rdot.rb, tests/TestRdot.rb: More reliably detect and
+	  handle newlines embedded within IDs and labels
+
+2008-03-08 10:48  monora
+
+	* ChangeLog, lib/rgl/base.rb (utags: REL_0_3_1): Prepare 0.3.1
+	  release
+
 2008-03-04 20:18  monora
 
-	* Rakefile (tags: REL_0_3_0): pre-tag commit
+	* Rakefile (tags: REL_0_3_1, REL_0_3_0): pre-tag commit
 
 2008-03-02 18:16  javanthropus
 

data/Rakefile

@@ -23,6 +23,17 @@ SOURCES = FileList['lib/**/*.rb']
 CLOBBER.include('TAGS', 'coverage')
 RDOC_DIR = './rgl'
 
+# The location for published documents to be copied.
+remote_user = ENV['REMOTE_USER'] || ''
+remote_host = ENV['REMOTE_HOST'] || 'rubyforge.org'
+remote_path = ENV['REMOTE_PATH'] || '/var/www/gforge-projects/rgl'
+remote_path += '/' unless remote_path[-1, 1] == '/'
+REMOTE_RDOC_DIR = remote_path
+REMOTE_RDOC_DIR.insert(
+  0,
+  remote_user + (remote_user.empty? ? '' : '@') + remote_host + ':'
+) unless remote_host.empty?
+
 # The default task is run if rake is given no explicit arguments.
 
 desc "Default Task"
@@ -124,6 +135,8 @@ else
      * Connected Components 
      * Strongly Connected Components 
      * Transitive Closure
+     * Transitive Reduction
+     * Graph Condensation
      * Search cycles (contributed by Shawn Garbett)
     EOF
     
@@ -211,7 +224,9 @@ end
 
 desc "Copy rdoc html to rubyforge"
 task :rdoc2rf => [:rdoc, :rcov, :changelog] do
-  mv 'coverage', RDOC_DIR
-  sh "scp -r #{RDOC_DIR} monora@rubyforge.org:/var/www/gforge-projects/rgl"
-  sh "scp examples/*.jpg monora@rubyforge.org:/var/www/gforge-projects/rgl/examples"
+  cp_r 'coverage', RDOC_DIR
+  examples = File.join(RDOC_DIR, 'examples')
+  mkdir_p examples
+  cp Dir.glob('examples/*.jpg'), examples
+  sh "rsync -r --delete \"#{RDOC_DIR}\" \"#{REMOTE_RDOC_DIR}\""
 end

data/lib/rgl/adjacency.rb

@@ -1,6 +1,6 @@
 # adjacency.rb
 # 
-# $Id: adjacency.rb,v 1.11 2008/03/02 13:45:43 monora Exp $
+# $Id: adjacency.rb,v 1.12 2008/08/23 05:37:05 javanthropus Exp $
 # 
 # The DirectedAdjacencyGraph class implements a generalized adjacency list
 # graph structure.  An AdjacencyGraph is basically a two-dimensional structure
@@ -173,6 +173,7 @@ module RGL
 
     def to_adjacency
       result = (directed? ? DirectedAdjacencyGraph : AdjacencyGraph).new
+      each_vertex { |v| result.add_vertex(v) }
       each_edge { |u,v| result.add_edge(u, v) }
       result
     end

data/lib/rgl/base.rb

@@ -5,7 +5,7 @@
 # all graphs in the library.
 require 'rgl/enumerable_ext'
 
-RGL_VERSION = "0.3.1"
+RGL_VERSION = "0.4.0"
 
 module RGL
   class NotDirectedError < RuntimeError; end

data/lib/rgl/condensation.rb

@@ -0,0 +1,47 @@
+require 'rgl/base'
+require 'rgl/implicit'
+
+module RGL
+  module Graph
+    # Returns an RGL::ImplicitGraph where the strongly connected components of
+    # this graph are condensed into single nodes represented by Set instances
+    # containing the members of each strongly connected component.  Edges
+    # between the different strongly connected components are preserved while
+    # edges within strongly connected components are omitted.
+    #
+    # Raises RGL::NotDirectedError if run on an undirected graph.
+    def condensation_graph
+      raise NotDirectedError,
+        "condensation_graph only supported for directed graphs" unless directed?
+
+      # Get the component map for the strongly connected components.
+      comp_map = strongly_connected_components.comp_map
+      # Invert the map such that for any number, n, in the component map a Set
+      # instance is created containing all of the nodes which map to n.  The Set
+      # instances will be used to map to the number, n, with which the elements
+      # of the set are associated.
+      inv_comp_map = {}
+      comp_map.each { |v, n| (inv_comp_map[n] ||= Set.new) << v }
+
+      # Create an ImplicitGraph where the nodes are the strongly connected
+      # components of this graph and the edges are the edges of this graph which
+      # cross between the strongly connected components.
+      ImplicitGraph.new do |g|
+        g.vertex_iterator do |b|
+          inv_comp_map.each_value(&b)
+        end
+        g.adjacent_iterator do |scc, b|
+          scc.each do |v|
+            each_adjacent(v) do |w|
+              # Do not make the cluster reference itself in the graph.
+              if comp_map[v] != comp_map[w] then
+                b.call(inv_comp_map[comp_map[w]])
+              end
+            end
+          end
+        end
+        g.directed = true
+      end
+    end
+  end
+end

data/lib/rgl/dot.rb

@@ -1,7 +1,7 @@
 # dot.rb
-# 
-# $Id: dot.rb,v 1.7 2008/02/26 06:01:22 javanthropus Exp $
-# 
+#
+# $Id: dot.rb,v 1.8 2008/08/26 20:07:09 javanthropus Exp $
+#
 # 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.
@@ -12,20 +12,20 @@ module RGL
 
   module Graph
 
-  # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
+  # Return a RGL::DOT::Digraph for directed graphs or a DOT::Subgraph for an
   # undirected Graph.  _params_ can contain any graph property specified in
   # rdot.rb.
 
   def to_dot_graph (params = {})
     params['name'] ||= self.class.name.gsub(/:/,'_')
     fontsize   = params['fontsize'] ? params['fontsize'] : '8'
-    graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
-    edge_class = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
+    graph      = (directed? ? DOT::Digraph : DOT::Subgraph).new(params)
+    edge_class = directed? ? DOT::DirectedEdge : DOT::Edge
     each_vertex do |v|
       name = v.to_s
-      graph << DOT::DOTNode.new('name'     => name,
-                                'fontsize' => fontsize,
-                                'label'    => name)
+      graph << DOT::Node.new('name'     => name,
+                             'fontsize' => fontsize,
+                             'label'    => name)
     end
     each_edge do |u,v|
       graph << edge_class.new('from'     => u.to_s,
@@ -41,8 +41,8 @@ module RGL
       s << to_dot_graph(params).to_s << "\n"
     end
 
-    # Call dotty[http://www.graphviz.org] for the graph which is written to the file 'graph.dot'
-    # in the # current directory.
+    # Call dotty[http://www.graphviz.org] for the graph which is written to the
+    # file 'graph.dot' in the # current directory.
 
     def dotty (params = {})
       dotfile = "graph.dot"
@@ -58,11 +58,11 @@ module RGL
     def write_to_graphic_file (fmt='png', dotfile="graph")
       src = dotfile + ".dot"
       dot = dotfile + "." + fmt
-      
+
       File.open(src, 'w') do |f|
         f << self.to_dot_graph.to_s << "\n"
       end
-      
+
       system( "dot -T#{fmt} #{src} -o #{dot}" )
       dot
     end

data/lib/rgl/rdot.rb

@@ -3,7 +3,7 @@
 #
 # It also supports undirected edges.
 
-module DOT
+module RGL; module DOT
 
   # options for node declaration
 
@@ -131,8 +131,8 @@ module DOT
     'layerseq'
   ]
 
-  # Ancestor of DOTEdge, DOTNode, and DOTGraph.
-  class DOTElement
+  # Ancestor of Edge, Node, and Graph.
+  class Element
     attr_accessor :name, :options
 
     def initialize (params = {}, option_list = []) # :nodoc:
@@ -151,7 +151,7 @@ module DOT
         id = id.to_s
 
         # Return the ID verbatim if it looks like a name, a number, or HTML.
-        return id if id =~ /^([[:alpha:]_][[:alnum:]_]*|-?(\.[[:digit:]]+|[[:digit:]]+(\.[[:digit:]]*)?)|<.*>)$/
+        return id if id =~ /\A([[:alpha:]_][[:alnum:]_]*|-?(\.[[:digit:]]+|[[:digit:]]+(\.[[:digit:]]*)?)|<.*>)\Z/m and id[-1] != ?\n
 
         # Return a quoted version of the ID otherwise.
         '"' + id.gsub('\\', '\\\\\\\\').gsub('"', '\\\\"') + '"'
@@ -166,7 +166,7 @@ module DOT
         label = label.to_s
 
         # Return the label verbatim if it looks like a name, a number, or HTML.
-        return label if label =~ /^([[:alpha:]_][[:alnum:]_]*|-?(\.[[:digit:]]+|[[:digit:]]+(\.[[:digit:]]*)?)|<.*>)$/
+        return label if label =~ /\A([[:alpha:]_][[:alnum:]_]*|-?(\.[[:digit:]]+|[[:digit:]]+(\.[[:digit:]]*)?)|<.*>)\Z/m and label[-1] != ?\n
 
         # Return a quoted version of the label otherwise.
         '"' + label.split(/(\\n|\\r|\\l)/).collect do |part|
@@ -181,9 +181,9 @@ module DOT
   end
 
 
-  # Ports are used when a DOTNode instance has its `shape' option set to
+  # Ports are used when a Node instance has its `shape' option set to
   # _record_ or _Mrecord_.  Ports can be nested.
-  class DOTPort
+  class Port
     attr_accessor :name, :label, :ports
 
     # Create a new port with either an optional name and label or a set of
@@ -222,10 +222,10 @@ module DOT
 
   # A node representation.  Edges are drawn between nodes.  The rendering of a
   # node depends upon the options set for it.
-  class DOTNode < DOTElement
+  class Node < Element
     attr_accessor :ports
 
-    # Creates a new DOTNode with the _params_ Hash providing settings for all
+    # Creates a new Node with the _params_ Hash providing settings for all
     # node options. The _option_list_ parameter restricts those options to the
     # list of valid names it contains. The exception to this is the _ports_
     # option which, if specified, must be an Enumerable containing a list of
@@ -275,14 +275,14 @@ module DOT
       end
     end
 
-  end		# class DOTNode
+  end		# class Node
 
   # A graph representation. Whether or not it is rendered as directed or
   # undirected depends on which of the programs *dot* or *neato* is used to
   # process and render the graph.
-  class DOTGraph < DOTElement
+  class Graph < Element
 
-    # Creates a new DOTGraph with the _params_ Hash providing settings for all
+    # Creates a new Graph with the _params_ Hash providing settings for all
     # graph options. The _option_list_ parameter restricts those options to the
     # list of valid names it contains. The exception to this is the _elements_
     # option which, if specified, must be an Enumerable containing a list of
@@ -349,14 +349,14 @@ module DOT
         (elements.empty? ? '' : elements + "\n") + leader + "}"
     end
 
-  end		# class DOTGraph
+  end		# class Graph
 
-  # A digraph is a directed graph representation which is the same as a DOTGraph
+  # A digraph is a directed graph representation which is the same as a Graph
   # except that its header in dot notation has an identifier of _digraph_
   # instead of _graph_.
-  class DOTDigraph < DOTGraph
+  class Digraph < Graph
 
-    # Creates a new DOTDigraph with the _params_ Hash providing settings for all
+    # Creates a new Digraph with the _params_ Hash providing settings for all
     # graph options.  The _option_list_ parameter restricts those options to the
     # list of valid names it contains. The exception to this is the _elements_
     # option which, if specified, must be an Enumerable containing a list of
@@ -366,14 +366,14 @@ module DOT
       @dot_string = 'digraph'
     end
 
-  end		# class DOTDigraph
+  end		# class Digraph
 
-  # A subgraph is a nested graph element and is the same as a DOTGraph except
+  # A subgraph is a nested graph element and is the same as a Graph except
   # that its header in dot notation has an identifier of _subgraph_ instead of
   # _graph_.
-  class DOTSubgraph < DOTGraph
+  class Subgraph < Graph
 
-    # Creates a new DOTSubgraph with the _params_ Hash providing settings for
+    # Creates a new Subgraph with the _params_ Hash providing settings for
     # all graph options.  The _option_list_ parameter restricts those options to
     # list of valid names it contains. The exception to this is the _elements_
     # option which, if specified, must be an Enumerable containing a list of
@@ -383,10 +383,10 @@ module DOT
       @dot_string = 'subgraph'
     end
 
-  end		# class DOTSubgraph
+  end		# class Subgraph
 
   # This is an undirected edge representation.
-  class DOTEdge < DOTElement
+  class Edge < Element
 
     # A node or subgraph reference or instance to be used as the starting point
     # for an edge.
@@ -395,7 +395,7 @@ module DOT
     # for an edge.
     attr_accessor :to
 
-    # Creates a new DOTEdge with the _params_ Hash providing settings for all
+    # Creates a new Edge with the _params_ Hash providing settings for all
     # edge options.  The _option_list_ parameter restricts those options to the
     # list of valid names it contains.
     def initialize (params = {}, option_list = EDGE_OPTS)
@@ -431,15 +431,15 @@ module DOT
         '--'
       end
 
-  end		# class DOTEdge
+  end		# class Edge
 
-  # A directed edge representation otherwise identical to DOTEdge.
-  class DOTDirectedEdge < DOTEdge
+  # A directed edge representation otherwise identical to Edge.
+  class DirectedEdge < Edge
 
     private
       def edge_link
         '->'
       end
 
-  end                           # class DOTDirectedEdge
-end                             # module DOT
+  end                           # class DirectedEdge
+end; end                        # module RGL; module DOT

data/lib/rgl/transitiv_closure.rb

@@ -1,46 +1,2 @@
-# transitiv_closure.rb
-#
-# == transitive_closure
-# 
-# The transitive closure of a graph G = (V,E) is a graph G* = (V,E*),
-# such that E* contains an edge (u,v) if and only if G contains a path
-# (of at least one edge) from u to v.  The transitive_closure() function
-# transforms the input graph g into the transitive closure graph tc. 
-
-require 'rgl/adjacency'
-
-module RGL
-
-  module Graph
-
-    # Floyd-Warshal algorithm which should be O(n^3), where n is the number of 
-    # nodes.  We can probably work a bit on the constant factors!
-    #
-    # In BGL, there is an algorithm with time complexity (worst-case) O(|V||E|)
-    # (see BOOST_DOC/transitive_closure.html), based on the detection of strong
-    # components.
-
-    def transitive_closure_floyd_warshal
-      raise NotDirectedError,
-        "transitive_closure makes sense only for directed graphs." unless directed?
-      tc = to_adjacency                     # direct links
-
-      # indirect links
-
-      each_vertex do |vi| 
-        each_vertex do |vj| 
-          each_vertex do |vk| 
-            unless tc.has_edge?(vi, vj)
-              tc.add_edge(vi, vj) if has_edge?(vi, vk) and
-                                     has_edge?(vk, vj)
-            end
-          end
-        end
-      end
-      tc
-    end
-
-    alias_method :transitive_closure, :transitive_closure_floyd_warshal
-
-  end                           # module Graph
-end                             # module RGL
+# This file is deprecated and only provided for backward compatibility.
+require 'rgl/transitivity'