poolparty 1.3.15 → 1.4.0

data/vendor/gems/gratr/lib/gratr/edge.rb

@@ -1,145 +0,0 @@
-#--
-# 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.
-#++
-
-
-module GRATR
-
-  # 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 for eql?
-    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
-    def hash() source.hash ^ (target.hash+1); 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
-    
-  # An undirected edge is simply an undirected pair (source, target) used in
-  # undirected graphs. Edge[u,v] == Edge[v,u]
-  class Edge < Arc
-
-    # Equality allows for the swapping of source and target
-    def eql?(other) super or (self.class == other.class and target==other.source and source==other.target); end
-      
-    # Alias for eql?
-    alias == eql?
-
-    # Hash is defined such that source and target can be reversed and the
-    # hash value will be the same
-    #
-    # This will cause problems with self loops
-    def hash() source.hash ^ target.hash; end
-
-    # Sort support
-    def <=>(rhs)
-      [[source,target].max,[source,target].min] <=> 
-      [[rhs.source,rhs.target].max,[rhs.source,rhs.target].min]
-    end
-    
-    # Edge[1,2].to_s == "(1=2 'label)"
-    def to_s
-      l = label ? " '#{label.to_s}'" : ''
-      s = source.to_s
-      t = target.to_s
-      "(#{[s,t].min}=#{[s,t].max}#{l})"
-    end
-    
-  end
-  
-  # This module provides for internal numbering of edges for differentiating between mutliple edges
-  module ArcNumber
-    
-    attr_accessor :number # Used to differentiate between mutli-edges
-    
-    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
-    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)
-      
-      def cl.[](p_source, p_target, p_number=nil, p_label=nil)
-        new(p_source, p_target, p_number, p_label)
-      end
-    end
-
-  end
-  
-  class MultiArc < Arc
-    include ArcNumber
-  end
-  
-  class MultiEdge < Edge
-    include ArcNumber
-  end
-  
-end

data/vendor/gems/gratr/lib/gratr/graph.rb

