jumoku 0.1.1 → 0.1.2

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

@@ -0,0 +1,91 @@
+module Graphy
+  module ChinesePostman    
+
+    # Returns the shortest walk that traverses all arcs at least
+    # once, returning to the specified start node.
+    def closed_chinese_postman_tour(start, weight=nil, zero=0)
+      cost, path, delta = floyd_warshall(weight, zero)
+      return nil unless cp_valid_least_cost? cost, zero
+      positive, negative = cp_unbalanced(delta)
+      f = cp_find_feasible(delta, positive, negative, zero)
+      while cp_improve(f, positive, negative, cost, zero); end
+      cp_euler_circuit(start, f, path)
+    end
+
+    private
+
+    def cp_euler_circuit(start, f, path) # :nodoc:
+      circuit = [u=v=start]
+      bridge_taken = Hash.new {|h,k| h[k] = Hash.new}
+      until v.nil?
+        if v=f[u].keys.detect {|k| f[u][k] > 0}
+          f[u][v] -= 1
+          circuit << (u = path[u][v]) while u != v 
+        else
+          unless bridge_taken[u][bridge = path[u][start]]
+            v = vertices.detect {|v1| v1 != bridge && edge?(u,v1) && !bridge_taken[u][v1]} || bridge
+            bridge_taken[u][v] = true
+            circuit << v            
+          end
+        end  
+        u=v
+      end; circuit
+    end
+
+    def cp_cancel_cycle(cost, path, f, start, zero) # :nodoc:
+      u = start; k = nil
+      begin
+        v = path[u][start]
+        k = f[v][u] if cost[u][v] < zero and (k.nil? || k > f[v][u])
+      end until (u=v) != start
+      u = start
+      begin
+        v = path[u][start]
+        cost[u][v] < zero ? f[v][u] -= k : f[u][v] += k
+      end until (u=v) != start
+      true # This routine always returns true to make cp_improve easier
+    end
+
+    def cp_improve(f, positive, negative, cost, zero) # :nodoc:
+      residual = self.class.new
+      negative.each do |u|
+        positive.each do |v|
+          residual.add_edge!(u,v,cost[u][v])
+          residual.add_edge!(v,u,-cost[u][v]) if f[u][v] != 0
+        end
+      end
+      r_cost, r_path, r_delta = residual.floyd_warshall(nil, zero)
+      i = residual.vertices.detect {|v| r_cost[v][v] and r_cost[v][v] < zero}
+      i ? cp_cancel_cycle(r_cost, r_path, f, i) : false
+    end
+
+    def cp_find_feasible(delta, positive, negative, zero) # :nodoc:
+      f = Hash.new {|h,k| h[k] = Hash.new}
+      negative.each do |i|
+        positive.each do |j|
+          f[i][j] = -delta[i] < delta[j] ? -delta[i] : delta[j]
+          delta[i] += f[i][j]
+          delta[j] -= f[i][j]
+        end
+      end; f
+    end
+
+    def cp_valid_least_cost?(c, zero) # :nodoc:
+      vertices.each do |i|
+        vertices.each do |j|
+          return false unless c[i][j] and c[i][j] >= zero
+        end
+      end; true
+    end
+
+    def cp_unbalanced(delta) # :nodoc:
+      negative = []; positive = []
+      vertices.each do |v|
+        negative << v if delta[v] < 0
+        positive << v if delta[v] > 0
+      end; [positive, negative]  
+    end
+
+  end # Chinese Postman
+end # Graphy
+

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

@@ -0,0 +1,28 @@
+module Graphy
+  # A generic {GraphBuilder Graph} class you can inherit from.
+  class Graph;                 include GraphBuilder;                 end
+
+  # A generic {AdjacencyGraphBuilder AdjacencyGraph} class you can inherit from.
+  class AdjacencyGraph;        include AdjacencyGraphBuilder;        end
+
+  # A generic {DirectedGraphBuilder DirectedGraph} class you can inherit from.
+  class DirectedGraph;         include DirectedGraphBuilder;         end
+
+  # A generic {DigraphBuilder Digraph} class you can inherit from.
+  class Digraph;               include DigraphBuilder;               end
+
+  # A generic {DirectedPseudoGraphBuilder DirectedPseudoGraph} class you can inherit from.
+  class DirectedPseudoGraph;   include DirectedPseudoGraphBuilder;   end
+
+  # A generic {DirectedMultiGraphBuilder DirectedMultiGraph} class you can inherit from.
+  class DirectedMultiGraph;    include DirectedMultiGraphBuilder;    end
+
+  # A generic {UndirectedGraphBuilder UndirectedGraph} class you can inherit from.
+  class UndirectedGraph;       include UndirectedGraphBuilder;       end
+
+  # A generic {UndirectedPseudoGraphBuilder UndirectedPseudoGraph} class you can inherit from.
+  class UndirectedPseudoGraph; include UndirectedPseudoGraphBuilder; end
+
+  # A generic {UndirectedMultiGraphBuilder UndirectedMultiGraph} class you can inherit from.
+  class UndirectedMultiGraph;  include UndirectedMultiGraphBuilder;  end
+end

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

