ruby-graphviz 0.9.16 → 0.9.17

data/lib/graphviz/math/matrix.rb

@@ -0,0 +1,221 @@
+class GraphViz
+  class Math
+    def self.Matrix( line, column = 0, val = 0 )
+      GraphViz::Math::Matrix.new(line, column, val)
+    end
+    
+    class CoordinateError < RuntimeError
+    end
+    class ValueError < RuntimeError
+    end
+    
+    class Matrix
+      def initialize( line_or_array, column = 0, val = 0 )
+        if line_or_array.kind_of?(Array)
+          line = line_or_array.size
+          column = nil
+          line_or_array.size.times do |l|
+            unless line_or_array[l].kind_of?(Array)
+              raise ArgumentError, "Wrong matrix definition"
+            end
+            column = line_or_array[l].size if column.nil?
+            unless line_or_array[l].size == column
+              raise ArgumentError, "Wrong matrix definition"
+            end
+            line_or_array[l].size.times do |c|
+              unless line_or_array[l][c].kind_of?(Numeric)
+                raise ValueError, "Element at [#{l+1}, #{c+1}] is not a number"
+              end
+            end
+          end 
+
+          @matrix = line_or_array
+          @line = line
+          @column = column
+        elsif line_or_array.kind_of?(Integer) and column > 0
+          @matrix = Array.new(line_or_array)
+          @matrix.size.times do |l|
+            @matrix[l] = Array.new(column)
+            @matrix[l].size.times do |c|
+              @matrix[l][c] = val
+            end
+          end
+          @line = line_or_array
+          @column = column
+        else
+          raise ArgumentError, "Wrong matrix definition"
+        end
+      end      
+            
+      def [](line, column)
+        unless (0...@line).to_a.include?(line-1)
+          raise CoordinateError, "Line out of range (#{line} for 1..#{@line})!"
+        end
+        unless (0...@column).to_a.include?(column-1)
+          raise CoordinateError, "Column out of range (#{column} for 1..#{@column})!"
+        end
+        @matrix[line-1][column-1]
+      end
+      
+      def []=( line, column, val )
+        unless (0...@line).to_a.include?(line-1)
+          raise CoordinateError, "Line out of range (#{line} for 1..#{@line})!"
+        end
+        unless (0...@column).to_a.include?(column-1)
+          raise CoordinateError, "Column out of range (#{column} for 1..#{@column})!"
+        end
+        @matrix[line-1][column-1] = val
+      end
+      
+      def matrix
+        @matrix
+      end
+      alias :to_a :matrix
+      
+      def columns
+        @column
+      end
+      
+      def lines
+        @line
+      end
+      
+      def to_s
+        size = bigger
+        out = ""
+        @line.times do |line|
+          out << "["
+          @column.times do |column|
+            out << sprintf(" %1$*2$s", @matrix[line][column].to_s, size)
+          end
+          out << "]\n"
+        end
+        return out
+      end
+      
+      def -(m)
+        matrix = GraphViz::Math::Matrix.new( @line, @column )
+        @line.times do |line|
+          @column.times do |column|
+            matrix[line+1, column+1] = self[line+1, column+1] - m[line+1, column+1]
+          end
+        end
+        return matrix
+      end
+      
+      def *(m)
+        matrix = GraphViz::Math::Matrix.new( @line, @line )
+        
+        @line.times do |line|
+          @line.times do |column|
+            l = self.line(line+1)
+            c = m.column(column+1)
+            v = 0
+            l.size.times do |i|
+              v += l[i]*c[i]
+            end
+            matrix[line+1,column+1] = v
+          end
+        end
+        
+        return matrix
+      end
+      
+      def line( line )
+        unless (0...@line).to_a.include?(line-1)
+          raise CoordinateError, "Line out of range (#{line} for 1..#{@line})!"
+        end
+        @matrix[line-1]
+      end
+      
+      def column( column )
+        col = []
+        unless (0...@column).to_a.include?(column-1)
+          raise CoordinateError, "Column out of range (#{column} for 1..#{@column})!"
+        end
+        @line.times do |line|
+          col << self[line+1, column]
+        end
+        
+        return col
+      end
+      
+      def transpose
+        matrix = GraphViz::Math::Matrix.new( @column, @line )
+        @line.times do |line|
+          @column.times do |column|
+            matrix[column+1, line+1] = self[line+1, column+1]
+          end
+        end
+        return matrix
+      end
+      
+      def ==(m)
+        equal = true
+        @line.times do |line|
+          @column.times do |column|
+            equal &&= (m[line+1, column+1] == self[line+1, column+1])
+          end
+        end
+        return equal
+      end
+      
+      def remove_line(n)
+        unless (0...@line).to_a.include?(n-1)
+          raise CoordinateError, "Line out of range (#{n} for 1..#{@line})!"
+        end
+
+        matrix = GraphViz::Math::Matrix.new( @line - 1, @column )
+        nline = 0
+        @line.times do |line|
+          next if line == n - 1
+          @column.times do |column|
+            matrix[nline+1, column+1] = self[line+1, column+1]
+          end
+          nline += 1
+        end
+        return matrix
+      end
+      
+      def remove_column(n)
+        unless (0...@column).to_a.include?(n-1)
+          raise CoordinateError, "Column out of range (#{n} for 1..#{@column})!"
+        end
+
+        matrix = GraphViz::Math::Matrix.new( @line, @column - 1 )
+        @line.times do |line|
+          ncolumn = 0
+          @column.times do |column|
+            next if column == n - 1
+            matrix[line+1, ncolumn+1] = self[line+1, column+1]
+            ncolumn += 1
+          end
+        end
+        return matrix
+      end
+      
+      def sum_of_column(n)
+        column(n).inject(0){|sum,item| sum + item}
+      end
+      
+      def sum_of_line(n)
+        line(n).inject(0){|sum,item| sum + item}
+      end
+
+      def set_matrix(m) #:nodoc:
+        @matrix = m
+      end
+
+      private
+      def bigger
+        b = 0
+        @matrix.each do |line|
+          line.each do |column|
+            b = column.to_s.size if column.to_s.size > b
+          end
+        end
+        return b
+      end
+    end
+  end
+end

data/lib/graphviz/node.rb

@@ -35,6 +35,7 @@ class GraphViz
       @xNodeName = xNodeName
       @oGParrent = oGParrent
       @oAttrNode = GraphViz::Attrs::new( nil, "node", NODESATTRS )
+      @index = nil
     end
 
     # 
@@ -51,6 +52,16 @@ class GraphViz
     def id
 	    @xNodeName.clone
 	  end
+	  
+	  #
+	  # Return the index of the node
+	  #
+	  def index
+	    @index
+    end
+    def index=(i) #:nodoc:
+      @index = i if @index == nil
+    end
 	
 	  # 
     # Set value +xAttrValue+ to the node attribut +xAttrName+

data/lib/graphviz/theory.rb

@@ -0,0 +1,252 @@
+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