ruby-graphviz 1.0.1 → 1.0.2

data/lib/graphviz/graphml.rb

@@ -37,9 +37,7 @@ class GraphViz
       'undirected' => :graph
     }
     
-    #
     # Create a new GraphViz object from a GraphML file of string
-    #
     def initialize( file_or_str )
       data = ((File.file?( file_or_str )) ? File::new(file_or_str) : file_or_str) 
       @xmlDoc = REXML::Document::new( data )
@@ -221,4 +219,4 @@ class GraphViz
       } 
     end
   end
-end
+end

data/lib/graphviz/node.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Gregoire Lejeune <gregoire.lejeune@free.fr>
+# Copyright (C) 2004 - 2011 Gregoire Lejeune <gregoire.lejeune@free.fr>
 # 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -18,153 +18,139 @@ require 'graphviz/attrs'
 require 'graphviz/constants'
 
 class GraphViz
-  class Node
-    include Constants
-    @xNodeName
-    @oAttrNode
-    @oGParrent
-    
-    # 
-    # Create a new node
-    # 
-    # In:
-    # * xNodeName : ID of the node
-    # * oGParrent : Graph 
-    # 
-    def initialize( xNodeName, oGParrent )
-      @xNodeName = xNodeName
-      @oGParrent = oGParrent
-      @oAttrNode = GraphViz::Attrs::new( nil, "node", NODESATTRS )
-      @index = nil
-    end
-
-    # 
-    # Get the node ID
-    # 
-    def id
-	    @xNodeName.clone
-	  end
-	  
-	  #
-	  # Return the node index
-	  #
-	  def index
-	    @index
-    end
-    def index=(i) #:nodoc:
-      @index = i if @index == nil
-    end
-
-    #
-    # Return the root graph
-    #
-    def root_graph
-      return( (self.pg.nil?) ? nil : self.pg.root_graph )
-    end
-    
-	 # 
-    # Set value +xAttrValue+ to the node attribut +xAttrName+
-    # 
-    def []=( xAttrName, xAttrValue )
-      xAttrValue = xAttrValue.to_s if xAttrValue.class == Symbol
-      @oAttrNode[xAttrName.to_s] = xAttrValue
-    end
-
-    # 
-    # Get the value of the node attribut +xAttrName+
-    # 
-    def []( xAttrName )
-      if Hash === xAttrName
-        xAttrName.each do |key, value|
-          self[key] = value
-        end
-        return self
-      else
-        (@oAttrNode[xAttrName.to_s].nil?)?nil:@oAttrNode[xAttrName.to_s].clone
+   class Node
+      include Constants
+
+      # List of nodes that are directly accessible from given node (in a directed graph neighbors == incidents)
+      attr_reader :neighbors
+      # List of nodes that are incident to the given node (in a directed graph neighbors == incidents)
+      attr_reader :incidents
+
+      # Create a new node
+      # 
+      # * node_id : ID of the node
+      # * parent_graph : Graph 
+      def initialize( node_id, parent_graph )
+         @neighbors = []
+         @incidents = []
+         @node_id = node_id
+         @parent_graph = parent_graph
+         @node_attributs = GraphViz::Attrs::new( nil, "node", NODESATTRS )
+         @index = nil
+      end
+
+      # Get the node ID
+      def id
+         @node_id.clone
+      end
+
+      # Return the node index
+      def index
+         @index
+      end
+      def index=(i) #:nodoc:
+         @index = i if @index == nil
+      end
+
+      # Return the root graph
+      def root_graph
+         return( (self.pg.nil?) ? nil : self.pg.root_graph )
+      end
+
+      # Set value +attribut_value+ to the node attribut +attribut_name+
+      def []=( attribut_name, attribut_value )
+         attribut_value = attribut_value.to_s if attribut_value.class == Symbol
+         @node_attributs[attribut_name.to_s] = attribut_value
       end
