abstract_graph 1.1.0 → 1.2.1

data/lib/abstract_graph/composition/vertex.rb

@@ -8,6 +8,11 @@ module AbstractGraph
       attr_reader :name
       attr_accessor :value
 
+      # d: Set the name of vertex.
+      # a: Throw an ArgumentError if the name is not a string
+      # t: constant
+      # p: name should be string
+      # r: The name
       def name=(name)
         raise ArgumentError if name.class != String
         @name = name
@@ -18,4 +23,3 @@ module AbstractGraph
 end
 
 require "abstract_graph/composition/vertex/initialize"
-require "abstract_graph/composition/vertex/delete"

data/lib/abstract_graph/composition/vertex/initialize.rb

@@ -4,6 +4,12 @@ module AbstractGraph
   module Composition
     class Vertex
 
+      # d: Create a vertex object with a name.
+      # a:
+      # t: constant
+      # p: name is the name of our vertex, default to "",
+      #   optional value that can be tracked
+      # r: The vertex
       def initialize (name="", value=nil)
         @name = name
         @value = value

data/lib/abstract_graph/graph.rb

@@ -31,3 +31,4 @@ require "abstract_graph/graph/merge_vertices"
 require "abstract_graph/graph/get_edge_name"
 require "abstract_graph/graph/templates"
 require "abstract_graph/graph/split_vertex"
+require "abstract_graph/graph/connected"

data/lib/abstract_graph/graph/add_edge.rb

@@ -3,14 +3,15 @@
 module AbstractGraph
   class Graph
 
-    # add a vertex named s to the graph joining
-    #   the vertices named v1 and v2
-    # p: String s represents name
-    #    Vertex name v1 and v2 are the two vertices
-    # r: errors when v1, v2 doesn't exist, loop, or multiple edge
+    # d: Add an edge to graph.
+    # a: Ensure the two vertices exist, then add the edge and check it's not coincident with any
+    #   other edge.
+    # t: |edges|
+    # p: s is name of edge, v1 and v2 are names of the two vertices
+    # r: returns the graph itself
     def add_edge( s, v1, v2 )
-      v1 = @vertices[v1] or return nil
-      v2 = @vertices[v2] or return nil
+      v1 = @vertices.find(v1) or return nil
+      v2 = @vertices.find(v2) or return nil
 
       raise Exception.new( "AddEdge: Same vertices passed, #{v1.name}" ) if v1 == v2
 
@@ -18,7 +19,7 @@ module AbstractGraph
       edge = Edge.new s, v1, v2
 
       # check if it's an multiple edge
-      @edges.each_value do |e|
+      @edges.each do |e|
         raise Exception.new( "AddEdge: Multiple edge being added between #{v1.name}, #{v2.name}" ) if e.is_coincident? edge
       end
 

data/lib/abstract_graph/graph/add_vertex.rb

@@ -3,8 +3,11 @@
 module AbstractGraph
   class Graph
 
-    # add a vertex named s to the graph
-    # p: String s represents the name of the wanted vertex
+    # d: Add a vertex to graph.
+    # a: Adds the new vertex.
+    # t: constant
+    # p: s is the name of the vertex
+    # r: returns the graph itself
     def add_vertex( s )
       # create the vertex
       vertex = Vertex.new s

data/lib/abstract_graph/graph/adjacency_list.rb

@@ -3,11 +3,16 @@
 module AbstractGraph
   class Graph
 
-    # return the adjacent vertices in of a vertex
-    # p: String s represents the name of the query vertex
+    # d: Return adjacent vertices
+    # a: Go through the edges and collect all the vertex names, subtracting our own. Thus, only the
+    #   'vertices' tuples that have one vertex left are adjacent since the other vertex got deleted.
+    #   Then, we can use the remaining array and return it.
+    # t: |edges|
+    # p: s is the name of vertex
+    # r: returns nil if nothing, returns array of adjacent vertices' names
     def adjacency_list( s )
       # this collects all the edges at first
-      result = @edges.collect do |id,e|
+      result = @edges.collect do |e|
         e.vertices.collect do |v|
           v.name
         end - [s]

data/lib/abstract_graph/graph/change_edge_name.rb

@@ -3,11 +3,13 @@
 module AbstractGraph
   class Graph
 
