iconofthestoneage-doodl 0.0.2 → 0.0.4

data/lib/connected_components.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require "depth_first_search"
+
+module Doodl
+  class ConnectedComponents
+
+    attr_reader :component
+
+    def initialize(graph, start_node = nil)
+      @component = {}
+      @component_count = 0
+      @dfs = DepthFirstSearch.new(graph, start_node, self)
+    end
+
+    def num_connected_components
+        @component_count
+    end
+
+    def start_node(graph, node)
+      @component_count += 1
+    end
+
+    def discover(graph, node)
+      @component[node] = @component_count
+    end
+
+  end
+end

data/lib/depth_first_search.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module Doodl
+
+  class DepthFirstSearch
+
+    attr_reader :dist, :prev, :list
+
+    def initialize(graph, start_node = nil, visitor = nil, radius = nil)
+      @graph, @start_node, @visitor, @radius = graph, start_node, visitor, radius
+      @color, @prev, @dist = {}, {}, {}
+      @time = 0
+      @list = []
+      init_maps
+      main_algorithm
+    end
+
+    private
+
+    def init_maps
+      @graph.each_node do |node|
+        visit(:init, @graph, node)
+        @color[node] = :white
+        @prev[node] = node
+      end
+    end
+
+    def main_algorithm
+      if (@start_node)
+        visit(:start_node, @graph, @start_node)
+        dfs(@start_node)
+      end
+      @graph.each_node  do |node|
+        if @color[node] == :white
+          visit(:start_node, @graph, node)
+          dfs(node)
+        end
+      end
+    end
+
+    def dfs(node)
+      @color[node] = :gray
+      visit(:discover, @graph, node)
+      @list << node
+      @dist[node] = @time
+      @time += 1
+      if (@radius == nil or @time <= @radius)
+        @graph.each_adjacent(node) do |adj_node, edge|
+          visit(:examine, @graph, edge)
+          if (@color[adj_node] == :white)
+            @prev[adj_node] = node
+            visit(:tree_edge, @graph, edge)
+            dfs(adj_node)
+          elsif (@color[adj_node] == :gray)
+            visit(:back_edge, @graph, edge)
+          elsif (@color[adj_node] == :black)
+            visit(:forward_edge, @graph, edge)
+          end
+        end
+        @color[node] = :black
+        visit(:finish, @graph, node)
+      end
+    end
+
+    def visit(position, *arg)
+      if @visitor.respond_to?(position)
+        @visitor.send(position, *arg)
+      end
+    end
+
+  end
+
+end

data/lib/edge.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Doodl
+
+  class Edge
+    attr_reader :source, :target
+
+    def initialize(source, target)
+      @source = source
+      @target = target
+    end
+
+    def to_s
+      "(#{@source}, #{@target})"
+    end
+
+    def reflexive?
+      @source == @target
+    end
+  end
+
+  class DirectedEdge < Edge
+
+    def ==(obj)
+      obj.respond_to?(:source)  and
+      obj.respond_to?(:target)  and
+      obj.source == self.source and
+      obj.target == self.target
+    end
+
+    def directed?
+      true
+    end
+
+  end
+
+  class UndirectedEdge < Edge
+
+    def ==(obj)
+      (obj.respond_to?(:source) and obj.respond_to?(:target)) and
+      ((obj.source == self.source and obj.target == self.target) or
+      (obj.source == self.target and obj.target == self.source))
+    end
+
+    def eql?(obj)
+      (obj.respond_to?(:source) and obj.respond_to?(:target)) and
+      ((obj.source == self.source and obj.target == self.target) or
+      (obj.source == self.target and obj.target == self.source))
+    end
+
+    def directed?
+      false
+    end
+
+  end
+
+end

data/lib/graph.rb

