gratr19 0.4.4

data/lib/gratr.rb

@@ -0,0 +1,42 @@
+#--
+# 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 'gratr/base'
+require 'gratr/digraph'
+require 'gratr/undirected_graph'
+require 'gratr/common'
+
+# Load priority queue classes
+begin
+  # Use installed Gem
+  require 'priority_queue'
+rescue LoadError # Use local copy
+  require 'priority-queue/lib/priority_queue/ruby_priority_queue'
+  PriorityQueue = RubyPriorityQueue
+end

data/lib/gratr/adjacency_graph.rb

@@ -0,0 +1,230 @@
+#--
+# 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 'gratr/edge'
+require 'gratr/graph'
+require 'set'
+
+module GRATR
+
+  # This provides the basic routines needed to implement the Digraph, UndirectedGraph,
+  # PseudoGraph, DirectedPseudoGraph, MultiGraph and DirectedPseudoGraph class.
+  module AdjacencyGraph
+    
+    include Graph
+
+    class ArrayWithAdd < Array # :nodoc:
+      alias add push
+    end
+
+    # Initialization parameters can include an Array of edges to add, Graphs to
+    # copy (will merge if multiple)
+    # :parallel_edges denotes that duplicate edges are allowed
+    # :loops denotes that loops are allowed
+    def initialize(*params)
+      @vertex_dict     = Hash.new    
+      raise ArgumentError if params.any? do |p| 
+        !(p.kind_of? GRATR::Graph or 
+          p.kind_of? Array or 
+          p == :parallel_edges or
+          p == :loops)
+      end
+      clear_all_labels
+
+      # Basic configuration of adjacency
+      @allow_loops    = params.any? {|p| p == :loops}
+      @parallel_edges = params.any? {|p| p == :parallel_edges}
+      @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.kind_of? GRATR::Graph}.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|
+          vertex_label_set(v, vertex_label(v)) if vertex_label(v)
+        end  
+      end
+
+      # Add all array edges specified
+      params.select {|p| p.kind_of? 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?
+    def vertex?(v) @vertex_dict.has_key?(v); end
+
+    # Returns true if [u,v] or u is an Arc
+    # An O(1) implementation 
+    def edge?(u, v=nil)
+      u, v = u.source, u.target if u.kind_of? GRATR::Arc
+      vertex?(u) and @vertex_dict[u].include?(v)
+    end
+
+    # Adds a vertex to the graph with an optional label
+    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
+    #   * add_edge!(Arc[source,target], "Label")
+    #   * add_edge!(source,target, "Label")
+    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.kind_of? GRATR::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
+    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 source and target or with
+    # and object of GRATR::Arc derivation
+    def remove_edge!(u, v=nil)
+      unless u.kind_of? GRATR::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
+    def vertices() @vertex_dict.keys; end
+
+    # Returns an array of edges, most likely of class Arc or Edge depending 
+    # upon the type of graph
+    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
+ 
+    alias graph_adjacent adjacent
+    def adjacent(x, options={})
+      options[:direction] ||= :out
+      if !x.kind_of?(GRATR::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
+    
+ 
+  public
+
+    def self.included(cl)
+      # Shortcut for creating a Graph
+      #
+      #  Example: GRATR::Digraph[1,2, 2,3, 2,4, 4,5].edges.to_a.to_s =>
+      #    "(1-2)(2-3)(2-4)(4-5)"
+      # 
+      # Or as a Hash for specifying lables
+      # GRATR::Digraph[ [:a,:b] => 3, [:b,:c] => 4 ]  (Note: Do not use for Multi or Pseudo graphs)
+      def cl.[] (*a)
+        result = new
+        if a.size == 1 and a[0].kind_of? Hash
+          # Convert to edge class
+          a[0].each do |k,v|
+            if result.edge_class.include? GRATR::ArcNumber
+              result.add_edge!(result.edge_class[k[0],k[1],nil,v])
+            else
+             result.add_edge!(result.edge_class[k[0],k[1],v])
+            end 
+          end
+        elsif a[0].kind_of? GRATR::Arc
+          a.each{|e| result.add_edge!(e); result[e] = e.label}
+        elsif a.size % 2 == 0    
+          0.step(a.size-1, 2) {|i| result.add_edge!(a[i], a[i+1])}
+        else
+          raise ArgumentError
+        end
+        result
+      end
+    end
+          
+  end # Adjacency Graph
+end # GRATR

data/lib/gratr/base.rb

@@ -0,0 +1,34 @@
+#--
+# 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.
+#++
+
+GRATR_VERSION = "0.4.3"
+
+module GRATR
+  class NoVertexError      < IndexError;   end
+  class NoArcError        < IndexError;   end
+end

data/lib/gratr/biconnected.rb

@@ -0,0 +1,116 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# 
+# 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 GRATR
+  module Graph    
+    # 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 # Graph
+end # GRATR

data/lib/gratr/chinese_postman.rb

@@ -0,0 +1,123 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# 
+# 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 'gratr/digraph_distance'
+
+module GRATR
+  module Graph
+    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 # Graph
+end # GRATR
+