-    end
-
-    #
-    # Calls block once for each attribut of the node, passing the name and value to the 
-    # block as a two-element array.
-    #
-    # If global is set to false, the block does not receive the attributs set globally
-    #
-    def each_attribut(global = true, &b)
-      attrs = @oAttrNode.to_h
-      if global
-        attrs = pg.node.to_h.merge attrs
+
+      # Get the value of the node attribut +attribut_name+
+      def []( attribut_name )
+         if Hash === attribut_name
+            attribut_name.each do |key, value|
+               self[key] = value
+            end
+            return self
+         else
+            (@node_attributs[attribut_name.to_s].nil?)?nil:@node_attributs[attribut_name.to_s].clone
+         end
       end
-      attrs.each do |k,v|
-        yield(k,v)
+
+      # Calls block once for each attribut of the node, passing the name and value to the 
+      # block as a two-element array.
+      #
+      # If global is set to false, the block does not receive the attributs set globally
+      def each_attribut(global = true, &b)
+         attrs = @node_attributs.to_h
+         if global
+            attrs = pg.node.to_h.merge attrs
+         end
+         attrs.each do |k,v|
+            yield(k,v)
+         end
       end
-    end
-    
-    # 
-    # Create an edge between the current node and the node +oNode+
-    # 
-    def <<( oNode )
-      if( oNode.class == Array ) 
-        oNode.each do |no|
-          self << no
-        end
-      else
-        return GraphViz::commonGraph( oNode, self ).add_edge( self, oNode )
+
+      # Create an edge between the current node and the node +node+
+      def <<( node )
+         if( node.class == Array ) 
+            node.each do |no|
+               self << no
+            end
+         else
+            return GraphViz::commonGraph( node, self ).add_edge( self, node )
+         end
       end
-    end
-    alias :> :<<
-    alias :- :<<
-    alias :>> :<<
-    
-    #
-    # Set node attributs
-    #
-    # Example :
-    #   n = graph.add_node( ... )
-    #   ...
-    #   n.set { |_n|
-    #     _n.color = "blue"
-    #     _n.fontcolor = "red"
-    #   }
-    # 
-    def set( &b )
-      yield( self )
-    end
-    
-    # Add node options
-    # use node.<option>=<value> or node.<option>( <value> )
-    def method_missing( idName, *args, &block ) #:nodoc:
-      xName = idName.id2name
-      
-      self[xName.gsub( /=$/, "" )]=args[0]
-    end
-    
-    def pg #:nodoc:
-      @oGParrent
-    end
-    
-    def output #:nodoc:
-      #xNodeName = @xNodeName.clone
-      #xNodeName = '"' << xNodeName << '"' if xNodeName.match( /^[a-zA-Z_]+[a-zA-Z0-9_\.]*$/ ).nil?
-      xNodeName = GraphViz.escape(@xNodeName)
-      
-      xOut = "" << xNodeName
-      xAttr = ""
-      xSeparator = ""
-      
-      if @oAttrNode.data.has_key?("label") and @oAttrNode.data.has_key?("html")
-        @oAttrNode.data.delete("label")
+      alias :> :<<
+      alias :- :<<
+      alias :>> :<<
+
+      # Set node attributs
+      #
+      # Example :
+      #   n = graph.add_node( ... )
+      #   ...
+      #   n.set { |_n|
+      #     _n.color = "blue"
+      #     _n.fontcolor = "red"
+      #   }
+      # 
+      def set( &b )
+         yield( self )
       end
-      @oAttrNode.data.each do |k, v|
-        xAttr << xSeparator + k + " = " + v.to_gv
-        xSeparator = ", "
+
+      # Add node options
+      # use node.<option>=<value> or node.<option>( <value> )
+      def method_missing( idName, *args, &block ) #:nodoc:
+         xName = idName.id2name
+
+         self[xName.gsub( /=$/, "" )]=args[0]
       end
-      if xAttr.length > 0
-        xOut << " [" + xAttr + "]"
+
+      def pg #:nodoc:
+         @parent_graph
       end
-      xOut << ";"
 
