iconofthestoneage-doodl 0.0.2 → 0.0.4

data/lib/layout/morph_layout.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'layout/layout'
+
+module Doodl
+  class MorphLayout < Layout
+
+    def initialize(view, layout = RandomLayout)
+      super(view)
+      @target_layout_class = layout
+      @steps = 45
+      @motion = :retard
+    end
+
+    def init(graph)
+      if graph.node_data(:layout)
+        @source = graph.node_data(:layout).clone
+      else
+        sl = RandomLayout.new(@view)
+        sl.graph = graph
+        sl.layout
+        @source = sl.locations.clone
+      end
+      tl = @target_layout_class.new(@view)
+      tl.graph = graph
+      tl.layout
+      @target = tl.locations.clone
+      @locations = graph.node_data(:layout)
+    end
+
+    def dolayout(graph)
+      (1..@steps).each do |step|
+        graph.each_node do |node|
+          @locations[node] = @target[node] + (@source[node]-@target[node]) * dist(step)
+        end
+        changed
+        notify_observers(self)
+      end
+    end
+
+    def dist(step)
+      if @motion == :accelerate
+        accelerate(step)
+      elsif @motion == :retard
+        retard(step)
+      else
+        smooth(step)
+      end
+    end
+
+    def smooth(step)
+       (0.5 * Math.cos((step / @steps.to_f) * Math::PI)) + 0.5
+    end
+
+    def accelerate(step)
+      Math.cos((step / @steps.to_f) * Math::PI/2)
+    end
+
+    def retard(step)
+      1 - Math.sin((step / @steps.to_f) * Math::PI/2)
+    end
+
+  end
+
+end

data/lib/node.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require "forwardable"
+
+module Doodl
+
+  class Node
+  end
+
+  class UndirectedNode < Node
+  extend Forwardable
+    def initialize
+      @edges = []
+    end
+
+    def_delegator(:@edges, :include?, :includes_edge?)
+    def_delegator(:@edges, :<<, :add_edge)
+    def_delegator(:@edges, :delete, :del_edge)
+    def_delegator(:@edges, :each, :each_edge)
+    def_delegator(:@edges, :size, :degree)
+
+    def get_edge(target)
+      @edges.select { |edge| edge.target == target  or edge.source == target}.first
+    end
+
+  end
+
+  class DirectedNode < Node
+  extend Forwardable
+    def initialize
+      @out_edges = []
+    end
+
+    def_delegator(:@out_edges, :include?, :includes_out_edge?)
+    def_delegator(:@out_edges, :<<, :add_out_edge)
+    def_delegator(:@out_edges, :delete, :del_out_edge)
+    def_delegator(:@out_edges, :each, :each_out_edge)
+    def_delegator(:@out_edges, :size, :out_degree)
+
+    def get_edge(target)
+      @out_edges.select { |edge| edge.target == target}.first
+    end
+  end
+
+  class SimpleBidirectionalNode < DirectedNode
+    def initialize
+      super
+      @in_edges = []
+    end
+    def_delegator(:@in_edges, :include?, :includes_in_edge?)
+    def_delegator(:@in_edges, :<<, :add_in_edge)
+    def_delegator(:@in_edges, :delete, :del_in_edge)
+    def_delegator(:@in_edges, :each, :each_in_edge)
+    def_delegator(:@in_edges, :size, :in_degree)
+  end
+
+end

data/lib/shortest_path/all_pair.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Doodl
+
+  module AllPairShortestPaths
+
+  def node_path(source, target)
+    path = []
+    if @dist[[source, target]] != INFINITY
+      while target != source
+        path.unshift target
+        target = @prev[[source, target]]
+      end
+      path.unshift source
+    end
+    return path
+  end
+
+  def edge_path(source, target)
+    path = []
+    if @dist[[source, target]] != INFINITY
+      while target != source
+        path.unshift @graph.get_edge(@prev[[source, target]], target)
+        target = @prev[[source, target]]
+      end
+    end
+    return path
+  end
+
+  def diameter
+    @dist.values.select{ |x| x < INFINITY  }.max
+  end
+end
+
+end

