jumoku 0.1.1 → 0.1.2

data/vendor/git/graphy/lib/graphy.rb

@@ -0,0 +1,90 @@
+#--
+# 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 'set'
+
+module Graphy
+  # Graphy internals: graph builders and additionnal behaviors
+  autoload :GraphAPI,                     'graphy/graph_api'
+
+  autoload :GraphBuilder,                 'graphy/graph'
+  autoload :AdjacencyGraphBuilder,        'graphy/adjacency_graph'
+
+  autoload :DirectedGraphBuilder,         'graphy/directed_graph'
+  autoload :DigraphBuilder,               'graphy/directed_graph'
+  autoload :DirectedPseudoGraphBuilder,   'graphy/directed_graph'
+  autoload :DirectedMultiGraphBuilder,    'graphy/directed_graph'
+
+  autoload :UndirectedGraphBuilder,       'graphy/undirected_graph'
+  autoload :UndirectedPseudoGraphBuilder, 'graphy/undirected_graph'
+  autoload :UndirectedMultiGraphBuilder,  'graphy/undirected_graph'
+
+  autoload :Arc,                          'graphy/arc'
+  autoload :ArcNumber,                    'graphy/arc_number'
+  autoload :Biconnected,                  'graphy/biconnected'
+  autoload :ChinesePostman,               'graphy/chinese_postman'
+  autoload :Common,                       'graphy/common'
+  autoload :Comparability,                'graphy/comparability'
+  
+  autoload :Dot,                          'graphy/dot'
+  autoload :Edge,                         'graphy/edge'
+  autoload :Labels,                       'graphy/labels'
+  autoload :MaximumFlow,                  'graphy/maximum_flow'
+  #autoload :Rdot,                        'graphy/dot'
+  autoload :Search,                       'graphy/search'
+  autoload :StrongComponents,             'graphy/strong_components'
+
+  # Graphy classes
+  autoload :AdjacencyGraph,               'graphy/classes/graph_classes'
+  autoload :DirectedGraph,                'graphy/classes/graph_classes'
+  autoload :Digraph,                      'graphy/classes/graph_classes'
+  autoload :DirectedPseudoGraph,          'graphy/classes/graph_classes'
+  autoload :DirectedMultiGraph,           'graphy/classes/graph_classes'
+  autoload :UndirectedGraph,              'graphy/classes/graph_classes'
+  autoload :UndirectedPseudoGraph,        'graphy/classes/graph_classes'
+  autoload :UndirectedMultiGraph,         'graphy/classes/graph_classes'
+
+  # ruby stdlib extensions
+  require 'graphy/ext'
+  # ruby 1.8.x/1.9.x compatibility
+  require 'graphy/ruby_compatibility'
+end
+
+# Vendored libraries
+
+require 'pathname'
+path = Pathname.new(__FILE__)
+$LOAD_PATH.unshift(path + '../../vendor')
+$LOAD_PATH.unshift(path + '../../vendor/priority-queue/lib')
+
+require 'rdot'
+require 'facets/hash'
+
+require 'priority_queue/ruby_priority_queue'
+PriorityQueue = RubyPriorityQueue
+

data/vendor/git/graphy/lib/graphy/adjacency_graph.rb