-    # changes an edge name to another valid name
-    # p: String s represents the current edge we want to rename
-    #    String snew is what we want to rename the edge to
+    # d: Change the name of an edge
+    # a: Changes the name of an edge by checking existing names and then adding our own
+    # t: t(rename), which is |edges + vertex|
+    # p: s is current name of edge, snew is requested name of edge
+    # r: returns graph if everything goes well, nil if it failed
     def change_edge_name( s, snew )
-      return nil if @edges.rename(s, snew).nil?
+      return nil unless @edges.rename(s, snew)
       self
     end
 

data/lib/abstract_graph/graph/change_vertex_name.rb

@@ -3,9 +3,11 @@
 module AbstractGraph
   class Graph
 
-    # changes a vertex name to another valid name
-    # p: String s represents the current vertex we want to rename
-    #    String snew is what we want to rename the vertex to
+    # d: Change the name of an vertex
+    # a: Changes the name of an vertex by checking existing names and then adding our own
+    # t: t(rename), which is |edges + vertex|
+    # p: s is current name of vertex, snew is requested name of vertex
+    # r: returns graph if everything goes well, nil if it failed
     def change_vertex_name( s, snew )
       return nil if @vertices.rename(s, snew).nil?
       self

data/lib/abstract_graph/graph/connected.rb

@@ -0,0 +1,36 @@
+# required in "abstract_graph/graph"
+
+module AbstractGraph
+  class Graph
+
+    # d: Check if graph is connected
+    # a: Do a depth first search. So we push the first vertex, and then keep trying to go to adjacent
+    #   vertices until all of them are seen. In the end, check if the list of seen vertices is the
+    #   same as the complete vertex list.
+    # t: |vertices| * t(adjacency_list) which is |vertices| * |edges|
+    # p: none
+    # r: returns true if graph is connected, false otherwise
+    def connected?
+      return true if @vertices.empty?
+      seen = []
+      toSee = [@vertices.first.name]
+
+      # go through vertices and if we seen them, don't inspect them
+      # essentially does a depth first search
+      while !toSee.empty? do
+        inspect = toSee.pop
+        seen << inspect
+
+        adjacentVertices = adjacency_list( inspect )
+        break if adjacentVertices.nil?
+
+        # add adjacent vertices if they're not in any of the seen lists
+        adjacentVertices.each do |v|
+          toSee << v if !seen.include?( v ) && !toSee.include?( v )
+        end
+      end
+      seen.size == @vertices.size
+    end
+
+  end
+end

data/lib/abstract_graph/graph/delete_edge.rb

@@ -3,15 +3,16 @@
 module AbstractGraph
   class Graph
 
-    # delete an edge in a replicated graph
-    # p: String s represents the name of the edge
+    # d: Delete an edge.
+    # a: Deletes the edge.
+    # t: constant
+    # p: s is the edge name
+    # r: graph itself
     def delete_edge( s )
       other = self.dup
       other.delete_edge! s
     end
 
-    # delete an edge in a current graph
-    # p: String s represents the name of the edge
     def delete_edge!( s )
       @edges.delete s
       self

data/lib/abstract_graph/graph/delete_vertex.rb

@@ -3,15 +3,16 @@
 module AbstractGraph
   class Graph
 
-    # delete a vertex in a new graph
-    # p: String s represents the name of the vertex
+    # d: Delete an vertex.
+    # a: Deletes the vertex.
+    # t: constant
+    # p: s is the vertex name
+    # r: graph itself
     def delete_vertex( s )
       other = self.dup
       other.delete_vertex! s
     end
 
-    # delete a vertex in a current graph
-    # p: String s represents the name of the vertex
     def delete_vertex!( s )
       @vertices.delete s
       self

data/lib/abstract_graph/graph/dup.rb

@@ -3,15 +3,20 @@
 module AbstractGraph
   class Graph
 
-    # does a deep copy of the graph
+    # d: Copies the graph.
+    # a: Does a deep copy, but does not dup vertex/edge so modifying them will affect both graphs.
+    #   Copies vertices then edges.
+    # t: |vertices| + |edges|
+    # p: none
+    # r: returns the copy graph
     def dup
       other = self.class.new
       # cannot call UniqueNameCollection#dup because we'll lose
       # link data