@@ -0,0 +1,365 @@
+# encoding: utf-8
+
+require "node"
+require "edge"
+require "graph_generator"
+
+require "forwardable"
+require "observer"
+
+module Doodl
+
+  class Graph
+  extend Forwardable
+  include Observable
+  include GraphGenerator
+
+  attr_reader :nodes
+
+  def initialize
+    @nodes = []
+    @node_data = Hash.new
+    @edge_data = Hash.new
+  end
+
+  def directed?
+    raise NotImplementedError
+  end
+  #Convinience
+  def contains_node?(node)
+    @nodes.include?(node)
+  end
+
+  def contains_edge?(edge)
+    raise NotImplementedError
+  end
+
+  def get_edge(source, target)
+    raise NotImplementedError
+  end
+
+  #Attachable User Data
+  def attach_node_data(key, hash = Hash.new)
+    @node_data[key] = hash
+  end
+
+  def detach_node_data(key)
+    @node_data.delete(key)
+  end
+
+  def attach_edge_data(key, hash = Hash.new)
+    @edge_data[key] = hash
+  end
+
+  def detach_edge_data(key)
+    @edge_data.delete(key)
+  end
+
+  def_delegator(:@node_data, :keys, :node_data_keys)
+
+  def_delegator(:@node_data, :[], :node_data)
+
+  def_delegator(:@node_data, :has_key?, :has_node_data_key?)
+
+  def_delegator(:@edge_data, :keys, :edge_data_keys)
+
+  def_delegator(:@edge_data, :[], :edge_data)
+
+  def_delegator(:@edge_data, :has_key?, :has_edge_data_key?)
+
+  #Mutable Graph
+  private
+  def gen_node
+    raise NotImplementedError
+  end
+
+  def gen_edge(source, target)
+    raise NotImplementedError
+  end
+
+  public
+  def add_node(update = false)
+    node = self.gen_node
+    @nodes << node
+    changed if update
+    notify_observers(self)
+    return node
+  end
+
+  def add_edge(source, target)
+    raise NotImplementedError
+  end
+
+  def del_node(node, update = false)
+    raise NotImplementedError
+  end
+
+  def del_edge(edge, update = false)
+    raise NotImplementedError
+  end
+
+  #Node List Graph
+  def_delegator(:@nodes, :each, :each_node)
+
+  def_delegator(:@nodes, :each_with_index, :each_node_with_index)
+
+  def each_node_passing(condition)
+    if block_given?
+      each_node do |node|
+        yield(node) if (condition.call(node))
+      end
+    else
+      raise ArgumentError, "No block given."
+    end
+  end
+
+  def_delegator(:@nodes, :size, :num_nodes)
+
+  #Edge List Graph
+  def each_edge
+    raise NotImplementedError
+  end
+
+  def num_edges
+    @nodes.inject(0) { |memo, node| memo + node.out_degree }
+  end
+
+  def source(edge)
+    edge.source
+  end
+
+  def target(edge)
+    edge.target
+  end
+
+  #Incidence
+  def out_degree(node)
+    node.degree
+  end
+
+  def each_adjacent_edge(node)
+    raise NotImplementedError
+  end
+
+  #Adjacent Graph
+  def each_adjacent_node(node)
+    raise NotImplementedError
+  end
+
+  def to_s
+    nodes = @nodes.inject("") { |memo, o| memo << o.to_s << ", " }
+    edges = ""
+    self.each_edge { |e| edges << e.to_s << ", "}
+    str = ""
+    str << "Graph Type: #{self.class.name}\n"
+    str << "Nodes: [#{nodes.chomp(", ")}]\n"
+    str << "Edges: [#{edges.chomp(", ")}]\n"
+    str << "Attached Node Data Keys: #{@node_data.keys.inspect}\n" if @node_data
+    str << "Attached Edge Data Keys: #{@edge_data.keys.inspect}\n" if @edge_data
+  end
+
+end
+
+  class DirectedGraph < Graph
+
+  def directed?
+    true
+  end
+
+  def includes_edge?(edge)
+    raise ArgumentError unless edge.respond_to?(:source) and edge.respond_to?(:target)
+    contains_node?(edge.source) and contains_node?(edge.target) and edge.source.includes_out_edge?(edge)
+  end
+
+
+  def gen_node
+    DirectedNode.new
+  end
+
+  def gen_edge(source, target)
+    DirectedEdge.new(source, target)
+  end
+
+  def get_edge(source, target)
+    raise ArgumentError, "Source and Target must be member of Graph" unless (@nodes.include?(source) and @nodes.include?(target))
+    source.get_edge(target)
+  end
+
+  def del_node(node, update = false)
+    each_edge do |edge|
+      if (edge.source == node or edge.target == node)
+        source = edge.source
+        source.del_out_edge(edge)
+      end
+    end
+    @nodes.delete(node)
+    changed if update
+    notify_observers(self)
+  end
+
+  def add_edge(source, target, update = false)
+    raise ArgumentError, "Source/Target must be member of graph" unless (@nodes.include?(source) and @nodes.include?(target))
+    edge = DirectedEdge.new(source, target)
+    raise ArgumentError if source.includes_out_edge?(edge)
+    source.add_out_edge(edge)
+    changed if update
+    notify_observers(self)
+    return edge
+  end
+
+  def del_edge(edge, update = false)
+    edge.source.del_out_edge(edge)
+    changed if update
+    notify_observers(self)
+  end
+
+  def each_edge
+    each_node do |source|
+      source.each_out_edge { |edge| yield(edge) }
+    end
+  end
+
+  #Incidence
+  def out_degree(node)
+    node.out_degree
+  end
+
+  def each_adjacent_edge(node)
+    node.each_out_edge { |edge| yield(edge) }
+  end
+
+  def each_adjacent_node(node)
+    each_adjacent_edge(node) { |edge| yield(target(edge)) }
+  end
+
+  def each_adjacent(node)
+    each_adjacent_edge(node) { |edge| yield(target(edge), edge) }
+  end
+
+end
+
+  class SimpleBidirectionalGraph < DirectedGraph
+
+  def gen_node
+    SimpleBidirectionalNode.new
+  end
+
+  def add_edge(source, target, update = false)
+    raise ArgumentError unless (@nodes.include?(source) and @nodes.include?(target))
+    edge = DirectedEdge.new(source, target)
+    raise ArgumentError if (source.includes_out_edge(edge) or target.includes_in_edge?(edge))
+    source.add_out_edge(edge)
+    target.add_in_edge(edge)
+    changed if update
+    notify_observers(self)
+    return edge
+  end
+
+  def each_in_edge(node)
+    node.each_in_edge do |edge|
+      yield(edge)
+    end
+  end
+
+end
+
+  class UndirectedGraph < Graph
+
+  def directed?
+    false
+  end
+
+  def includes_edge?(edge)
+    edge.source.includes_edge?(edge)
+  end
+
+
+  def gen_node
+    UndirectedNode.new
+  end
+
+  def get_edge(source, target)
+    raise ArgumentError, "Source and Target must be member of Graph" unless
+      (@nodes.include?(source) and @nodes.include?(target))
+    source.get_edge(target)
+  end
+
+  def gen_edge(source, target)
+    UndirectedEdge.new(source, target)
+  end
+
+  def del_node(node, update = false)
+    each_edge do |edge|
+      if (edge.source == node or edge.target == node)
+        edge.source.del_edge(edge)
+        edge.target.del_edge(edge)
+      end
+    end
+    @nodes.delete(node)
+    changed if update
+    notify_observers(self)
+  end
+
+  def add_edge(source, target, update = false)
+    raise ArgumentError unless (@nodes.include?(source) and @nodes.include?(target))
+    edge = UndirectedEdge.new(source, target)
+    raise ArgumentError if (source.includes_edge?(edge) or target.includes_edge?(edge))
+    source.add_edge(edge)
+    target.add_edge(edge)
+    changed if update
+    notify_observers(self)
+    return edge
+  end
+
+  def del_edge(edge, update = false)
+    edge.source.del_edge(edge)
+    edge.target.del_edge(edge)
+    changed if update
+    notify_observers(self)
+  end
+
+  def each_edge
+    result = []
+    each_node do |source|
+      each_adjacent_edge(source) do |edge|
+        result << edge
+      end
+    end
+    result.uniq.each { |edge| yield(edge) }
+  end
+
+  def each_adjacent_edge(node)
+    node.each_edge { |edge| yield(edge) }
+  end
+
+  def each_adjacent_node(node)
+    each_adjacent_edge(node) do |edge|
+      if target(edge) == node
+        yield(source(edge))
+      else
+        yield(target(edge))
+      end
+    end
+  end
+
+  def each_adjacent(node)
+    each_adjacent_edge(node) do |edge|
+      if target(edge) == node
+        yield(source(edge), edge)
+      else
+        yield(target(edge), edge)
+      end
+    end
+  end
+
+  def num_edges
+    num = 0
+    each_node do |node|
+      num += node.degree
+    end
+    return  num / 2
+  end
+
+end
+
+end