gratr19 0.4.4

data/lib/gratr/graph_api.rb

@@ -0,0 +1,82 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AREf
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+module GRATR
+  
+  # This defines the minimum set of functions required to make a graph class that can
+  # use the algorithms defined by this library
+  module GraphAPI
+    
+    # Is the graph directed?
+    # 
+    # This method must be implemented by the specific graph class
+    def directed?()             raise NotImplementedError; end
+
+    # Add a vertex to the Graph and return the Graph
+    # An additional label l can be specified as well
+    # 
+    # This method must be implemented by the specific graph class    
+    def add_vertex!(v,l=nil)     raise NotImplementedError; end
+      
+    # Add an edge to the Graph and return the Graph
+    # u can be an object of type GRATR::Arc or u,v specifies
+    # a source, target pair. The last parameter is an optional label
+    # 
+    # This method must be implemented by the specific graph class
+    def add_edge!(u,v=nil,l=nil) raise NotImplementedError; end
+      
+    # Remove a vertex to the Graph and return the Graph
+    # 
+    # This method must be implemented by the specific graph class
+    def remove_vertex!(v)        raise NotImplementedError; end
+      
+    # Remove an edge from the Graph and return the Graph
+    # 
+    # Can be a type of GRATR::Arc or a source and target
+    # This method must be implemented by the specific graph class
+    def remove_edge!(u,v=nil)    raise NotImplementedError; end
+            
+    # Return the array of vertices.
+    # 
+    # This method must be implemented by the specific graph class
+    def vertices()              raise NotImplementedError; end
+
+    # Return the array of edges.
+    # 
+    # This method must be implemented by the specific graph class
+    def edges()                 raise NotImplementedError; end
+      
+    # Returns the edge class
+    def edge_class()            raise NotImplementedError; end
+    
+    # Return the chromatic number for this graph
+    # This is currently incomplete and in some cases will be NP-complete
+    # FIXME: Should this even be here? My gut feeling is no...
+    def chromatic_number()      raise NotImplementedError; end
+  end
+end

data/lib/gratr/import.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+require 'gratr'
+
+# Pull all GRATR classes up into the current namespace
+Arc                  = GRATR::Arc
+Edge        = GRATR::Edge
+MultiArc             = GRATR::MultiArc
+MultiEdge   = GRATR::MultiEdge
+Graph                 = GRATR::Graph
+Digraph               = GRATR::Digraph
+DirectedGraph         = GRATR::DirectedGraph
+DirectedPseudoGraph   = GRATR::DirectedPseudoGraph
+DirectedMultiGraph    = GRATR::DirectedMultiGraph
+UndirectedGraph       = GRATR::UndirectedGraph
+UndirectedPseudoGraph = GRATR::UndirectedPseudoGraph
+UndirectedMultiGraph  = GRATR::UndirectedMultiGraph
+Complete              = GRATR::Complete

data/lib/gratr/labels.rb

@@ -0,0 +1,103 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+module GRATR
+  module Labels
+    # Return a label for an edge or vertex
+    def [](u) (u.kind_of? GRATR::Arc) ? edge_label(u) : vertex_label(u); end
+
+    # Set a label for an edge or vertex
+    def []= (u, value) (u.kind_of? GRATR::Arc) ? edge_label_set(u,value) : vertex_label_set(u, value); end
+
+    # Delete a label entirely
+    def delete_label(u) (u.kind_of? GRATR::Arc) ? edge_label_delete(u) : vertex_label_delete(u); end
+
+    # Get the label for an edge
+    def vertex_label(v)        vertex_label_dict[v]; end
+
+    # Set the label for an edge
+    def vertex_label_set(v, l) vertex_label_dict[v] = l; self; end
+
+    # Get the label for an edge
+    def edge_label(u,v=nil,n=nil)
+      u = edge_convert(u,v,n)
+      edge_label_dict[u]
+    end
+
+    # Set the label for an edge
+    def edge_label_set(u, v=nil, l=nil, n=nil) 
+      u.kind_of?(GRATR::Arc) ? l = v : u = edge_convert(u,v,n)
+      edge_label_dict[u] = l; self
+    end
+
+    # Delete all graph labels
+    def clear_all_labels()  @vertex_labels = {}; @edge_labels = {}; end
+
+    # Delete an edge label
+    def edge_label_delete(u, v=nil, n=nil)
+      u = edge_convert(u,v,n)
+      edge_label_dict.delete(u)
+    end
+
+    # Delete a vertex label
+    def vertex_label_delete(v) vertex_label_dict.delete(v); end
+
+   protected
+
+    def vertex_label_dict() @vertex_labels ||= {}; end
+    def edge_label_dict()   @edge_labels   ||= {}; end
+
+    # A generic cost function. It either calls the weight function with and edge
+    # constructed from the two nodes, or calls the [] operator of the label
+    # when given a value. If no weight value is specified, the label itself is
+    # treated as the cost value.
+    #
+    # Note: This function will not work for Pseudo or Multi graphs at present. 
+    # FIXME: Remove u,v interface to fix Pseudo Multi graph problems.
+    def cost(u,v=nil,weight=nil)
+      u.kind_of?(Arc) ? weight = v : u = edge_class[u,v] 
+      case weight
+        when Proc : weight.call(u)
+        when nil  : self[u]
+        else        self[u][weight]
+      end
+    end
+    
+    # An alias of cost for property retrieval in general
+    alias property cost
+    
+    # A function to set properties specified by the user.
+    def property_set(u,name,value)
+      case name
+        when Proc : name.call(value)
+        when nil  : self[u] = value
+        else        self[u][name] = value
+      end
+    end
+
+  end
+end