data/lib/shortest_path/bellman_ford.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require "shortest_path/single_source"
+require "facets/infinity"
+require "graph"
+
+module Doodl
+  class BellmanFord
+  include SingleSourceShortestPath
+
+  attr_reader :dist, :prev
+  def initialize(graph, source, weight = nil)
+    raise ArgumentError unless graph.is_a?(Graph)
+    raise ArgumentError unless graph.contains_node?(source)
+    @dist, @prev = {}, {}
+    @graph, @source, = graph, source
+    if weight
+      @weight = weight
+    else
+      @weight = Hash.new(1)
+    end
+    init_maps
+    main_algorithm
+    check_for_negative_cyles
+  end
+
+  private
+
+  def check_for_negative_cyles
+    @graph.each_edge do |e|
+      if @dist[e.source] < INFINITY and @dist[e.target] > (@dist[e.source] + @weight[e])
+        raise ArgumentError, "Graph has negative weight cycles"
+      end
+    end
+  end
+
+  def main_algorithm
+    (1..@graph.num_nodes-1).each do
+      @graph.each_edge do |e|
+        if @dist[e.source] < INFINITY and @dist[e.target] > (@dist[e.source] + @weight[e])
+          @dist[e.target] = @dist[e.source] + @weight[e]
+          @prev[e.target] = e.source
+        end
+      end
+    end
+  end
+
+  def init_maps
+    @graph.each_node do |node|
+      @prev[node] = nil
+      if node == @source
+        @dist[node] = 0
+      else
+        @dist[node] = INFINITY
+      end
+    end
+  end
+
+end
+end

data/lib/shortest_path/dijkstra.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require "graph"
+require "shortest_path/single_source"
+require "facets/infinity"
+require "facets/pqueue"
+
+module Doodl
+
+  class DijkstraShortestPath
+  include SingleSourceShortestPath
+
+  attr_reader :dist, :prev
+
+  def initialize(graph, source, weight_key = nil)
+    raise ArgumentError unless graph.is_a?(Graph)
+    raise ArgumentError unless graph.contains_node?(source)
+    raise ArgumentError if (weight_key and not graph.has_edge_data_key?(weight_key))
+
+    @graph, @source, @weight_key = graph, source, weight_key
+    @dist, @color, @prev = {}, {}, {}
+    @queue = PQueue.new { |x, y| @dist[x] < @dist[y] }
+    @weight = @graph.edge_data(@weight_key)
+
+    init_maps
+    main_algorithm
+  end
+
+  private
+
+  def init_maps
+    @graph.each_node do |node|
+      @dist[node] = INFINITY
+      @prev[node] = nil
+      @color[node] = :white
+    end
+  end
+
+  def main_algorithm
+    @color[@source] = :gray
+    @dist[@source] = 0
+    @queue << @source
+    while @queue.size != 0
+      u = @queue.pop
+      @graph.each_adjacent_edge(u) do |edge|
+        if (u == edge.source)
+          v = edge.target
+        else
+          v = edge.source
+        end
+        if (weight(edge) + @dist[u] < @dist[v])
+          @dist[v] = weight(edge) + @dist[u]
+          @prev[v] = u
+          if @color[v] == :white
+            @color[v] = :grey
+            @queue << v
+          end
+        end
+      end
+      @color[u] = :black
+    end
+  end
+
+  def weight(edge)
+    if (@weight)
+      @weight[edge]
+    else
+      1
+    end
+  end
+
+end
+
+end

