plexus 0.5.4 → 0.5.5

data/lib/plexus/strong_components.rb

@@ -0,0 +1,93 @@
+module Plexus
+  module StrongComponents
+    # strong_components computes the strongly connected components
+    # of a graph using Tarjan's algorithm based on DFS. See: Robert E. Tarjan
+    # _Depth_First_Search_and_Linear_Graph_Algorithms_. SIAM Journal on 
+    # Computing, 1(2):146-160, 1972
+    #
+    # The output of the algorithm is an array of components where is 
+    # component is an array of vertices
+    #
+    # A strongly connected component of a directed graph G=(V,E) is a maximal
+    # set of vertices U which is in V such that for every pair of 
+    # vertices u and v in U, we have both a path from u to v 
+    # and path from v to u. That is to say that u and v are reachable 
+    # from each other.
+    #
+    def strong_components
+      dfs_num    = 0
+      stack = []; result = []; root = {}; comp = {}; number = {}
+
+      # Enter vertex callback
+      enter = Proc.new do |v| 
+        root[v] = v
+        comp[v] = :new
+        number[v] = (dfs_num += 1)
+        stack.push(v)
+      end
+
+      # Exit vertex callback
+      exit  = Proc.new do |v|
+        adjacent(v).each do |w|
+          if comp[w] == :new
+            root[v] = (number[root[v]] < number[root[w]] ? root[v] : root[w])
+          end
+        end
+        if root[v] == v
+          component = []
+          begin
+            w = stack.pop
+            comp[w] = :assigned
+            component << w
+          end until w == v
+          result << component
+        end
+      end
+
+      # Execute depth first search
+      dfs({:enter_vertex => enter, :exit_vertex => exit}); result
+
+    end # strong_components
+
+    # Returns a condensation graph of the strongly connected components
+    # Each node is an array of nodes from the original graph
+    def condensation
+      sc  = strong_components
+      cg  = DirectedMultiGraph.new
+      map = sc.inject({}) do |a,c| 
+        c.each {|v| a[v] = c }; a
+      end
+      sc.each do |c|
+        c.each do |v|
+          adjacent(v).each {|v1| cg.add_edge!(c, map[v1]) unless cg.edge?(c, map[v1]) }
+        end
+      end; 
+      cg
+    end
+
+    # Compute transitive closure of a graph. That is any node that is reachable
+    # along a path is added as a directed edge.
+    def transitive_closure!
+      cgtc = condensation.plexus_inner_transitive_closure!
+      cgtc.each do |cgv|
+        cgtc.adjacent(cgv).each do |adj|
+          cgv.each do |u| 
+            adj.each {|v| add_edge!(u,v)}  
+          end
+        end
+      end; self
+    end
+
+    # This returns the transitive closure of a graph. The original graph
+    # is not changed.
+    def transitive_closure() self.class.new(self).transitive_closure!; end
+
+    def plexus_inner_transitive_closure!  # :nodoc:
+      sort.reverse.each do |u| 
+        adjacent(u).each do |v|
+          adjacent(v).each {|w| add_edge!(u,w) unless edge?(u,w)}
+        end
+      end; self
+    end
+  end # StrongComponents
+end # Plexus

data/lib/plexus/support/support.rb

@@ -0,0 +1,9 @@
+module Plexus
+  # Errors
+  # TODO FIXME: must review all raise lines and streamline things
+  
+  # Base error class for the library.
+  class PlexusError < StandardError; end
+  
+  class NoArcError < PlexusError; end
+end

data/lib/plexus/undirected_graph.rb

@@ -0,0 +1,56 @@
+module Plexus
+  module UndirectedGraphBuilder
+    autoload :Algorithms, "plexus/undirected_graph/algorithms"
+
+    include Plexus::GraphBuilder
+    extends_host
+
+    module ClassMethods
+      def [](*a)
+        self.new.from_array(*a)
+      end
+    end
+
+    def initialize(*params)
+      args = (params.pop if params.last.kind_of? Hash) || {}
+      args[:algorithmic_category] = Plexus::UndirectedGraphBuilder::Algorithms
+      super *(params << args)
+    end
+  end
+
+  # This is a Digraph that allows for parallel edges, but does not allow loops.
+  module UndirectedPseudoGraphBuilder
+    include UndirectedGraphBuilder
+    extends_host
+
+    module ClassMethods
+      def [](*a)
+        self.new.from_array(*a)
+      end
+    end
+
+    def initialize(*params)
+      args = (params.pop if params.last.kind_of? Hash) || {}
+      args[:parallel_edges] = true
+      super *(params << args)
+    end
+  end
+
+  # This is a Digraph that allows for parallel edges and loops.
+  module UndirectedMultiGraphBuilder
+    include UndirectedPseudoGraphBuilder
+    extends_host
+
+    module ClassMethods
+      def [](*a)
+        self.new.from_array(*a)
+      end
+    end
+
+    def initialize(*params)
+      args = (params.pop if params.last.kind_of? Hash) || {}
+      args[:loops] = true
+      super *(params << args)
+    end
+  end
+end

