gratr 0.4.2

data/lib/gratr/undirected_graph.rb

@@ -0,0 +1,153 @@
+#--
+# 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/adjacency_graph'
+require 'gratr/search'
+require 'gratr/biconnected'
+require 'gratr/comparability'
+require 'set'
+
+module GRATR
+  class UndirectedGraph
+    include AdjacencyGraph
+    include Graph::Search
+    include Graph::Biconnected
+    include Graph::Comparability
+    
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? GRATR::Graph or p.kind_of? Array)
+      end if self.class == GRATR::UndirectedGraph
+      super(*params)
+    end 
+
+    # 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 ? GRATR::MultiEdge : GRATR::Edge; end
+
+    def remove_edge!(u, v=nil)
+      unless u.kind_of? GRATR::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 # UndirectedGraph
+
+  # This is a UndirectedGraph that allows for parallel edges, but does not
+  # allow loops
+  class UndirectedPseudoGraph < UndirectedGraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, *params)
+    end 
+  end
+
+  # This is a UndirectedGraph that allows for parallel edges and loops
+  class UndirectedMultiGraph < UndirectedGraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, :loops, *params)
+    end 
+  end
+
+
+end # GRATR

data/tests/TestBiconnected.rb

@@ -0,0 +1,53 @@
+#--
+# 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 'test/unit'
+require 'gratr/import'
+
+class TestBiconnected < Test::Unit::TestCase # :nodoc:
+  def test_tarjan
+    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
+    assert_equal [1,2,7], articulations.sort
+    assert_equal 4, graphs.size
+    assert_equal [1,7],     graphs.find {|g| g.size == 2}.vertices.sort
+    assert_equal [1,2,5,6], graphs.find {|g| g.size == 4}.vertices.sort
+    assert_equal [2,3,4],   graphs.find {|g| g.size == 3 && g.vertex?(2)}.vertices.sort
+    assert_equal [7,8,9],   graphs.find {|g| g.size == 3 && g.vertex?(7)}.vertices.sort
+  end
+end

data/tests/TestChinesePostman.rb

@@ -0,0 +1,53 @@
+#--
+# 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 'test/unit'
+require 'gratr/import'
+
+class TestChinesePostman < Test::Unit::TestCase # :nodoc:
+
+  def setup  
+    @simple=Digraph[ 0,1,  0,2,  1,2,  1,3,  2,3,  3,0 ]
+    @weight = Proc.new {|e| 1}
+  end
+  
+  def test_closed_simple_tour
+    tour = @simple.closed_chinese_postman_tour(0, @weight)
+    assert_equal 11, tour.size
+    assert_equal 0, tour[0]
+    assert_equal 0, tour[10]
+    edges = Set.new
+    0.upto(9) do |n| 
+      edges << Arc[tour[n],tour[n+1]]
+      assert(@simple.edge?(tour[n],tour[n+1]), "Arc(#{tour[n]},#{tour[n+1]}) from tour not in graph")
+    end
+    assert_equal @simple.edges.size, edges.size, "Not all arcs traversed!"
+  end
+  
+  
+end

data/tests/TestComplement.rb

@@ -0,0 +1,54 @@
+#--
+# 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 'test/unit'
+require 'gratr/import'
+
+class TestComplement < Test::Unit::TestCase # :nodoc:
+  
+  def test_square
+    x = UndirectedGraph[:a,:b, :b,:c, :c,:d, :d,:a].complement
+    assert_equal 2, x.edges.size
+    assert x.edges.include?(Edge[:a,:c])
+    assert x.edges.include?(Edge[:b,:d])
+  end
+  
+  def test_g1
+    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
+    assert_equal 19, g1.edges.size
+    
+  end
+
+end

data/tests/TestDigraph.rb