data/lib/shortest_path/floyd_warshall.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require "shortest_path/all_pair"
+
+require "facets/infinity"
+require "graph"
+
+module Doodl
+
+  class FloydWarshall
+  include AllPairShortestPaths
+
+  attr_reader :dist, :prev
+
+  def initialize(graph, weight_key = nil)
+    raise ArgumentError unless graph.is_a?(Graph)
+    raise ArgumentError if (weight_key and not graph.has_edge_data_key?(weight_key))
+
+    @graph, @weight_key = graph, weight_key
+    @dist, @prev = {}, {}
+    init_distance
+    main_algorithm
+  end
+
+  private
+
+  def main_algorithm
+    @graph.each_node do |k|
+      @graph.each_node do |i|
+        @graph.each_node do |j|
+          if (@dist[[i,k]] < INFINITY and @dist[[k,j]] < INFINITY)
+            if (@dist[[i,k]] + @dist[[k,j]]) < @dist[[i,j]]
+              @dist[[i,j]] = @dist[[i,k]] + @dist[[k,j]]
+              @prev[[i,j]] = k
+              # @dist[[i, j]] = [@dist[[i,j]], @dist[[i,k]] + @dist[[k,j]]].min
+            else
+
+            end
+
+          end
+        end
+      end
+    end
+  end
+
+  def init_distance
+    @graph.each_node do |n|
+      @graph.each_node do |m|
+        edge = @graph.get_edge(n, m)
+        if edge
+          @dist[[n, m]] = weight(edge)
+          @prev[[n, m]] = n
+        elsif n==m
+          @dist[[n,m]] = 0
+        else
+          @dist[[n, m]] = INFINITY
+        end
+      end
+    end
+  end
+
+  def weight(edge)
+    1
+  end
+
+end
+
+end

data/lib/shortest_path/johnson_all_pair.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require "shortest_path/all_pair"
+require "shortest_path/bellman_ford"
+require "shortest_path/dijkstra"
+
+module Doodl
+
+  class JohnsonAllPairShortestPaths
+  include AllPairShortestPaths
+
+  attr_reader :dist, :prev
+
+  def initialize(graph, weight = nil)
+    raise ArgumentError unless graph.is_a?(Graph)
+
+    @graph = graph
+    @prev, @dist = {}, {}
+    if weight
+      @weight = weight
+    else
+      @weight = Hash.new(1)
+    end
+    @extra_node = @graph.add_node
+    add_edges_to_extra_node
+    re_weight
+    find_shortest_paths
+
+  end
+
+  private
+
+  def add_edges_to_extra_node
+    @graph.each_node do |node|
+      if node != @extra_node
+        edge = @graph.add_edge(@extra_node, node)
+        @weight[edge] = 0
+      end
+    end
+  end
+
+  def re_weight
+    @bf_weight = @graph.attach_edge_data(self)
+    bf = BellmanFord.new(@graph, @extra_node, @weight)
+    @graph.del_node(@extra_node)
+    @graph.each_edge do |edge|
+      @bf_weight[edge] = @weight[edge] + bf.dist[edge.source] - bf.dist[edge.target]
+    end
+  end
+
+  def find_shortest_paths
+    @graph.each_node do |source|
+      dsp = DijkstraShortestPath.new(@graph, source, self)
+      @graph.each_node do |target|
+        @dist[[source, target]] = dsp.dist[target]
+        @prev[[source, target]] = dsp.prev[target]
+      end
+    end
+    @graph.detach_edge_data(self)
+  end
+
+end
+
+end

data/lib/shortest_path/single_source.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Doodl
+
+  module SingleSourceShortestPath
+
+    def node_path_to(node)
+      path = []
+      if @dist[node] != INFINITY
+        while node != @source
+          path.unshift node
+          node = @prev[node]
+        end
+        path.unshift @source
+      end
+      return path
+    end
+
+    def edge_path_to(node)
+      path = []
+      if @dist[node] != INFINITY
+        while node != @source
+          path.unshift @graph.get_edge(@prev[node], node)
+          node = @prev[node]
+        end
+      end
+      return path
+    end
+
+  end
+
+end