-      @vertices.each_value do |v|
+      @vertices.each do |v|
         other.vertices.add v
       end
-      @edges.each_value do |e|
+      @edges.each do |e|
         other.edges.add e
       end
       other

data/lib/abstract_graph/graph/get_edge_name.rb

@@ -3,13 +3,16 @@
 module AbstractGraph
   class Graph
 
-    # returns the edge connecting v1 and v2, if there is no
-    #   edge, then it returns nil
-    # p: String v1, v2 represents the names of the vertices
+    # d: Returns the edge name given two vertex names.
+    # a: Goes through all the edges and see if any of them have the same vertices as
+    #   the ones we are requesting.
+    # t: |edges|
+    # p: the names of the two vertices
+    # r: nil if edge if nothing, name of edge(string) if found
     def get_edge_name( v1, v2 )
       vertices = [v1, v2].sort!
 
-      @edges.each_value do |e|
+      @edges.each do |e|
         eVertices = e.vertices.map do |v|
           v.name
         end.sort

data/lib/abstract_graph/graph/has_edge.rb

@@ -3,10 +3,13 @@
 module AbstractGraph
   class Graph
 
-    # returns whether there exists a edge with name string
-    # p: String s represents name of edge
+    # d: Checks if graph has the edge.
+    # a: Run find on @edges and existance it.
+    # t: constant
+    # p: name of edge
+    # r: true/false depending if edge with name s exists
     def has_edge?( s )
-      @edges.has_key? s || false
+      !(@edges.find s).nil?
     end
 
   end

data/lib/abstract_graph/graph/has_vertex.rb

@@ -3,10 +3,13 @@
 module AbstractGraph
   class Graph
 
-    # returns whether there exists a vertex with name string
-    # p: String s represents name of query vertex
+    # d: Checks if the graph has the vertex.
+    # a: Run find on @vertices and existance it.
+    # t: constant
+    # p: name of vertex
+    # r: true/false depending if vertex with name s exists
     def has_vertex?( s )
-      @vertices.has_key? s || false
+      !(@vertices.find s).nil?
     end
 
   end

data/lib/abstract_graph/graph/initialize.rb

@@ -3,7 +3,11 @@
 module AbstractGraph
   class Graph
 
-    # public constructor
+    # d: Initializes a graph
+    # a: Creates a vertex and edge UNC and links them to share namespace
+    # t: constant
+    # p:
+    # r: new graph
     def initialize
 
       @vertices = UniqueNameCollection.new

data/lib/abstract_graph/graph/is_adjacent.rb

@@ -3,17 +3,19 @@
 module AbstractGraph
   class Graph
 
-    # returns whether or not v1 and v2 are joined by an edge
-    # p: String v1, v2 represents the names of the vertices
+    # d: Check if two vertices are adjacent.
+    # a: Go through the edges and check if any of the edges have the same vertices as the
+    #   two query vertices
+    # t: |edges|
+    # p: v1 and v2 are the names of the vertices
+    # r: true if the vertices are adjacent, false otherwise
     def is_adjacent?( v1, v2 )
       vertices = [v1, v2].sort!
 