@@ -0,0 +1,63 @@
+module Graphy
+
+  # This class defines a cycle graph of size n.
+  # This is easily done by using the base Graph
+  # class and implemeting the minimum methods needed to
+  # make it work. This is a good example to look
+  # at for making one's own graph classes.
+  module CycleBuilder
+    def initialize(n)
+      @size = n;
+    end
+
+    def directed?
+      false
+    end
+
+    def vertices
+      (1..@size).to_a
+    end
+
+    def vertex?(v)
+      v > 0 and v <= @size
+    end
+
+    def edge?(u,v = nil)
+      u, v = [u.source, v.target] if u.is_a? Graphy::Arc
+      vertex?(u) && vertex?(v) && ((v-u == 1) or (u == @size && v = 1))
+    end
+
+    def edges
+      Array.new(@size) { |i| Graphy::Edge[i+1, (i+1) == @size ? 1 : i+2]}
+    end
+  end # CycleBuilder
+
+  # This class defines a complete graph of size n.
+  # This is easily done by using the base Graph
+  # class and implemeting the minimum methods needed to
+  # make it work. This is a good example to look
+  # at for making one's own graph classes.
+  module CompleteBuilder
+    include CycleBuilder
+
+    def initialize(n)
+      @size = n
+      @edges = nil
+    end
+
+    def edges
+      return @edges if @edges      # cache edges
+      @edges = []
+      @size.times do |u|
+        @size.times { |v| @edges << Graphy::Edge[u+1, v+1]}
+      end
+      @edges
+    end
+
+    def edge?(u, v = nil)
+      u, v = [u.source, v.target] if u.kind_of? Graphy::Arc
+      vertex?(u) && vertex?(v)
+    end
+  end # CompleteBuilder
+
+end # Graphy

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

@@ -0,0 +1,63 @@
+module Graphy
+  module Comparability
+    
+    # A comparability graph is an UndirectedGraph that has a transitive
+    # orientation. This returns a boolean that says if this graph
+    # is a comparability graph.
+    def comparability?() gamma_decomposition[1]; end
+    
+    # Returns an array with two values, the first being a hash of edges 
+    # with a number containing their class assignment, the second valud
+    # is a boolean which states whether or not the graph is a 
+    # comparability graph
+    #
+    # Complexity in time O(d*|E|) where d is the maximum degree of a vertex
+    # Complexity in space O(|V|+|E|)
+    def gamma_decomposition
+      k = 0; comparability=true; classification={}
+      edges.map {|edge| [edge.source,edge.target]}.each do |e|
+        if classification[e].nil?
+          k += 1
+          classification[e] = k; classification[e.reverse] = -k
+          comparability &&= graphy_comparability_explore(e, k, classification)
+        end
+      end; [classification, comparability]
+    end
+    
+    # Returns one of the possible transitive orientations of 
+    # the UndirectedGraph as a Digraph
+    def transitive_orientation(digraph_class=Digraph)
+      raise NotImplementError
+    end
+    
+   private
+   
+    # Taken from Figure 5.10, on pg. 130 of Martin Golumbic's, _Algorithmic_Graph_
+    # _Theory_and_Perfect_Graphs.
+    def graphy_comparability_explore(edge, k, classification, space='')
+      ret = graphy_comparability_explore_inner(edge, k, classification, :forward, space)
+      graphy_comparability_explore_inner(edge.reverse, k, classification, :backward, space) && ret
+    end
+    
+    def graphy_comparability_explore_inner(edge, k, classification, direction,space)
+      comparability = true  
+      adj_target = adjacent(edge[1])
+      adjacent(edge[0]).select do |mt|
+        (classification[[edge[1],mt]] || k).abs < k or
+        not adj_target.any? {|adj_t| adj_t == mt} 
+      end.each do |m|
+        e = (direction == :forward) ? [edge[0], m] : [m,edge[0]]
+        if classification[e].nil?
+          classification[e] = k
+          classification[e.reverse] = -k
+          comparability = graphy_comparability_explore(e, k, classification, '  '+space) && comparability
+        elsif classification[e] == -k
+          classification[e] = k
+          graphy_comparability_explore(e, k, classification, '  '+space)
+          comparability = false
+        end
+      end; comparability
+    end # graphy_comparability_explore_inner
+    
+  end # Comparability
+end # Graphy

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