data/lib/plexus/undirected_graph/algorithms.rb

@@ -0,0 +1,90 @@
+module Plexus
+  module UndirectedGraphBuilder
+    module Algorithms
+
+      include Search
+      include Biconnected
+      include Comparability
+
+      # UndirectedGraph is by definition undirected, always returns false
+      def directed?()  false; end
+
+      # Redefine degree (default was sum)
+      def degree(v)    in_degree(v); end
+
+      # A vertex of an undirected graph is balanced by definition
+      def balanced?(v)  true;  end
+
+      # UndirectedGraph uses Edge for the edge class.
+      def edge_class() @parallel_edges ? Plexus::MultiEdge : Plexus::Edge; end
+
+      def remove_edge!(u, v=nil)
+        unless u.kind_of? Plexus::Arc
+          raise ArgumentError if @parallel_edges 
+          u = edge_class[u,v]
+        end
+        super(u.reverse) unless u.source == u.target
+        super(u)
+      end
+
+      # A triangulated graph is an undirected perfect graph that every cycle of length greater than
+      # three possesses a chord. They have also been called chordal, rigid circuit, monotone transitive,
+      # and perfect elimination graphs.
+      #
+      # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
+      # Perfect Graphs" pg. 90
+      def triangulated?
+        a = Hash.new {|h,k| h[k]=Set.new}; sigma=lexicograph_bfs
+        inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
+        sigma[0..-2].each do |v|
+          x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
+          unless x.empty?
+            u = sigma[x.map {|y| inv_sigma[y]}.min]
+            a[u].merge(x - [u])
+          end
+          return false unless a[v].all? {|z| adjacent?(v,z)}
+        end
+        true
+      end
+
+      def chromatic_number
+        return triangulated_chromatic_number if triangulated?
+        raise NotImplementedError    
+      end
+
+      # An interval graph can have its vertices into one-to-one
+      # correspondence with a set of intervals F of a linearly ordered
+      # set (like the real line) such that two vertices are connected
+      # by an edge of G if and only if their corresponding intervals
+      # have nonempty intersection.
+      def interval?() triangulated? and complement.comparability?; end
+
+      # A permutation diagram consists of n points on each of two parallel
+      # lines and n straight line segments matchin the points. The intersection
+      # graph of the line segments is called a permutation graph.
+      def permutation?() comparability? and complement.comparability?; end
+
+      # An undirected graph is defined to be split if there is a partition
+      # V = S + K of its vertex set into a stable set S and a complete set K.    
+      def split?() triangulated? and complement.triangulated?; end
+
+      private
+      # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
+      # Perfect Graphs" pg. 99
+      def triangulated_chromatic_number
+        chi = 1; s= Hash.new {|h,k| h[k]=0}
+        sigma=lexicograph_bfs
+        inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
+        sigma.each do |v|
+          x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
+          unless x.empty?
+            u = sigma[x.map {|y| inv_sigma[y]}.min]
+            s[u] = [s[u], x.size-1].max
+            chi = [chi, x.size+1].max if s[v] < x.size
+          end
+        end; chi
+      end
+
+    end # UndirectedGraphAlgorithms
+  end # UndirectedGraphBuilder
+end # Plexus

data/lib/plexus/version.rb

@@ -0,0 +1,6 @@
+module Plexus
+  MAJOR = 0
+  MINOR = 5
+  PATCH = 5
+  VERSION = [MAJOR, MINOR, PATCH].join('.')
+end