@@ -0,0 +1,224 @@
+module Graphy
+
+  # This module provides the basic routines needed to implement the specialized builders:
+  # {DigraphBuilder}, {UndirectedGraphBuilder}, {DirectedPseudoGraphBuilder},
+  # {UndirectedPseudoGraphBuilder}, {DirectedMultiGraphBuilder} and {UndirectedMultiGraphBuilder}
+  # modules, each of them streamlining {AdjacencyGraphBuilder}'s behavior. Those
+  # implementations rely on the {GraphBuilder}, under the control of the {GraphAPI}.
+  module AdjacencyGraphBuilder
+
+    # Defines a useful `push` -> `add` alias for arrays.
+    class ArrayWithAdd < Array 
+      alias add push
+    end
+
+    # This method is called by the specialized implementations
+    # upon graph creation.
+    #
+    # Initialization parameters can include:
+    #
+    # * an array of edges to add
+    # * one or several graphs to copy (will be merged if multiple)
+    # * `:parallel_edges` denotes that duplicate edges are allowed
+    # * `:loops denotes` that loops are allowed
+    #
+    # @param *params [Hash] the initialization parameters
+    def implementation_initialize(*params)
+      @vertex_dict = Hash.new    
+      clear_all_labels
+
+      # FIXME: could definitely make use of the activesupport helper
+      # extract_options! and facets' reverse_merge! technique
+      # to handle parameters
+      args = (params.pop if params.last.is_a? Hash) || {}
+
+      # Basic configuration of adjacency.
+      @allow_loops    = args[:loops]          || false
+      @parallel_edges = args[:parallel_edges] || false
+      @edgelist_class = @parallel_edges ? ArrayWithAdd : Set
+      if @parallel_edges
+        @edge_number      = Hash.new
+        @next_edge_number = 0 
+      end
+
+      # Copy any given graph into this graph.
+      params.select { |p| p.is_a? Graphy::GraphBuilder }.each do |g|
+        g.edges.each do |e| 
+          add_edge!(e)
+          edge_label_set(e, edge_label(e)) if edge_label(e)
+        end
+        g.vertices.each do |v|
+          add_vertex!(v)
+          vertex_label_set(v, vertex_label(v)) if vertex_label(v)
+        end  
+      end
+
+      # Add all array edges specified.
+      params.select { |p| p.is_a? Array }.each do |a|
+        0.step(a.size-1, 2) { |i| add_edge!(a[i], a[i+1]) }
+      end
+    end
+
+    # Returns true if v is a vertex of this Graph
+    # (an "O(1)" implementation of `vertex?`).
+    #
+    # @param [vertex] v
+    # @return [Boolean]
+    def vertex?(v)
+      @vertex_dict.has_key?(v)
+    end
+
+    # Returns true if [u,v] or u is an {Arc}
+    # (an "O(1)" implementation of `edge?`).
+    #
+    # @param [vertex] u
+    # @param [vertex] v (nil)
+    # @return [Boolean]
+    def edge?(u, v = nil)
+      u, v = u.source, u.target if u.is_a? Graphy::Arc
+      vertex?(u) and @vertex_dict[u].include?(v)
+    end
+
+    # Adds a vertex to the graph with an optional label.
+    #
+    # @param [vertex(Object)] vertex any kind of Object can act as a vertex
+    # @param [#to_s] label (nil)
+    def add_vertex!(vertex, label = nil)
+      @vertex_dict[vertex] ||= @edgelist_class.new
+      self[vertex] = label if label
+      self
+    end
+
+    # Adds an edge to the graph.
+    # 
+    # Can be called in two basic ways, label is optional:
+    # @overload add_edge!(arc)
+    #   Using an explicit {Arc}
+    #   @param [Arc] arc an {Arc}[source, target, label = nil] object
+    #   @return [AdjacencyGraph] `self`
+    # @overload add_edge!(source, target, label = nil)
+    #   Using vertices to define an arc implicitly
+    #   @param [vertex] u
+    #   @param [vertex] v (nil)
+    #   @param [Label] l (nil)
+    #   @param [Integer] n (nil) {Arc arc} number of `(u, v)` (if `nil` and if `u`
+    #     has an {ArcNumber}, then it will be used)
+    #   @return [AdjacencyGraph] `self`
+    def add_edge!(u, v = nil, l = nil, n = nil)
+      n = u.number if u.class.include? ArcNumber and n.nil?
+      u, v, l = u.source, u.target, u.label if u.is_a? Graphy::Arc
+
+      return self if not @allow_loops and u == v
+
+      n = (@next_edge_number += 1) unless n if @parallel_edges
+      add_vertex!(u)
+      add_vertex!(v)
+      @vertex_dict[u].add(v)
+      (@edge_number[u] ||= @edgelist_class.new).add(n) if @parallel_edges
+
+      unless directed?
+        @vertex_dict[v].add(u)
+        (@edge_number[v] ||= @edgelist_class.new).add(n) if @parallel_edges
+      end
+
+      self[n ? edge_class[u,v,n] : edge_class[u,v]] = l if l
+      self
+    end
+
+    # Removes a given vertex from the graph.
+    #
+    # @param [vertex] v
+    # @return [AdjacencyGraph] `self`
+    def remove_vertex!(v)
+      # FIXME This is broken for multi graphs 
+      @vertex_dict.delete(v)
+      @vertex_dict.each_value { |adjList| adjList.delete(v) }
+      @vertex_dict.keys.each do |u| 
+        delete_label(edge_class[u,v]) 
+        delete_label(edge_class[v,u])
+      end
+      delete_label(v) 
+      self
+    end
+
+    # Removes an edge from the graph.
+    #
+    # Can be called with both source and target as vertex,
+    # or with source and object of {Graphy::Arc} derivation.
+    #
+    # @overload remove_edge!(a)
+    #   @param [Graphy::Arc] a
+    #   @return [AdjacencyGraph] `self`
+    #   @raise [ArgumentError] if parallel edges are enabled
+    # @overload remove_edge!(u, v)
+    #   @param [vertex] u
+    #   @param [vertex] v
+    #   @return [AdjacencyGraph] `self`
+    #   @raise [ArgumentError] if parallel edges are enabled and the {ArcNumber} of `u` is zero
+    def remove_edge!(u, v = nil)
+      unless u.is_a? Graphy::Arc
+        raise ArgumentError if @parallel_edges
+        u = edge_class[u,v]
+      end
+      raise ArgumentError if @parallel_edges and (u.number || 0) == 0
+      return self unless @vertex_dict[u.source] # It doesn't exist
+      delete_label(u) # Get rid of label
+      if @parallel_edges
+        index = @edge_number[u.source].index(u.number)
+        raise NoArcError unless index
+        @vertex_dict[u.source].delete_at(index)
+        @edge_number[u.source].delete_at(index) 
+      else
+        @vertex_dict[u.source].delete(u.target) 
+      end
+      self
+    end
+
+    # Returns an array of vertices that the graph has.
+    #
+    # @return [Array] graph's vertices
+    def vertices
+      @vertex_dict.keys
+    end
+
+    # Returns an array of edges, most likely of class {Arc} or {Edge} depending 
+    # upon the type of graph.
+    #
+    # @return [Array]
+    def edges
+      @vertex_dict.keys.inject(Set.new) do |a,v|
+        if @parallel_edges and @edge_number[v]
+          @vertex_dict[v].zip(@edge_number[v]).each do |w|
+            s, t, n = v, w[0], w[1]
+            a.add(edge_class[s, t, n, edge_label(s, t, n)])
+          end
+        else
+          @vertex_dict[v].each do |w|
+            a.add(edge_class[v, w, edge_label(v, w)])
+          end
+        end
+        a
+      end.to_a
+    end
+
+    # FIXME, EFFED UP (but why?)
+    #
+    # @fixme
+    def adjacent(x, options = {})
+      options[:direction] ||= :out
+      if !x.is_a?(Graphy::Arc) and (options[:direction] == :out || !directed?)
+        if options[:type] == :edges
+          i = -1
+          @parallel_edges ?
+            @vertex_dict[x].map { |v| e = edge_class[x, v, @edge_number[x][i+=1]]; e.label = self[e]; e } :
+            @vertex_dict[x].map { |v| e = edge_class[x, v];  e.label = self[e]; e }
+        else
+          @vertex_dict[x].to_a
+        end
+      else
+        graph_adjacent(x,options)
+      end
+    end
+
+  end # Adjacency Graph
+end # Graphy