@@ -0,0 +1,76 @@
+module Graphy
+
+  # This implements a directed graph which does not allow parallel
+  # edges nor loops. That is, only one arc per nodes couple,
+  # and only one parent per node. Mimics the typical hierarchy
+  # structure.
+  module DirectedGraphBuilder
+    include GraphBuilder
+    
+    autoload :Algorithms, "graphy/directed_graph/algorithms"
+    autoload :Distance,   "graphy/directed_graph/distance"    
+
+    # FIXME: DRY this snippet, I didn't find a clever way to
+    # to dit though
+    # TODO: well, extends_host_with do ... end would be cool,
+    # using Module.new.module_eval(&block) in the helper.
+    extends_host
+    module ClassMethods
+      def [](*a)
+        self.new.from_array(*a)
+      end
+    end
+    
+    def initialize(*params)
+      # FIXME/TODO: setting args to the hash or {} while getting rid
+      # on the previous parameters prevents from passing another
+      # graph to the initializer, so you cannot do things like:
+      # UndirectedGraph.new(Digraph[1,2, 2,3, 2,4, 4,5, 6,4, 1,6])
+      # As args must be a hash, if we're to allow such syntax,
+      # we should provide a way to handle the graph as a hash
+      # member.
+      args = (params.pop if params.last.kind_of? Hash) || {}
+      args[:algorithmic_category] = DirectedGraphBuilder::Algorithms    
+      super *(params << args)
+    end
+  end # DirectedGraphBuilder
+  
+  # DirectedGraph is just an alias for Digraph should one desire
+  DigraphBuilder = DirectedGraphBuilder
+
+  # This is a Digraph that allows for parallel edges, but does not
+  # allow loops.
+  module DirectedPseudoGraphBuilder
+    include DirectedGraphBuilder
+    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 # DirectedPseudoGraphBuilder
+
+  # This is a Digraph that allows for both parallel edges and loops.
+  module DirectedMultiGraphBuilder
+    include DirectedPseudoGraphBuilder
+    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 # DirectedMultiGraphBuilder
+
+end # Graphy

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

@@ -0,0 +1,92 @@
+module Graphy
+
+  # Digraph is a directed graph which is a finite set of vertices
+  # and a finite set of edges connecting vertices. It cannot contain parallel
+  # edges going from the same source vertex to the same target. It also
+  # cannot contain loops, i.e. edges that go have the same vertex for source 
+  # and target.
+  #
+  # DirectedPseudoGraph is a class that allows for parallel edges, and
+  # DirectedMultiGraph is a class that allows for parallel edges and loops
+  # as well.
+  module DirectedGraphBuilder
+    module Algorithms
+
+      include Search
+      include StrongComponents
+      include Distance
+      include ChinesePostman
+
+      # A directed graph is directed by definition
+      #
+      # @return [Boolean] always true
+      def directed?
+        true
+      end
+
+      # A digraph uses the Arc class for edges
+      #
+      # @return [Graphy::MultiArc, Graphy::Arc] `Graphy::MultiArc` if the graph allows for parallel edges,
+      #   `Graphy::Arc` otherwise.
+      def edge_class
+        @parallel_edges ? Graphy::MultiArc : Graphy::Arc
+      end
+
+      # Reverse all edges in a graph
+      #
+      # @return [DirectedGraph] a copy of the receiver for which the direction of edges has
+      #   been inverted.
+      def reversal
+        result = self.class.new
+        edges.inject(result) { |a,e| a << e.reverse}
+        vertices.each { |v| result.add_vertex!(v) unless result.vertex?(v) }
+        result
+      end
+
+      # Check whether the Graph is oriented or not.
+      #
+      # @return [Boolean]
+      def oriented?
+        e = edges
+        re = e.map { |x| x.reverse}
+        not e.any? { |x| re.include?(x)}
+      end
+
+      # Balanced is when the out edge count is equal to the in edge count
+      #
+      # @return [Boolean]
+      def balanced?(v)
+        out_degree(v) == in_degree(v)
+      end
+
+      # Returns out_degree(v) - in_degree(v)
+      def delta(v)
+        out_degree(v) - in_degree(v)
+      end
+
+      def community(node, direction)
+        nodes, stack = {}, adjacent(node, :direction => direction)
+        while n = stack.pop
+          unless nodes[n.object_id] || node == n
+            nodes[n.object_id] = n
+            stack += adjacent(n, :direction => direction)
+          end
+        end
+        nodes.values
+      end
+
+      def descendants(node)
+        community(node, :out)
+      end
+
+      def ancestors(node)
+        community(node, :in)
+      end
+
+      def family(node)
+        community(node, :all)
+      end    
+
+    end # Algorithms
+  end # DirectedGraphBuilder
+end # Graphy

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