data/spec/biconnected_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Biconnected" do # :nodoc:
+  describe "tarjan" do
+    it do
+      tarjan = UndirectedGraph[ 1, 2,
+                                1, 5,
+                                1, 6, 
+                                1, 7,
+                                2, 3, 
+                                2, 4,
+                                3, 4,
+                                2, 5,
+                                5, 6,
+                                7, 8,
+                                7, 9,
+                                8, 9 ]
+      graphs, articulations = tarjan.biconnected
+      articulations.sort.should == [1,2,7]
+      graphs.size.should == 4
+      graphs.find {|g| g.size == 2}.vertices.sort.should == [1,7]
+      graphs.find {|g| g.size == 4}.vertices.sort.should == [1,2,5,6]
+      graphs.find {|g| g.size == 3 && g.vertex?(2)}.vertices.sort.should == [2,3,4]
+      graphs.find {|g| g.size == 3 && g.vertex?(7)}.vertices.sort.should == [7,8,9]
+    end
+  end
+end

data/spec/chinese_postman_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "ChinesePostman" do # :nodoc:
+
+  before do  
+    @simple=Digraph[ 0,1,  0,2,  1,2,  1,3,  2,3,  3,0 ]
+    @weight = Proc.new {|e| 1}
+  end
+  
+  describe "closed_simple_tour" do
+    it do
+      tour = @simple.closed_chinese_postman_tour(0, @weight)
+      tour.size.should == 11
+      tour[0].should == 0
+      tour[10].should == 0
+      edges = Set.new
+      0.upto(9) do |n| 
+        edges << Arc[tour[n],tour[n+1]]
+        @simple.edge?(tour[n],tour[n+1]).should be_true
+      end
+      edges.size.should == @simple.edges.size
+    end
+    
+  end
+  
+  
+end

data/spec/community_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Community" do # :nodoc:
+  before do
+    @graph = Digraph[2,1, 3,1, 5,4, 6,5, 7,6, 7,2].add_vertex!(8)
+  end
+  
+  describe "ancestors_must_return_ancestors" do
+    it do
+      @graph.ancestors(1).sort.should == [2,3,7]
+      @graph.ancestors(2).sort.should == [7]
+      @graph.ancestors(3).sort.should == []
+      @graph.ancestors(4).sort.should == [5,6,7]
+      @graph.ancestors(5).sort.should == [6,7]
+      @graph.ancestors(6).sort.should == [7]
+      @graph.ancestors(7).sort.should == []
+    end
+  end
+  
+  describe "descendants_must_return_descendants" do
+    it do
+      @graph.descendants(1).sort.should == []
+      @graph.descendants(2).sort.should == [1]
+      @graph.descendants(3).sort.should == [1]
+      @graph.descendants(4).sort.should == []
+      @graph.descendants(5).sort.should == [4]
+      @graph.descendants(6).sort.should == [4,5]
+      @graph.descendants(7).sort.should == [1,2,4,5,6]
+    end
+  end
+  
+  describe "family_must_return_family" do
+    it do
+      @graph.family(1).sort.should == [2,3,4,5,6,7]
+      @graph.family(2).sort.should == [1,3,4,5,6,7]
+      @graph.family(3).sort.should == [1,2,4,5,6,7]
+      @graph.family(4).sort.should == [1,2,3,5,6,7]
+      @graph.family(5).sort.should == [1,2,3,4,6,7]
+      @graph.family(6).sort.should == [1,2,3,4,5,7]
+      @graph.family(7).sort.should == [1,2,3,4,5,6]
+    end
+  end
+  
+end

data/spec/complement_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Complement" do # :nodoc:
+  
+  describe "square" do
+    it do
+      x = UndirectedGraph[:a,:b, :b,:c, :c,:d, :d,:a].complement
+      x.edges.size.should == 2
+      x.edges.include?(Edge[:a,:c]).should be_true
+      x.edges.include?(Edge[:b,:d]).should be_true
+    end
+  end
+  
+  describe "g1" do
+    it do
+      g1 = UndirectedGraph[ :a,:b, :a,:d, :a,:e, :a,:i, :a,:g, :a,:h,
+                            :b,:c, :b,:f,
+                            :c,:d, :c,:h,
+                            :d,:h, :d,:e,
+                            :e,:f,
+                            :f,:g, :f,:h, :f,:i,
+                            :h,:i ].complement
+      g1.edges.size.should == 19
+    end
+  end
+
+end

data/spec/digraph_distance_spec.rb