@@ -0,0 +1,333 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'test/unit'
+require 'gratr/import'
+
+class TestDigraph < Test::Unit::TestCase # :nodoc:
+
+  def setup
+    @single = Digraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
+    @dups   = DirectedPseudoGraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
+    @loops  = DirectedMultiGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+  end
+
+  def test_new
+    assert_equal Digraph[1,2, 2,3, 3,4], @single
+    assert_equal DirectedPseudoGraph.new([1,2, 2,3, 3,4, 1,2, 2,3]), @dups
+    assert_equal DirectedMultiGraph.new([1,2, 2,3, 3,4, 4,4, 1,2, 2,3]), @loops
+    assert_raise(ArgumentError) {Digraph.new(:loops)}
+    assert_raise(ArgumentError) {Digraph.new(:parallel_edges)}
+    assert_raise(ArgumentError) {DirectedMultiGraph.new(:loops)}
+    assert_raise(ArgumentError) {DirectedMultiGraph.new(:parallel_edges)}
+    assert_raise(ArgumentError) {DirectedPseudoGraph.new(:loops)}
+    assert_raise(ArgumentError) {DirectedPseudoGraph.new(:parallel_edges)}
+    assert_raise(ArgumentError) {Digraph.new(1)}
+    assert_equal @single, Digraph.new(@single)
+    assert_equal @dups, DirectedPseudoGraph.new(@dups)
+    assert_equal @loops, DirectedMultiGraph.new(@loops)
+    assert_equal Digraph[1,2, 2,3, 3,4], Digraph.new(@loops)
+  end
+
+  def test_edges
+    assert_equal 3,@single.edges.size 
+    assert @single.edges.include?(Arc[1,2])
+    assert @single.edges.include?(Arc[2,3])
+    assert @single.edges.include?(Arc[3,4])
+    assert !@single.edges.include?(Arc[4,4])
+    assert @single.edges.include?(Arc[1,2])
+    assert @single.edges.include?(Arc[2,3])
+    assert !@single.edges.include?(Arc[1,3])
+    assert @single.edge?(2,3)
+    assert !@single.edge?(1,4)
+    assert @single.edge?(Arc[1,2])
+    assert !@single.add_edge!(5,5).edge?(5,5)
+    assert !@single.remove_edge!(5,5).edge?(5,5)
+
+    assert_equal 5,@dups.edges.size 
+    assert @dups.edges.include?(MultiArc[1,2])
+    assert @dups.edges.include?(MultiArc[2,3])
+    assert @dups.edges.include?(MultiArc[3,4])
+    assert !@dups.edges.include?(MultiArc[4,4])
+    assert @dups.edges.include?(MultiArc[1,2])
+    assert @dups.edges.include?(MultiArc[2,3])
+    assert !@dups.edges.include?(MultiArc[1,3])
+    assert @dups.edge?(2,3)
+    assert !@dups.edge?(1,4)
+    assert @dups.edge?(MultiArc[1,2])
+    assert !@dups.add_edge!(5,5).edge?(5,5)
+    assert_raise(ArgumentError) { @dups.remove_edge!(5,5) }
+
+    assert_equal 5,@dups.edges.size 
+    assert @loops.edges.include?(MultiArc[1,2])
+    assert @loops.edges.include?(MultiArc[2,3])
+    assert @loops.edges.include?(MultiArc[3,4])
+    assert @loops.edges.include?(MultiArc[4,4])
+    assert @loops.edges.include?(MultiArc[1,2])
+    assert @loops.edges.include?(MultiArc[2,3])
+    assert !@loops.edges.include?(MultiArc[1,3])
+    assert @loops.edge?(2,3)
+    assert !@loops.edge?(1,4)
+    assert @loops.edge?(MultiArc[1,2])
+    assert @loops.add_edge!(5,5).edge?(5,5)
+    assert_raise(ArgumentError) { @loops.remove_edge!(5,5) }
+
+  end
+
+  def test_vertices
+    assert_equal [1,2,3,4],   @single.vertices.sort
+    assert_equal [1,2,3,4,5], @single.add_vertex!(5).sort
+    assert_equal [1,2,4,5],   @single.remove_vertex!(3).sort
+    assert !@single.vertex?(3)
+    assert !@single.edge?(2,3)
+    assert !@single.edge?(3,4)
+    assert @single.add_vertex(:bogus).vertex?(:bogus)
+    assert !@single.add_vertex(:bogus).vertex?(nil)
+    assert !@single.vertex?(:bogus)
+    @single.add_vertex!(:real)
+    assert @single.vertex?(:real)
+    assert @single.add_edge(:here, :there).edge?(Arc[:here, :there])
+    assert !@single.edge?(Arc[:here, :there])
+    assert !@single.vertex?(:here)
+    assert !@single.vertex?(:there)
+    @single.add_edge!(:here, :there)
+    assert @single.edge?(Arc[:here, :there])
+    assert @single.vertex?(:here)
+    assert @single.vertex?(:there)
+  end
+
+  def test_properties
+    assert @single.directed?
+    assert @single.empty? == false
+    assert Digraph.new.empty? == true
+    assert_equal 4, @single.size 
+    assert_equal 4, @dups.size 
+    assert_equal 4, @loops.size 
+    assert_equal 4, @single.num_vertices
+    assert_equal 4, @dups.num_vertices
+    assert_equal 3, @single.num_edges
+    assert_equal 5, @dups.num_edges
+    assert_equal 6, @loops.num_edges
+    assert @single.oriented?
+    @single.remove_vertex!(4)
+    assert @single.oriented?
+    assert !@loops.oriented?
+    @loops.remove_vertex!(4)
+    assert @loops.oriented?
+  end
+
+  def test_merge
+    @dups.merge(@single)
+    assert_equal 8, @dups.num_edges
+    assert_equal [1,2,3,4],   @dups.vertices.sort
+  end
+
+  def test_operators
+    result = @single + Arc[3,2] 
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 4, result.size 
+    assert_equal 4, result.num_edges
+
+    result = @single + 5
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 5, result.size 
+    assert_equal 3, result.num_edges
+
+    result = @single - Arc[4,4]
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 4, result.size 
+    assert_equal 3, result.num_edges
+
+    e = @loops.edges.detect{|e| e.source == 4 and e.target == 4}
+    result = @loops - e
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 4, result.size 
+    assert_equal 5, result.num_edges
+
+    result = @single - 4
+    assert_equal 4, @single.size
+    assert_equal 3, @single.num_edges
+    assert_equal 3, result.size 
+    assert_equal 2, result.num_edges
+    
+    @single << Arc[6,1]
+    assert_equal 5, @single.size
+    assert_equal 4, @single.num_edges
+    assert @single.edge?(6,1)
+  end
+
+  def test_reversal
+    reverse = @single.reversal
+    assert [1,2,3,4], reverse.vertices.sort
+    assert reverse.edge?(2,1)
+    assert reverse.edge?(3,2)
+    assert reverse.edge?(4,3)
+    assert !reverse.edge?(4,4)
+    assert 3, reverse.num_edges
+    reverse = @loops.reversal
+    assert reverse.edge?(4,4)
+  end
+
+  def test_complement
+    complement = @single.complement 
+    assert_equal [1,2,3,4], complement.vertices.sort
+    assert !complement.edge?(1,1)
+    assert complement.edge?(1,3)
+    assert complement.edge?(1,4)
+    assert complement.edge?(2,1)
+    assert complement.edge?(2,4)
+    assert complement.edge?(3,1)
+    assert complement.edge?(3,2)
+    assert complement.edge?(4,1)
+    assert complement.edge?(4,2)
+    assert complement.edge?(4,3)
+    assert 9, complement.num_edges
+
+    complement = @loops.complement 
+    assert_equal [1,2,3,4], complement.vertices.sort
+    assert complement.edge?(1,1)
+    assert complement.edge?(1,3)
+    assert complement.edge?(1,4)
+    assert complement.edge?(2,1)
+    assert complement.edge?(2,2)
+    assert complement.edge?(2,4)
+    assert complement.edge?(3,1)
+    assert complement.edge?(3,2)
+    assert complement.edge?(3,3)
+    assert complement.edge?(4,1)
+    assert complement.edge?(4,2)
+    assert complement.edge?(4,3)
+    assert 12, complement.num_edges
+  end
+
+  def test_induced_subgraph
+    induced = @single.induced_subgraph([1,2])
+    assert [1,2], induced.vertices.sort
+    assert induced.edge?(1,2)
+    assert 1, induced.num_edges
+  end
+
+  def test_include
+    assert @single.include?(4)
+    assert @dups.include?(4)
+    assert !@dups.include?(5)
+    assert !@single.include?(5)
+    assert @single.include?(Arc[1,2])
+    assert @dups.include?(Arc[1,2])
+  end
+
+  def test_adjacent
+
+    assert @single.adjacent?(2, Arc[1,2])
+    assert_equal [2], @single.adjacent(1)
+
+    assert_equal [Arc[1,2]], @single.adjacent(1, :type=>:edges)
+    assert_equal [Arc[1,2]], @single.adjacent(1, :type=>:edges, :direction=> :out)
+    assert_equal [Arc[1,2]], @single.adjacent(2, :type=>:edges, :direction=> :in)
+    assert_equal [Arc[1,2],Arc[2,3]], @single.adjacent(2, :type=>:edges, :direction=> :all).sort
+
+    [[{},1], [{:direction => :out},1], [{:direction => :in},2]].each do |h,v|
+      adj = @dups.adjacent(v, h.merge(:type=>:edges))
+      assert_equal 2, adj.size
+      adj.each {|e| assert e.source == 1; assert e.target == 2}
+    end 
+    
+    adj = @dups.adjacent(2, {:type=>:edges,:direction=>:all})
+    assert_equal 4, adj.size
+    adj.each do |e| 
+      assert((e.source==1 and e.target==2) ||
+             (e.source==2 and e.target==3)) 
+    end
+    
+    assert_equal [2],   @single.adjacent(1, :type=>:vertices)
+    assert_equal [2],   @single.adjacent(1, :type=>:vertices, :direction=> :out)
+    assert_equal [1],   @single.adjacent(2, :type=>:vertices, :direction=> :in)
+    assert_equal [1,3], @single.adjacent(2, :type=>:vertices, :direction=> :all)
+
+    assert_equal [3], @single.adjacent(Arc[2,3], :type=>:vertices)
+    assert_equal [3], @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :out)
+    assert_equal [2], @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :in)
+    assert_equal [2,3], @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :all)
+
+    assert_equal [Arc[3,4]], @single.adjacent(Arc[2,3], :type=>:edges)
+    assert_equal [Arc[3,4]], @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :out)
+    assert_equal [Arc[1,2]], @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :in)
+    assert_equal [Arc[1,2],Arc[3,4]], @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :all).sort
+    
+    assert_equal [MultiArc[3,4]], @dups.adjacent(MultiArc[2,3], :type=>:edges)
+    assert_equal [MultiArc[3,4]], @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :out)
+    assert_equal [MultiArc[1,2]]*2, @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :in)
+    assert_equal ([MultiArc[1,2]]*2+[MultiArc[3,4]]), @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :all).sort
+  end
+
+  def test_neighborhood
+    assert_equal [2],    @single.neighborhood(1).sort
+    assert_equal [1,3],  @single.neighborhood(2).sort
+    assert_equal [Arc[1,2], Arc[3,4]], @single.neighborhood(Arc[2,3]).sort
+  end
+
+  def test_degree
+    assert_equal 0, @single.in_degree(1)
+    assert_equal 1, @single.in_degree(2)
+    assert_equal 1, @single.in_degree(4)
+    assert_equal 3, @loops.degree(4)
+    assert_equal 2, @loops.in_degree(4)
+    assert_equal 1, @single.out_degree(1)
+    assert_equal 1, @single.out_degree(2)
+    assert_equal 0, @single.out_degree(4)
+    assert_equal 1, @loops.out_degree(4)
+    assert_equal 0, @single.add_vertex!(6).out_degree(6)
+    assert_equal 0, @single.add_vertex!(7).in_degree(7)
+    assert_equal 1, @single.add_edge!(4,2).out_degree(4)
+    assert_equal 2, @loops.add_edge!(4,2).out_degree(4)
+    assert_equal 2, @single.in_degree(2)
+
+    assert_equal 0, @single.min_in_degree
+    assert_equal 2, @single.max_in_degree
+    assert_equal 0, @single.min_out_degree
+    assert_equal 1, @single.max_out_degree
+
+    assert_equal 0, @loops.min_in_degree
+    assert_equal 2, @loops.max_in_degree
+    assert_equal 1, @loops.min_out_degree
+    assert_equal 2, @loops.max_out_degree
+    assert_equal 4, @loops.degree(2)
+    assert_equal 1, @single.degree(1)
+    assert !@loops.regular?
+    assert !@single.regular?
+    assert !@dups.regular?
+  end
+
+  def test_include
+    assert @single.include?(2)
+    assert !@single.include?(23)
+    assert @single.include?(Arc[1,2])
+    assert !@single.include?(Arc[1,4])
+  end
+
+end