@@ -0,0 +1,167 @@
+module Graphy
+  module DirectedGraphBuilder
+
+    # This module provides algorithms computing distance between
+    # vertices.
+    module Distance
+      
+      # Shortest path computation.
+      #
+      # From: Jorgen Band-Jensen and Gregory Gutin,
+      # [*Digraphs: Theory, Algorithms and Applications*](http://www.springer.com/mathematics/numbers/book/978-1-84800-997-4), pg. 53-54.
+      # Complexity `O(n+m)`.
+      #
+      # Requires the graph to be acyclic. If the graph is not acyclic,
+      # then see {Distance#dijkstras_algorithm} or {Distance#bellman_ford_moore}
+      # for possible solutions.
+      #
+      # @param [vertex] start the starting vertex 
+      # @param [Proc, #[]] weight can be a `Proc`, or anything else accessed using the `[]`
+      #   operator. If not a `Proc`, and if no label accessible through `[]`, it will
+      #   default to using the value stored in the label for the {Arc}. If a `Proc`, it will 
+      #   pass the edge to the proc and use the resulting value.
+      # @param [Integer] zero used for math systems with a different definition of zero
+      #
+      # @return [Hash] a hash with the key being a vertex and the value being the
+      # distance. A missing vertex from the hash is equivalent to an infinite distance.
+      def shortest_path(start, weight = nil, zero = 0)
+        dist = { start => zero }
+        path = {}
+        topsort(start) do |vi|
+          next if vi == start
+          dist[vi], path[vi] = adjacent(vi, :direction => :in).map do |vj|
+            [dist[vj] + cost(vj,vi,weight), vj] 
+          end.min { |a,b| a[0] <=> b[0]}
+        end; 
+        dist.keys.size == vertices.size ? [dist, path] : nil
+      end   
+      
+      # Finds the distance from a given vertex in a weighted digraph
+      # to the rest of the vertices, provided all the weights of arcs
+      # are non-negative.
+      #
+      # If negative arcs exist in the graph, two basic options exist:
+      #
+      # * modify all weights to be positive using an offset (temporary at least)
+      # * use the {Distance#bellman_ford_moore} algorithm.
+      #
+      # Also, if the graph is acyclic, use the {Distance#shortest_path algorithm}.
+      #
+      # From: Jorgen Band-Jensen and Gregory Gutin,
+      # [*Digraphs: Theory, Algorithms and Applications*](http://www.springer.com/mathematics/numbers/book/978-1-84800-997-4), pg. 53-54.
+      #
+      # Complexity `O(n*log(n) + m)`.
+      # 
+      # @param [vertex] s
+      # @param [Proc, #[]] weight can be a `Proc`, or anything else accessed using the `[]`
+      #   operator. If not a `Proc`, and if no label accessible through `[]`, it will
+      #   default to using the value stored in the label for the {Arc}. If a `Proc`, it will 
+      #   pass the edge to the proc and use the resulting value.
+      # @param [Integer] zero used for math systems with a different definition of zero
+      # @return [Hash] a hash with the key being a vertex and the value being the
+      #   distance. A missing vertex from the hash is equivalent to an infinite distance.
+      def dijkstras_algorithm(s, weight = nil, zero = 0)
+        q = vertices; distance = { s => zero }
+        path = {}
+        while not q.empty?
+          v = (q & distance.keys).inject(nil) { |a,k| (!a.nil?) && (distance[a] < distance[k]) ? a : k} 
+          q.delete(v)
+          (q & adjacent(v)).each do |u|
+            c = cost(v, u, weight)
+            if distance[u].nil? or distance[u] > (c + distance[v])
+              distance[u] = c + distance[v]
+              path[u] = v
+            end
+          end
+        end
+        [distance, path]
+      end
+
+      # Finds the distances from a given vertex in a weighted digraph
+      # to the rest of the vertices, provided the graph has no negative cycle.
+      #
+      # If no negative weights exist, then {Distance#dijkstras_algorithm} is more
+      # efficient in time and space. Also, if the graph is acyclic, use the
+      # {Distance#shortest_path} algorithm.
+      #
+      # From: Jorgen Band-Jensen and Gregory Gutin,
+      # [*Digraphs: Theory, Algorithms and Applications*](http://www.springer.com/mathematics/numbers/book/978-1-84800-997-4), pg. 56-58..
+      #
+      # Complexity `O(nm)`.
+      #
+      # @param [vertex] s
+      # @param [Proc, #[]] weight can be a `Proc`, or anything else accessed using the `[]`
+      #   operator. If not a `Proc`, and if no label accessible through `[]`, it will
+      #   default to using the value stored in the label for the {Arc}. If a `Proc`, it will 
+      #   pass the edge to the proc and use the resulting value.
+      # @param [Integer] zero used for math systems with a different definition of zero
+      # @return [Hash] a hash with the key being a vertex and the value being the
+      #   distance. A missing vertex from the hash is equivalent to an infinite distance.
+      def bellman_ford_moore(start, weight = nil, zero = 0)
+        distance = { start => zero }
+        path = {}
+        2.upto(vertices.size) do
+          edges.each do |e|
+            u, v = e[0], e[1]
+            unless distance[u].nil?
+              c = cost(u, v, weight) + distance[u]
+              if distance[v].nil? or c < distance[v]
+                distance[v] = c
+                path[v] = u
+              end 
+            end        
+          end
+        end
+        [distance, path]
+      end
+      
+      # Uses the Floyd-Warshall algorithm to efficiently find
+      # and record shortest paths while establishing at the same time
+      # the costs for all vertices in a graph.
+      #
+      # See S.Skiena, *The Algorithm Design Manual*, Springer Verlag, 1998 for more details.
+      #
+      # O(n^3) complexity in time.
+      #  
+      # @param [Proc, nil] weight specifies how an edge weight is determined.
+      #   If it's a `Proc`, the {Arc} is passed to it; if it's `nil`, it will just use
+      #   the value in the label for the Arc; otherwise the weight is
+      #   determined by applying the `[]` operator to the value in the 
+      #   label for the {Arc}.
+      # @param [Integer] zero defines the zero value in the math system used.
+      #   This allows for no assumptions to be made about the math system and
+      #   fully functional duck typing.
+      # @return [Array(matrice, matrice, Hash)] a pair of matrices and a hash of delta values. 
+      #   The matrices will be indexed by two vertices and are implemented as a Hash of Hashes.
+      #   The first matrix is the cost, the second matrix is the shortest path spanning tree.
+      #   The delta (difference of number of in-edges and out-edges) is indexed by vertex.
+      def floyd_warshall(weight = nil, zero = 0)
+        c     = Hash.new { |h,k| h[k] = Hash.new }
+        path  = Hash.new { |h,k| h[k] = Hash.new }
+        delta = Hash.new { |h,k| h[k] = 0 }
+        edges.each do |e| 
+          delta[e.source] += 1
+          delta[e.target] -= 1
+          path[e.source][e.target] = e.target      
+          c[e.source][e.target] = cost(e, weight)
+        end
+        vertices.each do |k|
+          vertices.each do |i|
+            if c[i][k]
+              vertices.each do |j|
+                if c[k][j] && 
+                    (c[i][j].nil? or c[i][j] > (c[i][k] + c[k][j]))
+                  path[i][j] = path[i][k]
+                  c[i][j] = c[i][k] + c[k][j]
+                  return nil if i == j and c[i][j] < zero
+                end
+              end
+            end  
+          end
+        end
+        [c, path, delta]
+      end
+
+    end # Distance
+  end # DirectedGraph
+end # Graphy