data/lib/gratr/maximum_flow.rb

@@ -0,0 +1,107 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+require 'gratr/digraph'
+
+module GRATR
+
+  class Network < Digraph
+    attr_accessor :lower, :upper, :cost, :flow
+
+    def residual(residual_capacity, cost_property, zero = 0)
+      r = Digraph.new
+      edges.each do |e1| 
+        [e1,e1.reverse].each do |e|
+          rij = property(e,self.upper) - property(e,self.flow) if edge? e
+          rij += property(e.reverse,self.flow) - property(e.reverse,self.lower) if edge? e.reverse
+          r.add_edge!(e) if rij > zero
+          r.property_set(e,residual_capacity, rij)
+          r.property_set(e,cost, cost(e,cost_property))
+        end
+      end
+      r
+    end
+        
+    def maximum_flow() eliminate_lower_bounds.maximum_flow_prime.restore_lower_bounds(self); end
+    
+   private:
+
+    def eliminate_lower_bounds
+      no_lower_bounds = Digraph.new(self)
+      if self.upper.kind_of? Proc then
+         no_lower_bounds.upper = Proc.new {|e| self.upper.call(e) - property(e,self.lower) }
+      else
+        no_lower_bounds.edges.each {|e| no_lower_bounds[e][self.upper] -= property(e,self.lower)}
+      end
+      no_lower_bounds
+    end
+
+    def restore_lower_bounds(src)
+      src.edges.each do {|e| (src.flow ? src[e][src.flow] : src[e]) = property(e,self.flow) + src.property(e,self.lower) }
+      src
+    end
+   
+    def maximum_flow_prime
+    end
+    
+  end
+
+  module Graph
+
+    module MaximumFlow
+
+      # Maximum flow, it returns an array with the maximum flow and a hash of flow per edge
+      # Currently a highly inefficient implementation, FIXME, This should use Goldberg and Tarjan's method.
+      def maximum_flow(s, t, capacity = nil, zero = 0)
+        flow       = Hash.new(zero)
+        available  = Hash.new(zero)
+        total      = zero
+        edges.each {|e| available[e] = cost(e,capacity)} 
+        adj_positive = Proc.new do |u|
+          adjacent(u).select {|r| available[edge_class[u,r]] > zero}
+        end
+        while (tree = bfs_tree_from_vertex(start))[t]
+          route = [t]
+          while route[-1] != s
+            route << tree[route[route[-1]]]
+            raise ArgumentError, "No route from #{s} to #{t} possible"
+          end; route.reverse
+          amt   = route.map {|e| available[e]}.min
+          route.each do |e|
+            flow[e]      += amt
+            available[e] -= amt
+          end
+          total += amt
+        end
+        
+        [total, flow]
+      end
+
+    end # MaximumFlow
+  end # Graph
+end # GRATR

data/lib/gratr/rdot.rb