@@ -1,315 +0,0 @@
-#--
-# 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/labels'
-require 'gratr/graph_api'
-
-module GRATR
-  
-  # Using the functions required by the GraphAPI, it implements all the
-  # basic functions of a Graph class by using only functions in GraphAPI.
-  # An actual implementation still needs to be done, as in Digraph or
-  # UndirectedGraph.
-  module Graph
-    include Enumerable
-    include Labels
-    include GraphAPI
-      
-    alias remove_arc! remove_edge!
-    alias add_arc! add_edge!
-    alias arcs edges
-    alias arc_class edge_class  
-      
-    # Non destructive version of add_vertex!, returns modified copy of Graph
-    def add_vertex(v, l=nil) x=self.class.new(self); x.add_vertex!(v,l); end
-      
-    # Non destructive version add_edge!, returns modified copy of Graph  
-    def add_edge(u, v=nil, l=nil) x=self.class.new(self); x.add_edge!(u,v,l); end
-    alias add_arc add_edge  
-      
-    # Non destructive version of remove_vertex!, returns modified copy of Graph
-    def remove_vertex(v) x=self.class.new(self); x.remove_vertex!(v); end  
-
-    # Non destructive version of remove_edge!, returns modified copy of Graph
-    def remove_edge(u,v=nil) x=self.class.new(self); x.remove_edge!(u,v); end
-    alias remove_arc remove_edge  
-      
-    # Return Array of adjacent portions of the Graph
-    #  x can either be a vertex an edge.
-    #  options specifies parameters about the adjacency search
-    #   :type can be either :edges or :vertices (default).
-    #   :direction can be :in, :out(default) or :all.
-    #
-    # Note: It is probably more efficently done in implementation.
-    def adjacent(x, options={})
-      d = directed? ? (options[:direction] || :out) : :all
-
-      # Discharge the easy ones first
-      return [x.source] if x.kind_of? Arc and options[:type] == :vertices and d == :in
-      return [x.target] if x.kind_of? Arc and options[:type] == :vertices and d == :out
-      return [x.source, x.target] if x.kind_of? Arc and options[:type] != :edges and d == :all
-
-      (options[:type] == :edges ? edges : to_a).select {|u| adjacent?(x,u,d)}
-    end
-
-    # Add all objects in _a_ to the vertex set.
-    def add_vertices!(*a) a.each {|v| add_vertex! v}; self; end
-      
-    # See add_vertices!
-
-    def add_vertices(*a) x=self.class.new(self); x.add_vertices(*a); self; end
-
-    # Add all edges in the _edges_ Enumerable to the edge set.  Elements of the
-    # Enumerable can be both two-element arrays or instances of DirectedArc or
-    # UnDirectedArc. 
-    def add_edges!(*args) args.each { |edge| add_edge!(edge) }; self; end
-    alias add_arc! add_edges!  
-      
-    # See add_edge!
-    def add_edges(*a) x=self.class.new(self); x.add_edges!(*a); self; end
-    alias add_arcs add_edges
-
-    # Remove all vertices specified by the Enumerable a from the graph by
-    # calling remove_vertex!.
-    def remove_vertices!(*a) a.each { |v| remove_vertex! v }; end
-      
-    # See remove_vertices!
-    def remove_vertices(*a) x=self.class.new(self); x.remove_vertices(*a); end
-
-    # Remove all vertices edges by the Enumerable a from the graph by
-    # calling remove_edge!
-    def remove_edges!(*a) a.each { |e| remove_edges! e }; end
-    alias remove_arc! remove_edges!
-
-    # See remove_edges
-    def remove_edges(*a) x=self.class.new(self); x.remove_edges(*a); end
-    alias remove_arcs remove_edges
-
-    # Execute given block for each vertex, provides for methods in Enumerable
-    def each(&block) vertices.each(&block); end
-
-    # Returns true if _v_ is a vertex of the graph.
-    # This is a default implementation that is of O(n) average complexity.
-    # If a subclass uses a hash to store vertices, then this can be
-    # made into an O(1) average complexity operation.
-    def vertex?(v) vertices.include?(v); end  
-    
-    # Returns true if u or (u,v) is an Arc of the graph.
-    def edge?(*arg) edges.include?(edge_convert(*args)); end  
-    alias arc? edge?
-
-    # Tests two objects to see if they are adjacent.
-    # direction parameter specifies direction of adjacency, :in, :out, or :all(default)
-    # All denotes that if there is any adjacency, then it will return true.
-    # Note that the default is different than adjacent where one is primarily concerned with finding
-    # all adjacent objects in a graph to a given object. Here the concern is primarily on seeing
-    # if two objects touch. For vertexes, any edge between the two will usually do, but the direction
-    # can be specified if need be.
-    def adjacent?(source, target, direction=:all)
-      if source.kind_of? GRATR::Arc
-        raise NoArcError unless edge? source
-        if target.kind_of? GRATR::Arc
-          raise NoArcError unless edge? target
-          (direction != :out and source.source == target.target) or (direction != :in and source.target == target.source)
-        else
-          raise NoVertexError unless vertex? target
-          (direction != :out and source.source == target)  or (direction != :in and source.target == target)
-        end
-      else
-        raise NoVertexError unless vertex? source
-        if target.kind_of? GRATR::Arc
-          raise NoArcError unless edge? target
-          (direction != :out and source == target.target) or (direction != :in and source == target.source)
-        else
-          raise NoVertexError unless vertex? target
-          (direction != :out and edge?(target,source)) or (direction != :in and edge?(source,target))
-        end
-      end
-    end
-
-    # Returns true if the graph has no vertex, i.e. num_vertices == 0.
-    def empty?() vertices.size.zero?; end
-
-    # Returns true if the given object is a vertex or Arc in the Graph.
-    # 
-    def include?(x) x.kind_of?(GRATR::Arc) ? edge?(x) : vertex?(x); end
-
-    # Returns the neighboorhood of the given vertex (or Arc)
-    # This is equivalent to adjacent, but bases type on the type of object.
-    # direction can be :all, :in, or :out 
-    def neighborhood(x, direction = :all)
-      adjacent(x, :direction => direction, :type => ((x.kind_of? GRATR::Arc) ? :edges : :vertices )) 
-    end
-    
-    # Union of all neighborhoods of vertices (or edges) in the Enumerable x minus the contents of x
-    # Definition taken from Jorgen Bang-Jensen, Gregory Gutin, _Digraphs: Theory, Algorithms and Applications_, pg 4
-    def set_neighborhood(x, direction = :all)
-      x.inject(Set.new) {|a,v| a.merge(neighborhood(v,direction))}.reject {|v2| x.include?(v2)}
-    end  
-    
-    # Union of all set_neighborhoods reachable in p edges
-    # Definition taken from Jorgen Bang-Jensen, Gregory Gutin, _Digraphs: Theory, Algorithms and Applications_, pg 46
-    def closed_pth_neighborhood(w,p,direction=:all)
-      if p <= 0
-        w 
-      elsif p == 1
-        (w + set_neighborhood(w,direction)).uniq
-      else
-        n = set_neighborhood(w, direction)
-        (w + n + closed_pth_neighborhood(n,p-1,direction)).uniq
-      end
-    end
-    
-    # Returns the neighboorhoods reachable in p steps from every vertex (or edge)
-    # in the Enumerable x        
-    # Definition taken from Jorgen Bang-Jensen, Gregory Gutin, _Digraphs: Theory, Algorithms and Applications_, pg 46
-    def open_pth_neighborhood(x, p, direction=:all)
-      if    p <= 0
-        x
-      elsif p == 1
-        set_neighborhood(x,direction)
-      else  
-        set_neighborhood(open_pth_neighborhood(x, p-1, direction),direction) - closed_pth_neighborhood(x,p-1,direction)
-      end    
-    end
-    
-    # Returns the number of out-edges (for directed graphs) or the number of
-    # incident edges (for undirected graphs) of vertex _v_.
-    def out_degree(v) adjacent(v, :direction => :out).size; end
-
-    # Returns the number of in-edges (for directed graphs) or the number of
-    # incident edges (for undirected graphs) of vertex _v_.
-    def in_degree(v)  adjacent(v, :direction => :in ).size; end
-
-    # Returns the sum of the number in and out edges for a vertex
-    def degree(v) in_degree(v) + out_degree(v); end
-
-    # Minimum in-degree 
-    def min_in_degree() to_a.map {|v| in_degree(v)}.min; end
-
-    # Minimum out-degree
-    def min_out_degree() to_a.map {|v| out_degree(v)}.min; end
-
-    # Minimum degree of all vertexes
-    def min_degree() [min_in_degree, min_out_degree].min; end
-
-    # Maximum in-degree 
-    def max_in_degree() vertices.map {|v| in_degree(v)}.max; end
-
-    # Maximum out-degree
-    def max_out_degree() vertices.map {|v| out_degree(v)}.max; end
-
-    # Minimum degree of all vertexes
-    def max_degree() [max_in_degree, max_out_degree].max; end
-
-    # Regular
-    def regular?() min_degree == max_degree; end
-
-    # Returns the number of vertices.
-    def size()         vertices.size; end
-
-    # Synonym for size.
-    def num_vertices() vertices.size; end
-
-    # Returns the number of edges.
-    def num_edges()    edges.size; end
-
-    # Utility method to show a string representation of the edges of the graph.
-    def to_s() edges.to_s; end
-
-    # Equality is defined to be same set of edges and directed?
-    def eql?(g) 
-      return false unless g.kind_of? GRATR::Graph
-
-      (g.directed?   == self.directed?)  and 
-      (vertices.sort == g.vertices.sort) and
-      (g.edges.sort  == edges.sort)
-    end
-
-    # Synonym for eql?
-    def ==(rhs) eql?(rhs); end
-
-    # Merge another graph into this one
-    def merge(other)
-      other.vertices.each {|v| add_vertex!(v)      }
-      other.edges.each    {|e| add_edge!(e)         }
-      other.edges.each    {|e| add_edge!(e.reverse) } if directed? and !other.directed? 
-      self 
-    end
-
-    # A synonym for merge, that doesn't modify the current graph
-    def +(other)
-      result = self.class.new(self)
-      case other
-        when GRATR::Graph : result.merge(other)
-        when GRATR::Arc  : result.add_edge!(other)
-        else              result.add_vertex!(other)
-      end
-    end
-
-    # Remove all vertices in the specified right hand side graph
-    def -(other)
-      case  other
-        when GRATR::Graph : induced_subgraph(vertices - other.vertices)
-        when GRATR::Arc  : self.class.new(self).remove_edge!(other)
-        else              self.class.new(self).remove_vertex!(other)
-      end
-    end
-
-    # A synonym for add_edge!
-    def <<(edge) add_edge!(edge); end
-
-    # Return the complement of the current graph
-    def complement
-      vertices.inject(self.class.new) do |a,v|
-        a.add_vertex!(v)
-        vertices.each {|v2| a.add_edge!(v,v2) unless edge?(v,v2) }; a
-      end
-    end
-
-    # Given an array of vertices return the induced subgraph
-    def induced_subgraph(v)
-      edges.inject(self.class.new) do |a,e| 
-        ( v.include?(e.source) and v.include?(e.target) ) ?  (a << e) : a
-      end;
-    end
-    
-    def inspect
-      l = vertices.select {|v| self[v]}.map {|u| "vertex_label_set(#{u.inspect},#{self[u].inspect})"}.join('.')
-      self.class.to_s + '[' + edges.map {|e| e.inspect}.join(', ') + ']' + (l ? '.'+l : '')
-    end
-    
-   private
-    def edge_convert(*args) args[0].kind_of?(GRATR::Arc) ? args[0] : edge_class[*args]; end
-    
-
-  end # Graph
-
-end # GRATR