-      return( xOut )
-    end
-  end
+      def output #:nodoc:
+         #node_id = @node_id.clone
+         #node_id = '"' << node_id << '"' if node_id.match( /^[a-zA-Z_]+[a-zA-Z0-9_\.]*$/ ).nil?
+         node_id = GraphViz.escape(@node_id)
+
+         xOut = "" << node_id
+         xAttr = ""
+         xSeparator = ""
+
+         if @node_attributs.data.has_key?("label") and @node_attributs.data.has_key?("html")
+            @node_attributs.data.delete("label")
+         end
+         @node_attributs.data.each do |k, v|
+            xAttr << xSeparator + k + " = " + v.to_gv
+            xSeparator = ", "
+         end
+         if xAttr.length > 0
+            xOut << " [" + xAttr + "]"
+         end
+         xOut << ";"
+
+         return( xOut )
+      end
+   end
 end

data/lib/graphviz/theory.rb

@@ -1,252 +1,286 @@
 require 'graphviz/math/matrix'
 
 class GraphViz
-  class Theory
-    def initialize( graph )
-      @graph = graph
-    end
-    
-    #
-    # Return the adjancy matrix of the graph
-    #
-    def adjancy_matrix
-      matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count )
-      
-      @graph.each_edge { |e|
-        x = @graph.get_node(e.node_one( false )).index
-        y = @graph.get_node(e.node_two( false )).index
-        matrix[x+1, y+1] = 1
-        matrix[y+1, x+1] = 1 if @graph.type == "graph"
-      }
-      
-      return matrix
-    end
-    
-    #
-    # Return the incidence matrix of the graph
-    #
-    def incidence_matrix
-      tail = (@graph.type == "digraph") ? -1 : 1
-      matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.edge_count )
-      
-      @graph.each_edge { |e|
-        x = e.index
-        
-        nstart = @graph.get_node(e.node_one( false )).index
-        nend = @graph.get_node(e.node_two( false )).index
-        
-        matrix[nstart+1, x+1] = 1
-        matrix[nend+1, x+1] = tail
-        matrix[nend+1, x+1] = 2 if nstart == nend
-      }
-      
-      return matrix
-    end
-    
-    #
-    # Return the degree of the given node
-    #
-    def degree( node )
-      degree = 0
-      name = node 
-      if node.kind_of?(GraphViz::Node)
-        name = node.id
-      end
-      
-      @graph.each_edge do |e|
-        degree += 1 if e.node_one(false) == name or e.node_two(false) == name
-      end
-      
-      return degree
-    end
-        
-    #
-    # Return the laplacian matrix of the graph
-    #
-    def laplacian_matrix
-      return degree_matrix - adjancy_matrix
-    end
-    
-    #
-    # Return <tt>true</tt> if the graph if symmetric, <tt>false</tt> otherwise   
-    #
-    def symmetric?
-      adjancy_matrix == adjancy_matrix.transpose
-    end
-
-    #
-    # moore_dijkstra(source, destination)
-    # 
-    def moore_dijkstra( dep, arv )
-      dep = @graph.get_node(dep) unless dep.kind_of?(GraphViz::Node)
-      arv = @graph.get_node(arv) unless arv.kind_of?(GraphViz::Node)
-      
-      m = distance_matrix
-      n = @graph.node_count
-      # Table des sommets à choisir
-      c = [dep.index]
-      # Table des distances
-      d = []
-      d[dep.index] = 0
-      
-      # Table des predecesseurs
-      pred = []
-      
-      @graph.each_node do |name, k|
-        if k != dep
-          d[k.index] = m[dep.index+1,k.index+1]
-          pred[k.index] = dep
-        end
-      end
-      
-      while c.size < n
-        # trouver y tel que d[y] = min{d[k];  k sommet tel que k n'appartient pas à c}
-        mini = 1.0/0.0
-        y = nil
-        @graph.each_node do |name, k|
-          next if c.include?(k.index)
-          if d[k.index] < mini
-            mini = d[k.index]
-            y = k
-          end
-        end
-        
-        # si ce minimum est ∞ alors sortir de la boucle fin si
-        break unless mini.to_f.infinite?.nil?
-        
-        c << y.index
-        @graph.each_node do |name, k|
-          next if c.include?(k.index)
-          if d[k.index] > d[y.index] + m[y.index+1,k.index+1]
-            d[k.index] = d[y.index] + m[y.index+1,k.index+1]
-            pred[k.index] = y
-          end
-        end
-      end
-      
-      # Construction du chemin le plus court
-      ch = []
-      k = arv
-      while k.index != dep.index
-        ch.unshift(k.id)
-        k = pred[k.index]
-      end
-      ch.unshift(dep.id)
-      
-      if d[arv.index].to_f.infinite?
-        return nil
-      else
-        return( { 
-          :path => ch,
-          :distance => d[arv.index]
-        } )
-      end
-    end
-    
-    #
-    # Return a liste of range
-    #
-    # If the returned array include nil values, there is one or more circuits in the graph
-    #
-    def range
-      matrix = adjancy_matrix
-      unseen = (1..matrix.columns).to_a
-      result = Array.new(matrix.columns)
-      r = 0
-
-      range_recursion( matrix, unseen, result, r )
-    end
-    
-    #
-    # Return the critical path for a PERT network
-    #
-    # If the given graph is not a PERT network, return nul
-    #
-    def critical_path
-      return nil if range.include?(nil) or @graph.type != "digraph"
-      r = [ [0, [1]] ]
-      
-      critical_path_recursion( distance_matrix, adjancy_matrix, r, [], 0 ).inject( {:distance => 0, :path => []} ) { |r, item|
-        (r[:distance] < item[0]) ? { :distance => item[0], :path => item[1] } : r
-      }
-    end
-    
-    private 
-    def distance_matrix
-      type = @graph.type
-      matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count, (1.0/0.0) )
-      
-      @graph.each_edge { |e|
-        x = @graph.get_node(e.node_one( false )).index
-        y = @graph.get_node(e.node_two( false )).index
-        unless x == y
-          weight = ((e[:weight].nil?) ? 1 : e[:weight].to_f)
-          matrix[x+1, y+1] = weight
-          matrix[y+1, x+1] = weight if type == "graph"
-        end
-      }
-      
-      return matrix
-    end    
-  
-    def degree_matrix
-      matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count )
-      @graph.each_node do |name, node|
-        i = node.index
-        matrix[i+1, i+1] = degree(node)
-      end
-      return matrix
-    end
-  
-    def range_recursion(matrix, unseen, result, r)
-      remove = []
-      matrix.columns.times do |c|
-        if matrix.sum_of_column(c+1) == 0
-          result[unseen[c]-1] = r
-          remove.unshift( c + 1 )
-        end
-      end
-
-      remove.each do |rem|
-        matrix = matrix.remove_line(rem).remove_column(rem)
-        unseen.delete_at(rem-1)
-      end
-
-      if matrix.columns == 1 and matrix.lines == 1
-        if matrix.sum_of_column(1) == 0
-          result[unseen[0]-1] = r+1
-        end
-      elsif remove.size > 0
-        range_recursion( matrix, unseen, result, r+1 )
-      end
-
-      return result
-    end
-  
-    def index_of_item( array, item )
-      array.inject( [0,[]] ){|a,i|
-        a[1] << a[0] if i == item
-        a[0] += 1
-        a
-      }[1]
-    end
-
-    def critical_path_recursion( d, a, r, result, level )
-      r.each do |p|
-        node = p[1][-1]
-        index_of_item( a.line(node), 1 ).each do |c|
-          succ = c+1
-
-          cpath = [ (p[0] + d[node,succ]), (p[1].clone << succ) ]
-
-          if index_of_item( a.line(succ), 1 ).size > 0
-            capth = critical_path_recursion( d, a, [cpath], result, level+1 )
-          else
-            result << cpath
-          end          
-        end
-      end
-      return result
-    end
-  end
-end
+   class Theory
+      def initialize( graph )
+         @graph = graph
+      end
+
+      # Return the adjancy matrix of the graph
+      def adjancy_matrix
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count )
+
+         @graph.each_edge { |e|
+            x = @graph.get_node(e.node_one( false )).index
+            y = @graph.get_node(e.node_two( false )).index
+            matrix[x+1, y+1] = 1
+            matrix[y+1, x+1] = 1 if @graph.type == "graph"
+         }
+
+         return matrix
+      end
+
+      # Return the incidence matrix of the graph
+      def incidence_matrix
+         tail = (@graph.type == "digraph") ? -1 : 1
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.edge_count )
+
+         @graph.each_edge { |e|
+            x = e.index
+
+            nstart = @graph.get_node(e.node_one( false )).index
+            nend = @graph.get_node(e.node_two( false )).index
+
+            matrix[nstart+1, x+1] = 1
+            matrix[nend+1, x+1] = tail
+            matrix[nend+1, x+1] = 2 if nstart == nend
+         }
+
+         return matrix
+      end
+
+      # Return the degree of the given node
+      def degree( node )
+         degree = 0
+         name = node 
+         if node.kind_of?(GraphViz::Node)
+            name = node.id
+         end
+
+         @graph.each_edge do |e|
+            degree += 1 if e.node_one(false) == name or e.node_two(false) == name
+         end
+
+         return degree
+      end
+
+      # Return the laplacian matrix of the graph
+      def laplacian_matrix
+         return degree_matrix - adjancy_matrix
+      end
+
+      # Return <tt>true</tt> if the graph if symmetric, <tt>false</tt> otherwise   
+      def symmetric?
+         adjancy_matrix == adjancy_matrix.transpose
+      end
+
+      # moore_dijkstra(source, destination)
+      def moore_dijkstra( dep, arv )
+         dep = @graph.get_node(dep) unless dep.kind_of?(GraphViz::Node)
+         arv = @graph.get_node(arv) unless arv.kind_of?(GraphViz::Node)
+
+         m = distance_matrix
+         n = @graph.node_count
+         # Table des sommets à choisir
+         c = [dep.index]
+         # Table des distances
+         d = []
+         d[dep.index] = 0
+
+         # Table des predecesseurs
+         pred = []
+
+         @graph.each_node do |name, k|
+            if k != dep
+               d[k.index] = m[dep.index+1,k.index+1]
+               pred[k.index] = dep
+            end
+         end
+
+         while c.size < n
+            # trouver y tel que d[y] = min{d[k];  k sommet tel que k n'appartient pas à c}
+            mini = 1.0/0.0
+            y = nil
+            @graph.each_node do |name, k|
+               next if c.include?(k.index)
+               if d[k.index] < mini
+                  mini = d[k.index]
+                  y = k
+               end
+            end
+
+            # si ce minimum est ∞ alors sortir de la boucle fin si
+            break unless mini.to_f.infinite?.nil?
+
+            c << y.index
+            @graph.each_node do |name, k|
+               next if c.include?(k.index)
+               if d[k.index] > d[y.index] + m[y.index+1,k.index+1]
+                  d[k.index] = d[y.index] + m[y.index+1,k.index+1]
+                  pred[k.index] = y
+               end
+            end
+         end
+
+         # Construction du chemin le plus court
+         ch = []
+         k = arv
+         while k.index != dep.index
+            ch.unshift(k.id)
+            k = pred[k.index]
+         end
+         ch.unshift(dep.id)
+
+         if d[arv.index].to_f.infinite?
+            return nil
+         else
+            return( { 
+               :path => ch,
+               :distance => d[arv.index]
+            } )
+         end
+      end
+
+      # Return a liste of range
+      #
+      # If the returned array include nil values, there is one or more circuits in the graph
+      def range
+         matrix = adjancy_matrix
+         unseen = (1..matrix.columns).to_a
+         result = Array.new(matrix.columns)
+         r = 0
+
+         range_recursion( matrix, unseen, result, r )
+      end
+
+      # Return the critical path for a PERT network
+      #
+      # If the given graph is not a PERT network, return nul
+      def critical_path
+         return nil if range.include?(nil) or @graph.type != "digraph"
+         r = [ [0, [1]] ]
+
+         critical_path_recursion( distance_matrix, adjancy_matrix, r, [], 0 ).inject( {:distance => 0, :path => []} ) { |r, item|
+            (r[:distance] < item[0]) ? { :distance => item[0], :path => item[1] } : r
+         }
+      end
+
+      # Return the PageRank in an directed graph.
+      #
+      # * damping_factor: PageRank dumping factor.
+      # * max_iterations: Maximum number of iterations.
+      # * min_delta: Smallest variation required to have a new iteration.
+      def pagerank(damping_factor = 0.85, max_iterations = 100, min_delta = 0.00001)
+         return nil unless @graph.directed?
+
+         min_value = (1.0-damping_factor)/@graph.node_count
+
+         pagerank = {}
+         @graph.each_node { |_, node|
+            pagerank[node] = 1.0/@graph.node_count
+         }
+
+         max_iterations.times { |_|
+            diff = 0
+            @graph.each_node { |_, node|
+               rank = min_value
+               incidents(node).each { |referent|
+                  rank += damping_factor * pagerank[referent] / neighbors(referent).size
+               }
+
+               diff += (pagerank[node] - rank).abs
+               pagerank[node] = rank
+            }
+            break if diff < min_delta
+         }
+
+         return pagerank
+      end
+
+      # Return the list of nodes that are directly accessible from given node 
+      def neighbors(node)
+         if node.class == String
+            @graph.get_node(node).neighbors
+         else
+            node.neighbors
+         end
+      end
+
+      # Return the list of nodes that are incident to the given node (in a directed graph neighbors == incidents)
+      def incidents(node)
+         if node.class == String
+            @graph.get_node(node).incidents
+         else
+            node.incidents
+         end
+      end
+
+      private 
+      def distance_matrix
+         type = @graph.type
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count, (1.0/0.0) )
+
+         @graph.each_edge { |e|
+            x = @graph.get_node(e.node_one( false )).index
+            y = @graph.get_node(e.node_two( false )).index
+            unless x == y
+               weight = ((e[:weight].nil?) ? 1 : e[:weight].to_f)
+               matrix[x+1, y+1] = weight
+               matrix[y+1, x+1] = weight if type == "graph"
+            end
+         }
+
+         return matrix
+      end    
+
+      def degree_matrix
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count )
+         @graph.each_node do |name, node|
+            i = node.index
+            matrix[i+1, i+1] = degree(node)
+         end
+         return matrix
+      end
+
+      def range_recursion(matrix, unseen, result, r)
+         remove = []
+         matrix.columns.times do |c|
+            if matrix.sum_of_column(c+1) == 0
+               result[unseen[c]-1] = r
+               remove.unshift( c + 1 )
+            end
+         end
+
+         remove.each do |rem|
+            matrix = matrix.remove_line(rem).remove_column(rem)
+            unseen.delete_at(rem-1)
+         end
+
+         if matrix.columns == 1 and matrix.lines == 1
+            if matrix.sum_of_column(1) == 0
+               result[unseen[0]-1] = r+1
+            end
+         elsif remove.size > 0
+            range_recursion( matrix, unseen, result, r+1 )
+         end
+
+         return result
+      end
+
+      def index_of_item( array, item )
+         array.inject( [0,[]] ){|a,i|
+            a[1] << a[0] if i == item
+            a[0] += 1
+            a
+         }[1]
+      end
+
+      def critical_path_recursion( d, a, r, result, level )
+         r.each do |p|
+            node = p[1][-1]
+            index_of_item( a.line(node), 1 ).each do |c|
+               succ = c+1
+
+               cpath = [ (p[0] + d[node,succ]), (p[1].clone << succ) ]
+
+               if index_of_item( a.line(succ), 1 ).size > 0
+                  capth = critical_path_recursion( d, a, [cpath], result, level+1 )
+               else
+                  result << cpath
+               end          
+            end
+         end
+         return result
+      end
+   end
+end