@@ -0,0 +1,332 @@
+# rdot.rb
+# 
+# $Id: rdot.rb,v 1.4 2005/03/26 15:06:36 wsdng Exp $
+#
+# This is a modified version of dot.rb from Dave Thomas's rdoc project.  I [Horst Duchene]
+# renamed it to rdot.rb to avoid collision with an installed rdoc/dot.
+#
+# It also supports undirected edges.
+
+class Hash
+  def stringify_keys
+    inject({}) {|options, (key, value)| options[key.to_s] = value; options}
+  end
+end unless Hash.respond_to? :stringify_keys
+
+module DOT
+    
+  # These glogal vars are used to make nice graph source.
+
+  $tab  = '    '
+  $tab2 = $tab * 2
+    
+  # if we don't like 4 spaces, we can change it any time
+
+  def change_tab (t)
+    $tab  = t
+    $tab2 = t * 2
+  end
+    
+  # options for node declaration
+
+  NODE_OPTS = [
+    # attributes due to
+    # http://www.graphviz.org/Documentation/dotguide.pdf
+    # March, 26, 2005
+    'bottomlabel', # auxiliary label for nodes of shape M*
+    'color', # default: black; node shape color
+    'comment', # any string (format-dependent)
+    'distortion', # default: 0.0; node distortion for shape=polygon
+    'fillcolor', # default: lightgrey/black; node fill color
+    'fixedsize', # default: false; label text has no affect on node size
+    'fontcolor', # default: black; type face color
+    'fontname', # default: Times-Roman; font family
+    'fontsize', #default: 14; point size of label
+    'group', # name of node�s group
+    'height', # default: .5; height in inches
+    'label', # default: node name; any string
+    'layer', # default: overlay range; all, id or id:id
+    'orientation', # dafault: 0.0; node rotation angle
+    'peripheries', # shape-dependent number of node boundaries
+    'regular', # default:  false; force polygon to be regular
+    'shape', # default: ellipse; node shape; see Section 2.1 and Appendix E
+    'shapefile', # external EPSF or SVG custom shape file
+    'sides', # default: 4; number of sides for shape=polygon
+    'skew' , # default: 0.0; skewing of node for shape=polygon
+    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+    'toplabel', # auxiliary label for nodes of shape M*
+    'URL', # URL associated with node (format-dependent)
+    'width', # default: .75; width in inches
+    'z', #default: 0.0; z coordinate for VRML output
+
+    # maintained for backward compatibility or rdot internal
+    'bgcolor',
+    'rank'
+  ]
+    
+  # options for edge declaration
+
+  EDGE_OPTS = [
+    'arrowhead', # default: normal; style of arrowhead at head end
+    'arrowsize', # default: 1.0; scaling factor for arrowheads
+    'arrowtail', # default: normal; style of arrowhead at tail end
+    'color', # default: black; edge stroke color
+    'comment', # any string (format-dependent)
+    'constraint', # default: true use edge to affect node ranking
+    'decorate', # if set, draws a line connecting labels with their edges
+    'dir', # default: forward; forward, back, both, or none
+    'fontcolor', # default: black type face color
+    'fontname', # default: Times-Roman; font family
+    'fontsize', # default: 14; point size of label
+    'headlabel', # label placed near head of edge
+    'headport', # n,ne,e,se,s,sw,w,nw
+    'headURL', # URL attached to head label if output format is ismap
+    'label', # edge label
+    'labelangle', # default: -25.0; angle in degrees which head or tail label is rotated off edge
+    'labeldistance', # default: 1.0; scaling factor for distance of head or tail label from node
+    'labelfloat', # default: false; lessen constraints on edge label placement
+    'labelfontcolor', # default: black; type face color for head and tail labels
+    'labelfontname', # default: Times-Roman; font family for head and tail labels
+    'labelfontsize', # default: 14 point size for head and tail labels
+    'layer', # default: overlay range; all, id or id:id
+    'lhead', # name of cluster to use as head of edge
+    'ltail', # name of cluster to use as tail of edge
+    'minlen', # default: 1 minimum rank distance between head and tail
+    'samehead', # tag for head node; edge heads with the same tag are merged onto the same port
+    'sametail', # tag for tail node; edge tails with the same tag are merged onto the same port
+    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+    'taillabel', # label placed near tail of edge
+    'tailport', # n,ne,e,se,s,sw,w,nw
+    'tailURL', # URL attached to tail label if output format is ismap
+    'weight', # default: 1; integer cost of stretching an edge
+
+    # maintained for backward compatibility or rdot internal
+    'id'
+  ]
+    
+  # options for graph declaration
+
+  GRAPH_OPTS = [
+    'bgcolor',
+    'center', 'clusterrank', 'color', 'concentrate',
+    'fontcolor', 'fontname', 'fontsize',
+    'label', 'layerseq',
+    'margin', 'mclimit',
+    'nodesep', 'nslimit',
+    'ordering', 'orientation',
+    'page',
+    'rank', 'rankdir', 'ranksep', 'ratio',
+    'size'
+  ]
+    
+  # a root class for any element in dot notation
+
+  class DOTSimpleElement
+
+    attr_accessor :name
+
+    def initialize (params = {})
+      @label = params['name'] ? params['name'] : ''
+    end
+
+    def to_s
+      @name
+    end
+  end
+    
+  # an element that has options ( node, edge, or graph )
+
+  class DOTElement < DOTSimpleElement
+
+    # attr_reader :parent
+    attr_accessor :name, :options
+
+    def initialize (params = {}, option_list = [])
+      super(params)
+      @name   = params['name']   ? params['name']   : nil 
+      @parent = params['parent'] ? params['parent'] : nil
+      @options = {}
+      p = params.stringify_keys
+      option_list.each {|i| @options[i] = p[i] if p[i] }
+      @options['label'] ||= @name if @name != 'node'
+    end
+        
+    def each_option
+      @options.each{ |i| yield i }
+    end
+
+    def each_option_pair
+      @options.each_pair{ |key, val| yield key, val }
+    end
+
+    #def parent=( thing )
+    #    @parent.delete( self ) if defined?( @parent ) and @parent
+    #    @parent = thing
+    #end
+
+  end
+    
+    
+  # This is used when we build nodes that have shape=record
+  # ports don't have options :)
+
+  class DOTPort < DOTSimpleElement
+
+    attr_accessor :label
+        
+    def initialize (params = {})
+      super(params)
+      @name = params['label'] ? params['label'] : ''
+    end
+
+    def to_s
+      ( @name && @name != "" ? "<#{@name}>" : "" ) + "#{@label}"
+    end
+  end
+    
+  # node element
+
+  class DOTNode < DOTElement
+
+    @ports
+
+    def initialize (params = {}, option_list = NODE_OPTS)
+      super(params, option_list)
+      @ports = params['ports'] ? params['ports'] : []
+    end
+
+    def each_port
+      @ports.each { |i| yield i }
+    end
+
+    def << (thing)
+      @ports << thing
+    end
+
+    def push (thing)
+      @ports.push(thing)
+    end
+
+    def pop
+      @ports.pop
+    end
+
+    def to_s (t = '')
+
+      # This code is totally incomprehensible; it needs to be replaced!
+
+      label = @options['shape'] != 'record' && @ports.length == 0 ?
+                @options['label'] ? 
+                    t + $tab + "label = \"#{@options['label']}\"\n" :
+                    '' :
+                t + $tab + 'label = "' + " \\\n" +
+                t + $tab2 + "#{@options['label']}| \\\n" +
+                @ports.collect{ |i|
+                    t + $tab2 + i.to_s
+                }.join( "| \\\n" ) + " \\\n" +
+                t + $tab + '"' + "\n"
+            
+            t + "#{@name} [\n" +
+            @options.to_a.collect{ |i|
+                i[1] && i[0] != 'label' ? 
+                    t + $tab + "#{i[0]} = #{i[1]}" : nil
+            }.compact.join( ",\n" ) + ( label != '' ? ",\n" : "\n" ) + 
+            label +
+            t + "]\n" 
+      end
+
+  end		# class DOTNode
+
+  # A subgraph element is the same to graph, but has another header in dot
+  # notation.
+
+  class DOTSubgraph < DOTElement
+
+    @nodes
+    @dot_string
+
+    def initialize (params = {}, option_list = GRAPH_OPTS)
+      super(params, option_list)
+      @nodes      = params['nodes'] ? params['nodes'] : []
+      @dot_string = 'graph'
+    end
+
+    def each_node
+      @nodes.each{ |i| yield i }
+    end
+
+    def << (thing)
+      @nodes << thing
+    end
+       
+    def push (thing)
+      @nodes.push( thing )
+    end
+
+    def pop
+      @nodes.pop
+    end
+
+    def to_s (t = '')
+      hdr = t + "#{@dot_string} #{@name} {\n"
+
+      options = @options.to_a.collect{ |name, val|
+        val && name != 'label' ? 
+          t + $tab + "#{name} = #{val}" : 
+          name ? t + $tab + "#{name} = \"#{val}\"" : nil
+      }.compact.join( "\n" ) + "\n"
+
+      nodes = @nodes.collect{ |i|
+        i.to_s( t + $tab )
+      }.join( "\n" ) + "\n" 
+      hdr + options + nodes + t + "}\n"
+    end
+
+  end		# class DOTSubgraph
+
+  # This is a graph.
+
+  class DOTDigraph < DOTSubgraph
+
+    def initialize (params = {}, option_list = GRAPH_OPTS)
+      super(params, option_list)
+      @dot_string = 'digraph'
+    end
+
+  end		# class DOTDigraph
+
+  # This is an edge.
+
+  class DOTArc < DOTElement
+
+    attr_accessor :from, :to
+
+    def initialize (params = {}, option_list = EDGE_OPTS)
+      super(params, option_list)
+      @from = params['from'] ? params['from'] : nil
+      @to   = params['to'] ? params['to'] : nil
+    end
+       
+    def edge_link
+      '--'
+    end
+
+    def to_s (t = '')
+      t + "#{@from} #{edge_link} #{to} [\n" +
+          @options.to_a.collect{ |i|
+            i[1] && i[0] != 'label' ? 
+              t + $tab + "#{i[0]} = #{i[1]}" : 
+              i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil
+          }.compact.join( "\n" ) + "\n" + t + "]\n"
+    end
+
+  end		# class DOTArc
+          
+  class DOTDirectedArc < DOTArc
+
+    def edge_link
+      '->'
+    end
+
+  end                           # class DOTDirectedArc
+end                             # module DOT