data/vendor/git/graphy/lib/graphy/arc.rb

@@ -0,0 +1,65 @@
+module Graphy
+
+  # Arc includes classes for representing egdes of directed and
+  # undirected graphs. There is no need for a Vertex class, because any ruby
+  # object can be a vertex of a graph.
+  #
+  # Arc's base is a Struct with a :source, a :target and a :label
+  Struct.new("ArcBase", :source, :target, :label)
+
+  class Arc < Struct::ArcBase
+
+    def initialize(p_source, p_target, p_label = nil)
+      super(p_source, p_target, p_label)
+    end
+
+    # Ignore labels for equality.
+    def eql?(other)
+      self.class == other.class and target == other.target and source == other.source
+    end
+    alias == eql?
+
+    # Returns (v,u) if self == (u,v).
+    def reverse() self.class.new(target, source, label); end
+
+    # Sort support.
+    def <=>(rhs)
+      [source, target] <=> [rhs.source, rhs.target]
+    end
+
+    # Arc.new[1,2].to_s => "(1-2 'label')"
+    def to_s
+      l = label ? " '#{label.to_s}'" : ''
+      "(#{source}-#{target}#{l})"
+    end
+    
+    # Hash is defined in such a way that label is not
+    # part of the hash value
+    # FIXME: I had to get rid of that in order to make to_dot_graph
+    # work, but I can't figure it out (doesn't show up in the stack!)
+    #def hash
+      #puts "--- #{caller}"
+      ##puts source.inspect
+      ##puts target.inspect
+      #source.hash ^ (target.hash + 1)
+      #puts "---"
+    #end
+
+    # Shortcut constructor.
+    #
+    # Instead of Arc.new(1,2) one can use Arc[1,2].
+    def self.[](p_source, p_target, p_label = nil)
+      new(p_source, p_target, p_label)
+    end
+    
+    #def inspect
+      #"#{self.class.to_s}[#{source.inspect},#{target.inspect},#{label.inspect}]"
+    #end
+    
+  end # Arc
+  
+  class MultiArc < Arc
+    include ArcNumber
+  end
+
+end # Graphy