data/vendor/gems/gratr/lib/gratr/graph_api.rb

@@ -1,82 +0,0 @@
-#--
-# 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 AREf
-# 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.
-#++
-
-
-module GRATR
-  
-  # This defines the minimum set of functions required to make a graph class that can
-  # use the algorithms defined by this library
-  module GraphAPI
-    
-    # Is the graph directed?
-    # 
-    # This method must be implemented by the specific graph class
-    def directed?()             raise NotImplementedError; end
-
-    # Add a vertex to the Graph and return the Graph
-    # An additional label l can be specified as well
-    # 
-    # This method must be implemented by the specific graph class    
-    def add_vertex!(v,l=nil)     raise NotImplementedError; end
-      
-    # Add an edge to the Graph and return the Graph
-    # u can be an object of type GRATR::Arc or u,v specifies
-    # a source, target pair. The last parameter is an optional label
-    # 
-    # This method must be implemented by the specific graph class
-    def add_edge!(u,v=nil,l=nil) raise NotImplementedError; end
-      
-    # Remove a vertex to the Graph and return the Graph
-    # 
-    # This method must be implemented by the specific graph class
-    def remove_vertex!(v)        raise NotImplementedError; end
-      
-    # Remove an edge from the Graph and return the Graph
-    # 
-    # Can be a type of GRATR::Arc or a source and target
-    # This method must be implemented by the specific graph class
-    def remove_edge!(u,v=nil)    raise NotImplementedError; end
-            
-    # Return the array of vertices.
-    # 
-    # This method must be implemented by the specific graph class
-    def vertices()              raise NotImplementedError; end
-
-    # Return the array of edges.
-    # 
-    # This method must be implemented by the specific graph class
-    def edges()                 raise NotImplementedError; end
-      
-    # Returns the edge class
-    def edge_class()            raise NotImplementedError; end
-    
-    # Return the chromatic number for this graph
-    # This is currently incomplete and in some cases will be NP-complete
-    # FIXME: Should this even be here? My gut feeling is no...
-    def chromatic_number()      raise NotImplementedError; end
-  end
-end