@@ -0,0 +1,121 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "DigraphDistance" do # :nodoc:
+
+  before do  
+    @d = Digraph[ :a,:b, :a,:e,
+                  :b,:c, :b,:e,
+                  :c,:d,
+                  :d,:c,
+                  :e,:b, :e,:f,
+                  :f,:c, :f,:d, :f,:e ]
+    
+    @w = {  Arc[:a,:b] => 9,
+      Arc[:a,:e] => 3,
+      Arc[:b,:c] => 2,
+      Arc[:b,:e] => 6,
+      Arc[:c,:d] => 1,
+      Arc[:d,:c] => 2,
+      Arc[:e,:b] => 2,
+      Arc[:e,:f] => 1,
+      Arc[:f,:c] => 2,
+      Arc[:f,:d] => 7,
+      Arc[:f,:e] => 2  }
+    @a = {  :a => 0,
+      :b => 5,
+      :c => 6,
+      :d => 7,
+      :e => 3,
+      :f => 4   }
+    @simple_weight = Proc.new {|e| 1}            
+  end
+  
+  describe "shortest_path" do
+    it do
+      x = Digraph[ :s,:u, :s,:w,
+                   :j,:v,
+                   :u,:j,
+                   :v,:y,
+                   :w,:u, :w,:v, :w,:y, :w,:x,
+                   :x,:z ]
+      x.should be_acyclic
+      cost, path = x.shortest_path(:s,@simple_weight)
+      cost.should == {:x=>2, :v=>2, :y=>2, :w=>1, :s=>0, :z=>3, :u=>1, :j=> 2}
+      path.should == {:x=>:w, :v=>:w, :y=>:w, :w=>:s, :z=>:x, :u=>:s, :j=>:u}
+    end
+  end
+  
+  describe "dijkstra_with_proc" do
+    it do
+      p = Proc.new {|e| @w[e]}
+      distance, path = @d.dijkstras_algorithm(:a,p)
+      distance.should == @a
+      path.should == { :d => :c,  :c => :f,  :f => :e,  :b => :e,  :e => :a}
+    end
+  end
+  
+  describe "dijkstra_with_label" do
+    it do
+      @w.keys.each {|e| @d[e] = @w[e]}
+      @d.dijkstras_algorithm(:a)[0].should == @a
+    end
+  end
+
+  describe "dijkstra_with_bracket_label" do
+    it do
+      @w.keys.each do |e|
+        @d[e] = {:xyz => (@w[e])} 
+      end
+      @d.dijkstras_algorithm(:a, :xyz)[0].should == @a
+      @w.keys.each do |e|
+        @d[e] = [@w[e]] 
+      end
+      @d.dijkstras_algorithm(:a, 0)[0].should == @a
+    end
+  end
+  
+  describe "floyd_warshall" do
+    it do
+      simple = Digraph[ 0,1,  0,2,  1,2,  1,3,  2,3,  3,0 ]
+      
+      cost, path, delta = simple.floyd_warshall(@simple_weight)
+      # Costs
+      cost[0].should == {0=>3, 1=>1, 2=>1, 3=>2}
+      cost[1].should == {0=>2, 1=>3, 2=>1, 3=>1}
+      cost[2].should == {0=>2, 1=>3, 2=>3, 3=>1}
+      cost[3].should == {0=>1, 1=>2, 2=>2, 3=>3}
+      
+      # Paths
+      path[0].should == {0=>1, 1=>1, 2=>2, 3=>1}
+      path[1].should == {0=>3, 1=>3, 2=>2, 3=>3}
+      path[2].should == {0=>3, 1=>3, 2=>3, 3=>3}
+      path[3].should == {0=>0, 1=>0, 2=>0, 3=>0}
+      
+      # Deltas
+      delta[0].should == 1
+      delta[1].should == 1
+      delta[2].should == -1
+      delta[3].should == -1
+    end
+  end
+  
+  describe "bellman_ford_moore" do
+    it do
+      fig24 = Digraph[ [:s,:e] =>  8,
+                       [:s,:d] =>  4,
+                       [:e,:c] =>  2,
+                       [:e,:d] => -5,
+                       [:c,:b] => -2,
+                       [:d,:c] => -2,
+                       [:d,:a] =>  4,
+                       [:a,:c] => 10,
+                       [:a,:b] =>  9,
+                       [:b,:c] =>  5,
+                       [:b,:a] => -3]
+      cost, path = fig24.bellman_ford_moore(:s)
+      cost.should == {:e=>8, :d=>3, :c=>1, :b=>-1, :a=>-4, :s=>0}
+      path.should == {:e=>:s, :d=>:e, :c=>:d, :b=>:c, :a=>:b}
+    end
+  end
+  
+end