jumoku 0.2.0 → 0.2.1

data/vendor/git/plexus/lib/plexus/strong_components.rb

@@ -1,93 +0,0 @@
-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/vendor/git/plexus/lib/plexus/support/support.rb

@@ -1,9 +0,0 @@
-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/vendor/git/plexus/lib/plexus/undirected_graph.rb

@@ -1,56 +0,0 @@
-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/vendor/git/plexus/lib/plexus/undirected_graph/algorithms.rb

@@ -1,90 +0,0 @@
-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/vendor/git/plexus/lib/plexus/version.rb

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

data/vendor/git/plexus/plexus.gemspec

@@ -1,24 +0,0 @@
-# -*- encoding: utf-8 -*-
-require './lib/plexus/version'
-
-Gem::Specification.new do |s|
-  s.name = %q{plexus}
-  s.version = Plexus::VERSION
-  s.authors = ["Bruce Williams", "Jean-Denis Vauguet <jd@vauguet.fr>"]
-  s.summary = "A framework for graph data structures and algorithms."
-  s.description = %q{This library is based on GRATR and RGL.
-
-Graph algorithms currently provided are:
-
-* Topological Sort
-* Strongly Connected Components
-* Transitive Closure
-* Rural Chinese Postman
-* Biconnected
-}
-  s.email = %q{bruce@codefluency.com}
-  s.add_dependency "facets"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "yard"
-end
-

data/vendor/git/plexus/spec/biconnected_spec.rb

@@ -1,27 +0,0 @@
-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/vendor/git/plexus/spec/chinese_postman_spec.rb

@@ -1,27 +0,0 @@
-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/vendor/git/plexus/spec/community_spec.rb

@@ -1,44 +0,0 @@
-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/vendor/git/plexus/spec/complement_spec.rb

@@ -1,27 +0,0 @@
-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/vendor/git/plexus/spec/digraph_distance_spec.rb

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