data/vendor/gems/gratr/lib/gratr/import.rb

@@ -1,44 +0,0 @@
-#--
-# 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'
-
-# Pull all GRATR classes up into the current namespace
-Arc                  = GRATR::Arc
-Edge        = GRATR::Edge
-MultiArc             = GRATR::MultiArc
-MultiEdge   = GRATR::MultiEdge
-Graph                 = GRATR::Graph
-Digraph               = GRATR::Digraph
-DirectedGraph         = GRATR::DirectedGraph
-DirectedPseudoGraph   = GRATR::DirectedPseudoGraph
-DirectedMultiGraph    = GRATR::DirectedMultiGraph
-UndirectedGraph       = GRATR::UndirectedGraph
-UndirectedPseudoGraph = GRATR::UndirectedPseudoGraph
-UndirectedMultiGraph  = GRATR::UndirectedMultiGraph
-Complete              = GRATR::Complete

data/vendor/gems/gratr/lib/gratr/labels.rb

@@ -1,103 +0,0 @@
-#--
-# 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.
-#++
-
-module GRATR
-  module Labels
-    # Return a label for an edge or vertex
-    def [](u) (u.kind_of? GRATR::Arc) ? edge_label(u) : vertex_label(u); end
-
-    # Set a label for an edge or vertex
-    def []= (u, value) (u.kind_of? GRATR::Arc) ? edge_label_set(u,value) : vertex_label_set(u, value); end
-
-    # Delete a label entirely
-    def delete_label(u) (u.kind_of? GRATR::Arc) ? edge_label_delete(u) : vertex_label_delete(u); end
-
-    # Get the label for an edge
-    def vertex_label(v)        vertex_label_dict[v]; end
-
-    # Set the label for an edge
-    def vertex_label_set(v, l) vertex_label_dict[v] = l; self; end
-
-    # Get the label for an edge
-    def edge_label(u,v=nil,n=nil)
-      u = edge_convert(u,v,n)
-      edge_label_dict[u]
-    end
-
-    # Set the label for an edge
-    def edge_label_set(u, v=nil, l=nil, n=nil) 
-      u.kind_of?(GRATR::Arc) ? l = v : u = edge_convert(u,v,n)
-      edge_label_dict[u] = l; self
-    end
-
-    # Delete all graph labels
-    def clear_all_labels()  @vertex_labels = {}; @edge_labels = {}; end
-
-    # Delete an edge label
-    def edge_label_delete(u, v=nil, n=nil)
-      u = edge_convert(u,v,n)
-      edge_label_dict.delete(u)
-    end
-
-    # Delete a vertex label
-    def vertex_label_delete(v) vertex_label_dict.delete(v); end
-
-   protected
-
-    def vertex_label_dict() @vertex_labels ||= {}; end
-    def edge_label_dict()   @edge_labels   ||= {}; end
-
-    # A generic cost function. It either calls the weight function with and edge
-    # constructed from the two nodes, or calls the [] operator of the label
-    # when given a value. If no weight value is specified, the label itself is
-    # treated as the cost value.
-    #
-    # Note: This function will not work for Pseudo or Multi graphs at present. 
-    # FIXME: Remove u,v interface to fix Pseudo Multi graph problems.
-    def cost(u,v=nil,weight=nil)
-      u.kind_of?(Arc) ? weight = v : u = edge_class[u,v] 
-      case weight
-        when Proc : weight.call(u)
-        when nil  : self[u]
-        else        self[u][weight]
-      end
-    end
-    
-    # An alias of cost for property retrieval in general
-    alias property cost
-    
-    # A function to set properties specified by the user.
-    def property_set(u,name,value)
-      case name
-        when Proc : name.call(value)
-        when nil  : self[u] = value
-        else        self[u][name] = value
-      end
-    end
-
-  end
-end