depq 0.5 → 0.6

data/README

@@ -21,7 +21,7 @@ depq is double-ended stable priority queue with priority update operation implem
 * ((<reference manual|URL:http://depq.rubyforge.org/rdoc/classes/Depq.html>))
 * ((<home page on rubyforge|URL:http://depq.rubyforge.org/>))
 * ((<project info on rubyforge|URL:http://rubyforge.org/projects/depq/>))
-* ((<depq on gemcutter|URL:http://gemcutter.org/gems/depq>))
+* ((<depq on rubygems.org|URL:http://rubygems.org/gems/depq>))
 * ((<source repository on github|URL:http://github.com/akr/depq>))
 * ((<raa entry|URL:http://raa.ruby-lang.org/project/depq/>))
 

data/lib/depq.rb

@@ -241,6 +241,11 @@ class Depq
       super value, subpriority, priority
     end
 
+    def initialize_in_queue(value, depq, index)
+      initialize(value, index, depq)
+    end
+    private :initialize_in_queue
+
     def inspect
       prio = self.priority
       if self.value == prio
@@ -377,10 +382,8 @@ class Depq
 
     def internal_inserted(depq, index)
       raise ArgumentError, "already inserted" if in_queue?
-      priority = index_or_priority()
       self.depq_or_subpriority = depq
       self.index_or_priority = index
-      priority
     end
     private :internal_inserted
 
@@ -432,7 +435,6 @@ class Depq
     @heapsize = 0
     @mode = nil
     @totalcount = 0
-    #@subpriority_generator = nil
   end
 
   # :stopdoc:
@@ -456,12 +458,10 @@ class Depq
   end
   private :set_entry
 
-  def delete_entry(i)
-    locator, priority, subpriority = @ary[i*ARY_SLICE_SIZE, ARY_SLICE_SIZE]
-    @ary[i*ARY_SLICE_SIZE, ARY_SLICE_SIZE] = []
-    [locator, priority, subpriority]
+  def delete_last_entry
+    @ary.slice!(@ary.size-ARY_SLICE_SIZE, ARY_SLICE_SIZE)
   end
-  private :delete_entry
+  private :delete_last_entry
 
   def each_entry
     0.upto(self.size-1) {|i|
@@ -479,25 +479,37 @@ class Depq
   private :mode_call
 
   def use_min
-    if @mode == :min || @mode == :interval
+    case @mode
+    when :min, :interval
       if @heapsize < self.size
         @heapsize = mode_call(:heapify, @heapsize)
       end
-    else
+    when :max
+      @mode = :interval
+      @heapsize = mode_call(:heapify)
+    when nil
       @mode = :min
       @heapsize = mode_call(:heapify)
+    else
+      raise "[bug] unexpected mode: #{@mode.inspect}"
     end
   end
   private :use_min
 
   def use_max
-    if @mode == :max || @mode == :interval
+    case @mode
+    when :max, :interval
       if @heapsize < self.size
         @heapsize = mode_call(:heapify, @heapsize)
       end
-    else
+    when :min
+      @mode = :interval
+      @heapsize = mode_call(:heapify)
+    when nil
       @mode = :max
       @heapsize = mode_call(:heapify)
+    else
+      raise "[bug] unexpected mode: #{@mode.inspect}"
     end
   end
   private :use_max
@@ -530,7 +542,6 @@ class Depq
   private :check_locator
 
   def default_subpriority
-    #return @subpriority_generator.call if @subpriority_generator
     self.totalcount
   end
   private :default_subpriority
@@ -538,13 +549,14 @@ class Depq
   def initialize_copy(obj) # :nodoc:
     if defined? @ary
       @ary = @ary.dup
-      0.step(@ary.length-1, ARY_SLICE_SIZE) {|k|
-        i = k / ARY_SLICE_SIZE
+      n = @ary.length / ARY_SLICE_SIZE
+      k = 0
+      n.times {|i|
         loc1 = @ary[k]
-        priority = @ary[k+1]
-        loc2 = Depq::Locator.new(loc1.value, priority)
-        loc2.send(:internal_inserted, self, i)
+        loc2 = Depq::Locator.allocate
+        loc2.send(:initialize_in_queue, loc1.value, self, i)
         @ary[k] = loc2
+        k += ARY_SLICE_SIZE
       }
     end
   end
@@ -684,8 +696,9 @@ class Depq
 
   def internal_set_priority(loc, priority, subpriority)
     check_locator(loc)
-    if @heapsize <= loc.send(:index)
-      set_entry(loc.send(:index), loc, priority, subpriority)
+    index = loc.send(:index)
+    if @heapsize <= index
+      set_entry(index, loc, priority, subpriority)
     else
       mode_heapify
       mode_call(:update_prio, loc, priority, subpriority)
@@ -705,9 +718,10 @@ class Depq
   #   p q.delete_min           #=> 1
   #
   def insert_locator(loc)
+    priority = loc.priority
     subpriority = loc.subpriority || default_subpriority
     i = self.size
-    priority = loc.send(:internal_inserted, self, i)
+    loc.send(:internal_inserted, self, i)
     set_entry(i, loc, priority, subpriority)
     @totalcount += 1
     loc
@@ -961,7 +975,7 @@ class Depq
         set_entry(index, loc2, priority2, subpriority2)
         loc2.send(:index=, index)
       end
-      delete_entry(last)
+      delete_last_entry
       loc.send(:internal_deleted, priority, subpriority)
       loc
     else
@@ -1010,8 +1024,7 @@ class Depq
   #
   def delete_min_priority
     loc = delete_min_locator
-    return nil unless loc
-    [loc.value, loc.priority]
+    loc and [loc.value, loc.priority]
   end
 
   # delete the minimum element in the queue and returns the value.
@@ -1075,8 +1088,7 @@ class Depq
   #
   def delete_max_priority
     loc = delete_max_locator
-    return nil unless loc
-    [loc.value, loc.priority]
+    loc and [loc.value, loc.priority]
   end
 
   # delete the maximum element in the queue and returns the value.
@@ -1138,8 +1150,7 @@ class Depq
   #
   def delete_unspecified_priority
     loc = delete_unspecified_locator
-    return nil unless loc
-    [loc.value, loc.priority]
+    loc and [loc.value, loc.priority]
   end
 
   # delete an element in the queue and returns the value.
@@ -1159,8 +1170,7 @@ class Depq
   #
   def delete_unspecified
     loc = delete_unspecified_locator
-    return nil unless loc
-    loc.value
+    loc and loc.value
   end
 
   # replaces the minimum element.
@@ -1233,7 +1243,7 @@ class Depq
   #   }
   #
   def each_locator # :yield: locator
-    each_entry {|locator, priority|
+    each_entry {|locator,|
       yield locator
     }
     nil
@@ -1241,6 +1251,8 @@ class Depq
 
   # iterate over the values and priorities in the queue.
   #
+  # The iteration order is unspecified.
+  #
   #   q = Depq.new
   #   q.insert "durian", 1
   #   q.insert "banana", 3
@@ -1295,6 +1307,8 @@ class Depq
   #   p Depq.nlargest(3, [5, 2, 3, 1, 4, 6, 7]) {|e| -e } #=> [3, 2, 1]
   #
   def Depq.nlargest(n, iter)
+    raise ArgumentError, "n is negative" if n < 0
+    return [] if n == 0
     limit = (n * Math.log(1+n)).ceil
     limit = 1024 if limit < 1024
     q = Depq.new
@@ -1348,6 +1362,8 @@ class Depq
   #   p Depq.nsmallest(5, [5, 2, 3, 1, 4, 6, 7]) {|e| -e } #=> [7, 6, 5, 4, 3]
   #
   def Depq.nsmallest(n, iter)
+    raise ArgumentError, "n is negative" if n < 0
+    return [] if n == 0
     limit = (n * Math.log(1+n)).ceil
     limit = 1024 if limit < 1024
     q = Depq.new
@@ -1436,6 +1452,102 @@ class Depq
     end
   end
 
+  # search a graph using A* search algorithm.
+  #
+  # The graph is defined by _start_ argument and the given block.
+  # _start_ specifies the start node for searching.
+  # The block should takes a node and return an array of pairs.
+  # The pair is an 2-element array which contains the next node and cost of the given node to the next node.
+  #
+  # The optional argument, _heuristics_ specifies
+  # conservative estimation to goal.
+  # It should be a Hash or a Proc that _heuristics_+[node]+ returns an estimated cost to goal.
+  # The estimated cost must be smaller or equal to the true cost.
+  # If _heuristics_ is not given, Hash.new(0) is used.
+  # This means +Depq.astar_search+ behaves as Dijkstra's algorithm in that case.
+  #
+  # +Depq.astar_search+ returns an enumerator.
+  # It yields 3 values: previous node, current node and total cost between start node to current node.
+  # When current node is start node, nil is given for previous node.
+  #
+  #   #    7    5    1
+  #   #  A--->B--->C--->D
+  #   #  |    |    |    |
+  #   # 2|   4|   1|   3|
+  #   #  |    |    |    |
+  #   #  V    V    V    V
+  #   #  E--->F--->G--->H
+  #   #    3    3    5
+  #   #
+  #   g = {
+  #     :A => [[:B, 7], [:E, 2]],
+  #     :B => [[:C, 5], [:F, 4]],
+  #     :C => [[:D, 1], [:G, 1]],
+  #     :D => [[:H, 3]],
+  #     :E => [[:F, 3]],
+  #     :F => [[:G, 3]],
+  #     :G => [[:H, 5]],
+  #     :H => []
+  #   }
+  #   # This doesn't specify _heuristics_.  So This is Dijkstra's algorithm.
+  #   Depq.astar_search(:A) {|n| g[n] }.each {|prev, curr, cost| p [prev, curr, cost] }
+  #   #=> [nil, :A, 0]
+  #   #   [:A, :E, 2]
+  #   #   [:E, :F, 5]
+  #   #   [:A, :B, 7]
+  #   #   [:F, :G, 8]
+  #   #   [:B, :C, 12]
+  #   #   [:G, :H, 13]  # H found.
+  #   #   [:C, :D, 13]
+  #
+  #   # heuristics using Manhattan distance assuming the goal is H.
+  #   h = {
+  #     :A => 4,
+  #     :B => 3,
+  #     :C => 2,
+  #     :D => 1,
+  #     :E => 3,
+  #     :F => 2,
+  #     :G => 1,
+  #     :H => 0
+  #   }
+  #   # This specify _heuristics_.  So This is A* search algorithm.
+  #   Depq.astar_search(:A, h) {|n| g[n] }.each {|prev, curr, cost| p [prev, curr, cost] }
+  #   #=> [nil, :A, 0]
+  #   #   [:A, :E, 2]
+  #   #   [:E, :F, 5]
+  #   #   [:F, :G, 8]
+  #   #   [:A, :B, 7]
+  #   #   [:G, :H, 13]  # H found.  Bit better than Dijkstra's algorithm.
+  #   #   [:B, :C, 12]
+  #   #   [:C, :D, 13]
+  #
+  # cf. http://en.wikipedia.org/wiki/A*_search_algorithm
+  #
+  def Depq.astar_search(start, heuristics=nil, &find_nexts)
+    Enumerator.new {|y|
+      heuristics ||= Hash.new(0)
+      h = Hash.new {|_, k| h[k] = heuristics[k] }
+      q = Depq.new
+      visited = {start => q.insert([nil, start], h[start])}
+      until q.empty?
+        path, w1 = q.delete_min_priority
+        v1 = path.last
+        w1 -= h[v1]
+        y.yield [path.first, path.last, w1]
+        find_nexts.call(v1).each {|v2, w2|
+          w3 = w1 + w2 + h[v2]
+          if !visited[v2]
+            visited[v2] = q.insert([path.last,v2], w3)
+          elsif w3 < visited[v2].priority
+            visited[v2].update([path.last,v2], w3)
+          end
+        }
+      end
+      nil
+    }
+  end
+
   private
   # :stopdoc:
 
@@ -1465,17 +1577,18 @@ class Depq
   def mm_downheap(i, upper)
     while true
       j = i*2+1
-      k = i*2+2
+      k = j+1
       return if self.size <= j
       if self.size == k
         return if upper.call(i, j)
         swap(i, j)
         i = j
+        return
       else
         return if upper.call(i, j) && upper.call(i, k)
-        loc = upper.call(j, k) ? j : k
-        swap(i, loc)
-        i = loc
+        m = upper.call(j, k) ? j : k
+        swap(i, m)
+        i = m
       end
     end
   end
@@ -1490,7 +1603,7 @@ class Depq
     _, priority, subpriority = get_entry(i)
     last = self.size - 1
     loc.send(:internal_deleted, priority, subpriority)
-    el, pl, sl = delete_entry(last)
+    el, pl, sl = delete_last_entry
     if i != last
       set_entry(i, el, pl, sl)
       el.send(:index=, i)
@@ -1642,10 +1755,10 @@ class Depq
   def itv_maxside(i) i | 1 end
   def itv_parent_minside(j) (j-2)/2 & ~1 end
   def itv_parent_maxside(j) (j-2)/2 | 1 end
-  def itv_child1_minside(i) i &= ~1; (i*2+2) & ~1 end
-  def itv_child1_maxside(i) i &= ~1; (i*2+2) | 1 end
-  def itv_child2_minside(i) i &= ~1; (i*2+4) & ~1 end
-  def itv_child2_maxside(i) i &= ~1; (i*2+4) | 1 end
+  def itv_child1_minside(i) i &= ~1; i*2+2 end
+  def itv_child1_maxside(i) i &= ~1; i*2+3 end
+  def itv_child2_minside(i) i &= ~1; i*2+4 end
+  def itv_child2_maxside(i) i &= ~1; i*2+5 end
 
   def pcmp(i, j)
     ei, pi, si = get_entry(i)
@@ -1672,7 +1785,7 @@ class Depq
         imin = itv_minside(i)
         imax = itv_maxside(i)
         if range.include?(imin) && range.include?(imax)
-          if pcmp(imin, imax) == 0 && scmp(imin, imax) > 0
+          if scmp(imin, imax) > 0 && pcmp(imin, imax) == 0
             swap imin, imax
           end
         end
@@ -1926,7 +2039,7 @@ class Depq
     _, priority, subpriority = get_entry(i)
     last = self.size - 1
     loc.send(:internal_deleted, priority, subpriority)
-    el, pl, sl = delete_entry(last)
+    el, pl, sl = delete_last_entry
     if i != last
       set_entry(i, el, pl, sl)
       el.send(:index=, i)

data/sample/dijkstra.rb

@@ -0,0 +1,43 @@
+# Dijkstra's single source shortest path finding algorithm
+#
+# usage:
+#   ruby -Ilib sample/dijkstra.rb
+
+require 'depq'
+
+def dijkstra_shortest_path(start, edges)
+  h = {}
+  edges.each {|v1, v2, w|
+    (h[v1] ||= []) << [v2, w]
+  }
+  h.default = []
+  q = Depq.new
+  visited = {start => q.insert([start], 0)}
+  until q.empty?
+    path, w1 = q.delete_min_priority
+    v1 = path.last
+    h[v1].each {|v2, w2|
+      if !visited[v2]
+        visited[v2] = q.insert(path+[v2], w1 + w2)
+      elsif w1 + w2 < visited[v2].priority
+        visited[v2].update(path+[v2], w1 + w2)     # update val/prio
+      end
+    }
+  end
+  result = []
+  visited.each_value {|loc|
+    result << [loc.value, loc.priority]
+  }
+  result
+end
+
+E = [
+  ['A', 'B', 2],
+  ['A', 'C', 4],
+  ['B', 'C', 1],
+  ['C', 'B', 2],
+  ['B', 'D', 3],
+  ['C', 'D', 1],
+]
+p dijkstra_shortest_path('A', E)
+

data/sample/exqsort.rb

@@ -0,0 +1,90 @@
+# external quick sort
+#
+# usage:
+#   ruby -Ilib sample/exqsort.rb input-file
+
+require 'tmpdir'
+require 'depq'
+
+NUM_PIVOTS = 1024
+$tmpdir = nil
+$filecount = 0
+
+def partition(input)
+  q = Depq.new
+  fn1 = "#{$tmpdir}/#{$filecount += 1}"
+  fn2 = "#{$tmpdir}/#{$filecount += 1}"
+  fn3 = "#{$tmpdir}/#{$filecount += 1}"
+  open(fn1, "w") {|f1|
+    open(fn3, "w") {|f3|
+      n1 = n2 = n3 = 0
+      input.each_line {|line|
+        line = line.chomp
+        if q.size < NUM_PIVOTS
+          q.insert line
+        else
+          min, max = q.minmax
+          if line <= min
+            f1.puts line
+            n1 += 1
+          elsif line < max
+            q.insert line
+            if n1 < n2
+              f1.puts q.delete_min
+              n1 += 1
+            else
+              f3.puts q.delete_max
+              n3 += 1
+            end
+          else
+            f3.puts line
+            n3 += 1
+          end
+        end
+      }
+    }
+  }
+  open(fn2, "w") {|f2|
+    while !q.empty?
+      f2.puts q.delete_min
+    end
+  }
+  if File.size(fn1) == 0
+    File.delete fn1
+    fn1 = nil
+  end
+  if File.size(fn2) == 0
+    File.delete fn2
+    fn2 = nil
+  end
+  if File.size(fn3) == 0
+    File.delete fn3
+    fn3 = nil
+  end
+  [fn1, fn2, fn3]
+end
+
+def eqs(input)
+  fn1, fn2, fn3 = partition(input)
+  r = []
+  if fn1
+    r.concat(open(fn1) {|f| eqs(f) })
+  end
+  if fn2
+    r << fn2
+  end
+  if fn3
+    r.concat(open(fn3) {|f| eqs(f) })
+  end
+  r
+end
+
+Dir.mktmpdir {|d|
+  $tmpdir = d
+  fns = eqs(ARGF)
+  fns.each {|fn|
+    File.foreach(fn) {|line|
+      puts line
+    }
+  }
+}

data/sample/huffman.rb

@@ -0,0 +1,37 @@
+# Huffman coding
+#
+# usage:
+#   ruby -Ilib sample/huffman.rb input-file
+
+require 'depq'
+
+h = Hash.new(0)
+ARGF.each {|line|
+  line.scan(/\S+/).each {|word|
+    h[word] += 1
+  }
+}
+
+if h.empty?
+  exit
+end
+
+q = Depq.new
+
+h.each {|word, count|
+  q.insert({word => ""}, count)
+}
+
+while 1 < q.size 
+  h0, count0 = q.delete_min_priority
+  h1, count1 = q.delete_min_priority
+  hh = {}
+  h0.each {|w, c| hh[w] = "0" + c }
+  h1.each {|w, c| hh[w] = "1" + c }
+  q.insert hh, count0+count1
+end
+
+hh = q.delete_min
+hh.keys.sort_by {|w| h[w] }.each {|w| puts "#{hh[w]} #{h[w]} #{w.inspect}" }
+
+

data/sample/int-3d.rb

@@ -0,0 +1,48 @@
+# search integers x, y, z from smaller x*y*z where x >= y >= z >= 1.
+#
+# usage:
+#   ruby -Ilib sample/int-3d.rb
+
+require 'depq'
+
+# naive version
+def gen1
+  q = Depq.new
+  q.insert [1, 1,1,1]
+  loop {
+    ary = q.delete_min
+    while q.find_min == ary
+      q.delete_min
+    end
+    yield ary
+    w, x,y,z = ary
+    x1 = x + 1
+    y1 = y + 1
+    z1 = z + 1
+    q.insert [x1*y*z, x1,y,z] if x1 >= y && y >= z
+    q.insert [x*y1*z, x,y1,z] if x >= y1 && y1 >= z
+    q.insert [x*y*z1, x,y,z1] if x >= y && y >= z1
+  }
+end
+
+# faster version
+def gen2
+  q = Depq.new
+  q.insert [1, 1,1,1]
+  loop {
+    ary = q.delete_min
+    yield ary
+    w, x,y,z = ary
+    x1 = x + 1
+    y1 = y + 1
+    z1 = z + 1
+    q.insert [x1*y*z, x1,y,z]
+    q.insert [x*y1*z, x,y1,z] if x == y1
+    q.insert [x*y*z1, x,y,z1] if x == y && y == z1
+  }
+end
+
+gen2 {|w, x,y,z|
+  break if 100 <= w
+  p [w, x,y,z]
+}

data/sample/kruskal.rb

@@ -0,0 +1,55 @@
+# Kruskal's algorithm
+#
+# finds a minimum spanning tree for a connected weighted graph
+#
+# http://en.wikipedia.org/wiki/Kruskal's_algorithm
+#
+# usage:
+#   ruby -Ilib sample/kruskal.rb
+
+require 'depq'
+
+def kruskal(edge_set)
+  q = Depq.new
+  parent = {}
+  edge_set.each {|v1, v2, w|
+    parent[v1] = nil
+    parent[v2] = nil
+    q.insert [v1, v2], w
+  }
+
+  edge_set2 = []
+
+  until q.empty?
+    v1, v2 = q.delete_min
+    r1 = v1
+    r1 = parent[r1] while parent[r1]
+    r2 = v2
+    r2 = parent[r2] while parent[r2]
+    if r1 != r2
+      edge_set2 << [v1, v2]
+      parent[r2] = r1
+    end
+  end
+
+  edge_set2
+end
+
+if $0 == __FILE__
+  E = [
+    ['A', 'B', 7],
+    ['A', 'D', 5],
+    ['B', 'C', 8],
+    ['B', 'D', 9],
+    ['B', 'E', 7],
+    ['C', 'E', 5],
+    ['D', 'E', 15],
+    ['D', 'F', 6],
+    ['E', 'F', 8],
+    ['E', 'G', 9],
+    ['F', 'G', 11],
+  ]
+
+  p kruskal(E)
+  #=> [["A", "D"], ["C", "E"], ["D", "F"], ["A", "B"], ["B", "E"], ["E", "G"]]
+end

data/sample/maze.rb

@@ -0,0 +1,103 @@
+# solve a maze using A* search algorithm
+#
+# usage:
+#   ruby -Isample -Ilib sample/maze.rb
+
+require 'depq'
+
+Pos = Struct.new(:x, :y)
+
+MAZE_MAP = <<'End'
+OOOOOOOOOOOOOOOOOOOOOOOOO
+O         OSO   O       O
+O OOOOOOOOO O O OOO OOO O
+O         O   O   O O   O
+O OOOOOOO OOOOOOO OOO O O
+O     O   O     O     O O
+OOOOO O O OOO OOOOOOOOO O
+OG  O O O   O     O O   O
+O O O O OOO OOO O O O OOO
+O O O O O       O   O   O
+O OOO O OOOOOOOOOOOOOOO O
+O     O                 O
+OOOOOOOOOOOOOOOOOOOOOOOOO
+End
+
+MAZE = MAZE_MAP.lines.map {|line| line.chomp.split(//) }
+
+H = HEIGHT = MAZE.length
+W = WIDTH = MAZE[0].length
+
+MAZE.each_with_index {|line,y|
+  line.each_with_index {|cell,x|
+    if cell == 'S'
+      START = Pos[x,y]
+      MAZE[y][x] = ' '
+    elsif cell == 'G'
+      GOAL = Pos[x,y]
+      MAZE[y][x] = ' '
+    end
+  }
+}
+
+find_nexts4 = proc {|pos|
+  x, y = pos.x, pos.y
+  r = []
+  r << [Pos[x-1,y],1] if 0 < x && MAZE[y][x-1] == ' '
+  r << [Pos[x,y-1],1] if 0 < y && MAZE[y-1][x] == ' '
+  r << [Pos[x+1,y],1] if x < W-1 && MAZE[y][x+1] == ' '
+  r << [Pos[x,y+1],1] if y < H-1 && MAZE[y+1][x] == ' '
+  r
+}
+
+heuristics4 = proc {|pos|
+  x, y = pos.x, pos.y
+  (x-GOAL.x).abs + (y-GOAL.y).abs
+}
+
+find_nexts8 = proc {|pos|
+  x, y = pos.x, pos.y
+  r = []
+  r << [[x-1,y],1] if 0 < x && MAZE[y][x-1] == ' '
+  r << [[x,y-1],1] if 0 < y && MAZE[y-1][x] == ' '
+  r << [[x+1,y],1] if x < W-1 && MAZE[y][x+1] == ' '
+  r << [[x,y+1],1] if y < H-1 && MAZE[y+1][x] == ' '
+  r << [[x-1,y-1],2] if 0 < x && 0 < y && MAZE[y-1][x-1] == ' '
+  r << [[x-1,y+1],2] if 0 < x && y < H-1 && MAZE[y+1][x-1] == ' '
+  r << [[x+1,y-1],2] if x < W-1 && 0 < y && MAZE[y-1][x+1] == ' '
+  r << [[x+1,y+1],2] if x < W-1 && y < H-1 && MAZE[y+1][x+1] == ' '
+  r
+}
+
+heuristics8 = proc {|pos|
+  x, y = pos.x, pos.y
+  (x-GOAL.x).abs + (y-GOAL.y).abs
+}
+
+t1 = Time.now
+searched = {}
+path = Depq.astar_search(START, heuristics4, &find_nexts4).each {|prev, cur, w|
+  searched[cur] = [searched[prev], cur]
+  if cur == GOAL
+    break searched[cur].flatten.compact
+  end
+}
+t2 = Time.now
+p t2-t1
+
+searched.each_key {|pos|
+  x, y = pos.x, pos.y
+  MAZE[y][x] = '.'
+}
+
+path.each {|pos|
+  x, y = pos.x, pos.y
+  MAZE[y][x] = '*'
+}
+
+MAZE[START.y][START.x] = 'S'
+MAZE[GOAL.y][GOAL.x] = 'G'
+
+MAZE.each {|line|
+  puts line.join('')
+}

data/sample/prim.rb

@@ -0,0 +1,78 @@
+# Prim's algorithm
+#
+# finds a minimum spanning tree for a connected weighted graph
+#
+# http://en.wikipedia.org/wiki/Prim's_algorithm
+#
+# usage:
+#   ruby -Ilib sample/prim.rb
+#
+
+require 'depq'
+
+def prim(edge_set)
+  vertex_set1 = {}
+  adj = {}
+  weight = {}
+  edge_set.each {|v1, v2, w|
+    vertex_set1[v1] = true
+    vertex_set1[v2] = true
+    adj[v1] ||= []
+    adj[v1] << v2
+    adj[v2] ||= []
+    adj[v2] << v1
+    weight[[v1, v2]] = weight[[v2, v1]] = w
+  }
+  adj.default = []
+
+  start = vertex_set1.first[0]
+  q = Depq.new
+  vertex_set2 = {start => true}
+  edge_set2 = []
+  prev_locators = {}
+
+  adj[start].each {|v2|
+    prev_locators[v2] = [start, q.insert(v2, weight[[start, v2]])]
+  }
+
+  while vertex_set2.size < vertex_set1.size
+    v2 = q.delete_min
+    v1, _ = prev_locators[v2]
+    prev_locators.delete v2
+    vertex_set2[v2] = true
+    edge_set2 << [v1, v2]
+    adj[v2].each {|v3|
+      next if vertex_set2[v3]
+      if prev_loc = prev_locators[v3]
+        _, loc = prev_loc
+        if weight[[v2, v3]] < loc.priority
+          prev_loc[0] = v2
+          loc.update v3, weight[[v2, v3]]
+        end
+      else
+        prev_locators[v3] = [v2, q.insert(v3, weight[[v2, v3]])]
+      end
+    }
+  end
+  edge_set2
+end
+
+if $0 == __FILE__
+  E = [
+    ['A', 'B', 7],
+    ['A', 'D', 5],
+    ['B', 'C', 8],
+    ['B', 'D', 9],
+    ['B', 'E', 7],
+    ['C', 'E', 5],
+    ['D', 'E', 15],
+    ['D', 'F', 6],
+    ['E', 'F', 8],
+    ['E', 'G', 9],
+    ['F', 'G', 11],
+  ]
+
+  p prim(E)
+  #=> [["A", "D"], ["D", "F"], ["A", "B"], ["B", "E"], ["E", "C"], ["E", "G"]]
+end
+

data/sample/sched.rb

@@ -0,0 +1,68 @@
+# scheduler
+#
+# needs Ruby 1.9.2 for timeout argument of ConditionVariable#wait.
+#
+# usage:
+#   ruby -Ilib sample/sched.rb
+
+require 'depq'
+require 'thread'
+
+class Sched
+  def initialize
+    @q = Depq.new
+    @m = Mutex.new
+    @cv = ConditionVariable.new
+  end
+
+  def sync
+    @m.synchronize { yield }
+  end
+
+  def insert(time, &block)
+    sync {
+      @q.insert block, time
+    }
+  end
+
+  def wait_next_event
+    sync {
+      block, time = @q.find_min_priority
+      now = Time.now
+      if now < time
+        @cv.wait(@m, time - now)
+      end
+      now
+    }
+  end
+
+  def start
+    until sync { @q.empty? }
+      now = wait_next_event
+      loop {
+        block = time = nil
+        sync {
+          raise StopIteration if @q.empty?
+          block, time = @q.find_min_priority
+          raise StopIteration if now < time
+          block, time = @q.delete_min_priority
+        }
+        block.call
+      }
+    end
+  end
+end
+
+if $0 == __FILE__
+  now = Time.now
+  sc = Sched.new
+  Thread.new {
+    sleep 1.5
+    sc.insert(Time.now+1) { p Time.now-now }
+  }
+  sc.insert(now+4) { p Time.now-now }
+  sc.insert(now+3) { p Time.now-now }
+  sc.insert(now+2) { p Time.now-now }
+  sc.insert(now+1) { p Time.now-now }
+  sc.start
+end

data/test/test-depq.rb

@@ -1097,4 +1097,75 @@ class TestDepq < Test::Unit::TestCase
     assert_raise(StopIteration) { e.next }
   end
 
+  def test_mode_min_first
+    q = Depq.new
+    q.insert 1
+    q.insert 2
+    assert_equal(nil, q.instance_eval { @mode })
+    assert_equal(1, q.delete_min)
+    assert_equal(:min, q.instance_eval { @mode })
+    assert_equal(2, q.delete_max)
+    assert_equal(:interval, q.instance_eval { @mode })
+  end
+
+  def test_mode_max_first
+    q = Depq.new
+    q.insert 1
+    q.insert 2
+    assert_equal(nil, q.instance_eval { @mode })
+    assert_equal(2, q.delete_max)
+    assert_equal(:max, q.instance_eval { @mode })
+    assert_equal(1, q.delete_min)
+    assert_equal(:interval, q.instance_eval { @mode })
+  end
+
+  def test_astar
+    g = {
+      :A => [[:B, 7], [:E, 2]],
+      :B => [[:C, 5], [:F, 4]],
+      :C => [[:D, 1], [:G, 1]],
+      :D => [[:H, 3]],
+      :E => [[:F, 3]],
+      :F => [[:G, 3]],
+      :G => [[:H, 5]],
+      :H => []
+    }
+    res = []
+    Depq.astar_search(:A) {|n| g[n] }.each {|prev, curr, cost| res << [prev, curr, cost] }
+    assert_equal(
+      [[nil, :A, 0],
+       [:A, :E, 2],
+       [:E, :F, 5],
+       [:A, :B, 7],
+       [:F, :G, 8],
+       [:B, :C, 12],
+       [:G, :H, 13],
+       [:C, :D, 13]],
+      res)
+
+    # heuristics using Manhattan distance assuming the goal is H.
+    h = {
+      :A => 4,
+      :B => 3,
+      :C => 2,
+      :D => 1,
+      :E => 3,
+      :F => 2,
+      :G => 1,
+      :H => 0
+    }
+    res = []
+    Depq.astar_search(:A, h) {|n| g[n] }.each {|prev, curr, cost| res << [prev, curr, cost] }
+    assert_equal(
+      [[nil, :A, 0],
+       [:A, :E, 2],
+       [:E, :F, 5],
+       [:F, :G, 8],
+       [:A, :B, 7],
+       [:G, :H, 13],
+       [:B, :C, 12],
+       [:C, :D, 13]],
+      res)
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: depq
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '0.6'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-27 00:00:00.000000000 Z
+date: 2011-11-29 00:00:00.000000000 Z
 dependencies: []
 description: ! 'depq is a Double-Ended Priority Queue library.
 
@@ -28,6 +28,14 @@ extra_rdoc_files: []
 files:
 - README
 - lib/depq.rb
+- sample/dijkstra.rb
+- sample/exqsort.rb
+- sample/huffman.rb
+- sample/int-3d.rb
+- sample/kruskal.rb
+- sample/maze.rb
+- sample/prim.rb
+- sample/sched.rb
 - test/test-depq.rb
 homepage: http://depq.rubyforge.org/
 licenses: []