-      ( @edges.each_value.find do |e|
-        vertices == e.vertices.map do |v|
-          v.name
-        end.sort
+      # note find is overridden on uniqueNameCollection
+      ( @edges.each.find do |e|
+        vertices == e.vertices.map(&:name).sort
       end && true ) || false
-
     end
 
   end

data/lib/abstract_graph/graph/merge_vertices.rb

@@ -3,17 +3,20 @@
 module AbstractGraph
   class Graph
 
-    # returns a replicated graph where the vertices with names
-    #   v1 and v2 merge together to a vertex named vmerged and
-    #   the edges that were adjacent to v1 and v2 are now
-    #   adjacent to vmerged
+    # d: Merges vertices together so that any edges are connected to merged vertex
+    # a: First create a list of all edges within the vertices, they will be deleted.
+    #   Next create a list of edges to create which will be connected to the final
+    #   vertex. This is done by finding the remaining edges connected to the vertices.
+    #   Finally, delete the vertices, add the new vertex, and add the edges.
+    # t: |vertices| * |edges|
     # p: (Array, String)
-    #      array is the string names of vertices to merge together
-    #      string is the name of the final vertex
+    #   array is the string names of vertices to merge together
+    #   string is the name of the final vertex
     #    (String, String, String)
-    #      first two strings are the vertices to merge together
-    #      last string is the name of the merged vertex
-    # e: the edges prioritize v1 to v2 if there are any conflicts
+    #   first two strings are the vertices to merge together
+    #   last string is the name of the merged vertex
+    # r: the graph itself
+    # *: the edges prioritize v1 to v2 if there are any conflicts
     def merge_vertices( *args )
       other = self.dup
       other.merge_vertices!( *args )
@@ -21,7 +24,6 @@ module AbstractGraph
 
     # same as before except operates on the current graph
     def merge_vertices!( *args )
-
       # create a list of vertices we want to merge
       mergeV = []
       if args[0].class == Array
@@ -36,7 +38,7 @@ module AbstractGraph
         # do not need to go through the array of vertices
         edgesInBetween << get_edge_name( args[0], args[1] )
       else
-        edgesInBetween = @edges.values.collect do |e|
+        edgesInBetween = @edges.collect do |e|
           e.name if ( e.vertices.map do |v|
             v.name
           end & mergeV ).count == 2
@@ -51,15 +53,15 @@ module AbstractGraph
       # get the list of connections we want vmerged to be merged with
       finalConnections = {}
       mergeV.reverse.each do |vCheck|
-        @edges.each do |name, e|
+        @edges.each do |e|
           [0,1].each do |edgeVId|
 
             # check if the edge contains our vertex
             if e.vertices[edgeVId].name == vCheck
               otherVertex = e.vertices[(edgeVId+1)%2].name
               # track the vertex with the edge name
-              finalConnections[otherVertex] = name
-              delete_edge! name
+              finalConnections[otherVertex] = e.name 
+              delete_edge! e.name 
             end
 
           end

data/lib/abstract_graph/graph/split_vertex.rb

@@ -3,10 +3,13 @@
 module AbstractGraph
   class Graph
 
-    # returns a replicated graph where all the vertices are the same but one
-    #   gets split and all it's adjacent vertices are now connected to two replaced vertices
-    # p: String s the name of the vertex that will be split into vertexName-1 and vertexName-2
-    #     all adjacent edges will also be split and adjacent to the correct vertex
+    # d: Split a vertex into two and assign adjacent to each of the vertices.
+    # a: Gathers a list of adjacent vertices by going through the edges, then
+    #   deletes the vertex and all the adjacent edges. Then goes back, creates
+    #   two vertices, and recreates all the adjacent edges.
+    # t: |edges|
+    # p: name of vertex to split
+    # r: graph itself
     def split_vertex( s )
       other = self.dup
       other.split_vertex!( s )
@@ -15,10 +18,10 @@ module AbstractGraph
 
     # same as before except operates on the current graph
     def split_vertex!( s )
-      adjacentVertices = @edges.dup.keep_if do |id, e|
+      adjacentVertices = @edges.dup.keep_if do |e|
         e.vertices.collect(&:name).include? s
-      end.collect do |id, e|
-        [id, ( e.vertices.collect(&:name) - [s] )[0] ]
+      end.collect do |e|
+        [ e.name, ( e.vertices.collect(&:name) - [s] )[0] ]
       end
 
       delete_vertex! s

data/lib/abstract_graph/graph/templates/complete_bipartite_graph.rb

@@ -4,11 +4,13 @@ module AbstractGraph
   class Graph
     class << self
 
-      # create a connected graph with two sets of vertices where
-      #   the two sets only have vertices adjacent to the other set
-      # p: the number of vertices in the two sets. the first set has
-      #   n vertices from 2**(0..n-1) and the second set has m
-      #   vertices from 2**(n**m+n-1)
+      # d: Create a complete bipartite graph K(n,m).
+      # a: It first adds the vertices, then adds the edges. The vertices are named "v(2^i)" from
+      #   the first set being i=2^0..n-1, and the second set i=2^n..m+n-1. The edges are sums "e(i)"
+      #   where i=sum of two vertices
+      # t: n * m * t(add_edge) + max(n,m) * t(add_vertex)
+      # p: n is the number of vertices in the first set, m is number of vertices in second set
+      # r: a complete bipartite graph
       def complete_bipartite_graph n, m
         result = new