data/vendor/git/graphy/lib/graphy/arc_number.rb

@@ -0,0 +1,52 @@
+module Graphy
+  # This module handles internal numbering of edges in order to differente between mutliple edges.
+  module ArcNumber
+
+    # Used to differentiate between mutli-edges
+    attr_accessor :number
+    
+    def initialize(p_source, p_target, p_number, p_label = nil)
+      self.number = p_number 
+      super(p_source, p_target, p_label)
+    end
+
+    # Returns (v,u) if self == (u,v).
+    def reverse
+      self.class.new(target, source, number, label)
+    end
+    
+    # Allow for hashing of self loops.
+    def hash
+      super ^ number.hash
+    end
+
+    def to_s
+      super + "[#{number}]"
+    end
+
+    def <=>(rhs)
+      (result = super(rhs)) == 0 ? number <=> rhs.number : result
+    end 
+    
+    def inspect
+      "#{self.class.to_s}[#{source.inspect},#{target.inspect},#{number.inspect},#{label.inspect}]"
+    end
+
+    def eql?(rhs)
+      super(rhs) and (rhs.number.nil? or number.nil? or number == rhs.number)
+    end
+
+    def ==(rhs)
+      eql?(rhs)
+    end
+
+    # Shortcut constructor. Instead of Arc.new(1,2) one can use Arc[1,2]
+    def self.included(cl)
+      # FIXME: lacks a cl.class_eval, no?
+      def cl.[](p_source, p_target, p_number = nil, p_label = nil)
+        new(p_source, p_target, p_number, p_label)
+      end
+    end
+
+  end # ArcNumber
+end # Graphy

data/vendor/git/graphy/lib/graphy/biconnected.rb

@@ -0,0 +1,84 @@
+module Graphy
+
+  # Biconnected is a module for adding the biconnected algorithm to 
+  # UndirectedGraphs
+  module Biconnected
+
+    # biconnected computes the biconnected subgraphs
+    # 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 a pair, the first value is an 
+    # array of biconnected subgraphs. The second is the set of
+    # articulation vertices.
+    #
+    # A connected graph is biconnected if the removal of any single vertex 
+    # (and all edges incident on that vertex) cannot disconnect the graph.
+    # More generally, the biconnected components of a graph are the maximal
+    # subsets of vertices such that the removal of a vertex from a particular
+    # component will not disconnect the component. Unlike connected components,
+    # vertices may belong to multiple biconnected components: those vertices
+    # that belong to more than one biconnected component are called articulation
+    # points or, equivalently, cut vertices. Articulation points are vertices
+    # whose removal would increase the number of connected components in the graph.
+    # Thus, a graph without articulation points is biconnected.
+    def biconnected
+      dfs_num     = 0
+      number      = {}; predecessor = {}; low_point   = {}
+      stack       = []; result      = []; articulation= []
+
+      root_vertex  = Proc.new {|v| predecessor[v]=v }
+      enter_vertex = Proc.new {|u| number[u]=low_point[u]=(dfs_num+=1) }
+      tree_edge  = Proc.new do |e|
+        stack.push(e)
+        predecessor[e.target] = e.source
+      end
+      back_edge  = Proc.new do |e|
+        if e.target != predecessor[e.source]
+          stack.push(e)
+          low_point[e.source] = [low_point[e.source], number[e.target]].min
+        end
+      end
+      exit_vertex = Proc.new do |u|
+        parent = predecessor[u]
+        is_articulation_point = false
+        if number[parent] > number[u]
+          parent = predecessor[parent]
+          is_articulation_point = true
+        end
+        if parent == u
+          is_articulation_point = false if (number[u] + 1) == number[predecessor[u]]
+        else
+          low_point[parent] = [low_point[parent], low_point[u]].min
+          if low_point[u] >= number[parent]
+            if number[parent] > number[predecessor[parent]]
+              predecessor[u] = predecessor[parent]
+              predecessor[parent] = u
+            end
+            result << (component = self.class.new)
+            while number[stack[-1].source] >= number[u]
+              component.add_edge!(stack.pop)
+            end
+            component.add_edge!(stack.pop)
+            if stack.empty?
+              predecessor[u] = parent
+              predecessor[parent] = u
+            end
+          end
+        end
+        articulation << u if is_articulation_point
+      end
+
+      # Execute depth first search
+      dfs({:root_vertex  => root_vertex,
+           :enter_vertex => enter_vertex, 
+           :tree_edge    => tree_edge,
+           :back_edge    => back_edge,
+           :exit_vertex  => exit_vertex})
+         
+      [result, articulation]
+    end # biconnected
+
+  end # Biconnected
+end # Graphy