pqueue 1.0.0 → 2.0.0

data/lib/pqueue/legacy.rb

@@ -0,0 +1,269 @@
+# PQueue, a Priority Queue with array based heap.
+#
+# A priority queue is like a standard queue, except that each inserted
+# elements is given a certain priority, based on the result of the
+# comparison block given at instantiation time. Also, retrieving an element
+# from the queue will always return the one with the highest priority
+# (see #pop and #top).
+#
+# The default is to compare the elements in repect to their #> method.
+# For example, Numeric elements with higher values will have higher
+# priorities.
+#
+class PQueue
+
+  # number of elements
+  attr_reader :size
+  # compare Proc
+  attr_reader :gt
+  attr_reader :qarray #:nodoc:
+  protected :qarray
+
+  # Returns a new priority queue.
+  #
+  # If elements are given, build the priority queue with these initial
+  # values. The elements object must respond to #to_a.
+  #
+  # If a block is given, it will be used to determine the priority between
+  # the elements.
+  #
+  # By default, the priority queue retrieves maximum elements first
+  # (using the #> method).
+  def initialize(elements=nil, &block) # :yields: a, b
+    @qarray = [nil]
+    @size = 0
+    @gt = block || lambda {|a,b| a > b}
+    replace(elements) if elements
+  end
+
+  private
+
+  # Assumes that the tree is a heap, for nodes < k.
+  #
+  # The element at index k will go up until it finds its place.
+  def upheap(k)
+    k2 = k.div(2)
+    v = @qarray[k]
+    while k2 > 0 && @gt[v, @qarray[k2]]
+      @qarray[k] = @qarray[k2]
+      k = k2
+      k2 = k2.div(2)
+    end
+    @qarray[k] = v
+  end
+
+  # Assumes the entire tree is a heap.
+  #
+  # The element at index k will go down until it finds its place.
+  def downheap(k)
+    v = @qarray[k]
+    q2 = @size.div(2)
+    loop {
+      break if k > q2
+      j = 2 * k
+      if j < @size && @gt[@qarray[j+1], @qarray[j]]
+        j += 1
+      end
+      break if @gt[v, @qarray[j]]
+      @qarray[k] = @qarray[j]
+      k = j
+    }
+    @qarray[k] = v;
+  end
+
+
+  # Recursive version of heapify. I kept the code, since it may be
+  # easier to understand than the non-recursive one.
+  #  def heapify
+  #    @size.div(2).downto(1) {|i| h(i)}
+  #  end
+  #  def h(t)
+  #    l = 2 * t
+  #    r = l + 1
+  #    hi = if r > @size || @gt[@qarray[l],@qarray[r]] then l else r end
+  #    if @gt[@qarray[hi],@qarray[t]]
+  #      @qarray[hi], @qarray[t] = @qarray[t], @qarray[hi]
+  #      h(hi) if hi <= @size.div(2)
+  #    end
+  #  end
+
+  # Make a heap out of an unordered array.
+  def heapify
+    @size.div(2).downto(1) do |t|
+      begin
+        l = 2 * t
+        r = l + 1
+        hi = if r > @size || @gt[@qarray[l],@qarray[r]] then l else r end
+        if @gt[@qarray[hi],@qarray[t]]
+          @qarray[hi], @qarray[t] = @qarray[t], @qarray[hi]
+          if hi <= @size.div(2)
+            t = hi
+            redo
+          end # if
+        end #if
+      end #begin
+    end # downto
+  end
+
+  public
+
+  # Add an element in the priority queue.
+  #
+  # The insertion time is O(log n), with n the size of the queue.
+  def push(v)
+    @size += 1
+    @qarray[@size] = v
+    upheap(@size)
+    return self
+  end
+
+  alias :<< :push
+
+  # Return the element with the highest priority and remove it from
+  # the queue.
+  #
+  # The highest priority is determined by the block given at instanciation
+  # time.
+  #
+  # The deletion time is O(log n), with n the size of the queue.
+  #
+  # Return nil if the queue is empty.
+  def pop
+    return nil if empty?
+    res = @qarray[1]
+    @qarray[1] = @qarray[@size]
+    @size -= 1
+    downheap(1)
+    return res
+  end
+
+  # Return the element with the highest priority.
+  def top
+    return nil if empty?
+    return @qarray[1]
+  end
+
+  # Add more than one element at the same time. See #push.
+  #
+  # The elements object must respond to #to_a, or to be a PQueue itself.
+  def push_all(elements)
+    if empty?
+      if elements.kind_of?(PQueue)
+        initialize_copy(elements)
+      else
+        replace(elements)
+      end
+    else
+      if elements.kind_of?(PQueue)
+        @qarray[@size + 1, elements.size] = elements.qarray[1..-1]
+        elements.size.times{ @size += 1; upheap(@size)}
+      else
+        ary = elements.to_a
+        @qarray[@size + 1, ary.size] = ary
+        ary.size.times{ @size += 1; upheap(@size)}
+      end
+    end
+    return self
+  end
+
+  alias :merge :push_all
+
+
+  # Return top n-element as a sorted array.
+  def pop_array(n=@size)
+    ary = []
+    n.times{ary.push(pop)}
+    return ary
+  end
+
+
+  # True if there is no more elements left in the priority queue.
+  def empty?
+    return @size.zero?
+  end
+
+  # Remove all elements from the priority queue.
+  def clear
+    @qarray.replace([nil])
+    @size = 0
+    return self
+  end
+
+  # Replace the content of the heap by the new elements.
+  #
+  # The elements object must respond to #to_a, or to be a PQueue itself.
+  def replace(elements)
+    if elements.kind_of?(PQueue)
+      initialize_copy(elements)
+    else
+      @qarray.replace([nil] + elements.to_a)
+      @size = @qarray.size - 1
+      heapify
+    end
+    return self
+  end
+
+  # Return a sorted array, with highest priority first.
+  def to_a
+    old_qarray = @qarray.dup
+    old_size = @size
+    res = pop_array
+    @qarray = old_qarray
+    @size = old_size
+    return res
+  end
+
+  alias :sort :to_a
+
+  # Replace the top element with the given one, and return this top element.
+  #
+  # Equivalent to successively calling #pop and #push(v).
+  def replace_top(v)
+    # replace top element
+    if empty?
+      @qarray[1] = v
+      @size += 1
+      return nil
+    else
+      res = @qarray[1]
+      @qarray[1] = v
+      downheap(1)
+      return res
+    end
+  end
+
+  # Return true if the given object is present in the queue.
+  def include?(element)
+    return @qarray.include?(element)
+  end
+
+  # Iterate over the ordered elements, destructively.
+  def each_pop #:yields: popped
+    until empty?
+      yield pop
+    end
+    return nil
+  end
+
+  # Pretty print
+  def inspect
+    "<#{self.class}: size=#{@size}, top=#{top || "nil"}>"
+  end
+
+  ###########################
+  ### Override Object methods
+
+  # Return true if the queues contain equal elements.
+  def ==(other)
+    return size == other.size && to_a == other.to_a
+  end
+
+  private
+
+  def initialize_copy(other)
+    @gt = other.gt
+    @qarray = other.qarray.dup
+    @size = other.size
+  end
+end # class PQueue
+

data/test/test_pqueue.rb

@@ -1,17 +1,30 @@
+require 'microtest'
+require 'ae/legacy'
+
 require 'pqueue'
-require 'test/unit'
 
-class TC_PQueue < Test::Unit::TestCase
-  ARY_TEST = [2,6,1,3,8,15,0,-4,7,8,10]
+class TC_PQueue < MicroTest::TestCase
+  include AE::Legacy::Assertions
+
+  ARY_TEST   = [2,6,1,3,8,15,0,-4,7,8,10]
   ARY_TEST_2 = [25,10,5,13,16,9,16,12]
 
-  def test_initialize
-    assert_nothing_raised { PQueue.new }
-    assert_nothing_raised { PQueue.new([3]) }
-    assert_nothing_raised { PQueue.new(ARY_TEST) }
-    assert_nothing_raised { PQueue.new {|a,b| a<b} }
-    assert_nothing_raised { PQueue.new([3]) {|a,b| a<b} }
-    assert_nothing_raised { PQueue.new(ARY_TEST) {|a,b| a<b} }
+  def test_initialize_empty
+    PQueue.new
+  end
+
+  def test_initialize_single_element
+    PQueue.new([3])
+  end
+
+  def test_initialize_multiple_elements
+    PQueue.new(ARY_TEST)
+  end
+
+  def test_initialize_with_custom_comparison
+    PQueue.new {|a,b| b<=>a}
+    PQueue.new([3]) {|a,b| b<=>a}
+    PQueue.new(ARY_TEST) {|a,b| b<=>a}
   end
 
   def test_top
@@ -36,14 +49,18 @@ class TC_PQueue < Test::Unit::TestCase
     ret = q.push(24)
     assert_equal(q, ret)
     assert_equal(ARY_TEST.size+1, q.size)
+  end
+
+  def test_concat
+    q = PQueue.new(ARY_TEST)
 
-    ret = q.push_all(ARY_TEST_2)
+    ret = q.concat(ARY_TEST_2)
     assert_equal(q, ret)
-    assert_equal(ARY_TEST.size+1+ARY_TEST_2.size, q.size)
+    assert_equal(ARY_TEST.size+ARY_TEST_2.size, q.size)
 
     q = PQueue.new(ARY_TEST)
     r = PQueue.new(ARY_TEST_2)
-    q.push_all(r)
+    q.concat(r)
     assert_equal(ARY_TEST.size + ARY_TEST_2.size, q.size)
   end
 
@@ -70,9 +87,9 @@ class TC_PQueue < Test::Unit::TestCase
 
   def test_to_a
     q = PQueue.new(ARY_TEST)
-    assert_equal(ARY_TEST.sort.reverse, q.sort)
+    assert_equal(ARY_TEST.sort, q.to_a)
     q = PQueue.new(0..4)
-    assert_equal([4,3,2,1,0], q.sort)
+    assert_equal([0,1,2,3,4], q.to_a)
   end
 
   def pop_array
@@ -90,20 +107,20 @@ class TC_PQueue < Test::Unit::TestCase
     assert_equal(false, q.include?(15))
   end
 
-  def test_assert_equal
+  def test_equal
     assert_equal(PQueue.new, PQueue.new)
     assert_equal(PQueue.new(ARY_TEST), PQueue.new(ARY_TEST.sort_by{rand}))
   end
 
-  def test_replace_top
+  def test_swap
     q = PQueue.new
-    assert_nil(q.replace_top(6))
+    assert_nil(q.swap(6))
     assert_equal(6, q.top)
 
     q = PQueue.new(ARY_TEST)
     h = PQueue.new(ARY_TEST)
     q.pop; q.push(11)
-    h.replace_top(11)
+    h.swap(11)
     assert_equal(q, h)
   end
 
@@ -126,7 +143,7 @@ class TC_PQueue < Test::Unit::TestCase
 
     ary = ARY_TEST.dup
     q = PQueue.new([1])
-    q.push_all(ary)
+    q.concat(ary)
     q.pop
     assert_equal(ARY_TEST, ary)
 

metadata

@@ -1,89 +1,99 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: pqueue
-version: !ruby/object:Gem::Version 
-  version: 1.0.0
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
 platform: ruby
-authors: 
-- K.Kodama
+authors:
+- K. Kodama
 - Ronald Butler
 - Olivier Renaud
 - Rick Bradley
-- Trans <transfire@gmail.com>
+- Thomas Sawyer
 autorequire: 
 bindir: bin
 cert_chain: []
+date: 2011-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &27756040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *27756040
+- !ruby/object:Gem::Dependency
+  name: microtest
+  requirement: &27755500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *27755500
+- !ruby/object:Gem::Dependency
+  name: ae
+  requirement: &27755000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *27755000
+description: ! 'A priority queue is like a standard queue, except that each inserted
+  elements
 
-date: 2009-07-05 00:00:00 -04:00
-default_executable: 
-dependencies: []
+  is given a certain priority, based on the result of the comparison block given
 
-description: |-
-  A priority queue is like a standard queue, except that each inserted
-  elements is given a certain priority, based on the result of the
-  comparison block given at instantiation time. Retrieving an element
-  from the queue will always return the one with the highest priority.
-email: 
-executables: []
+  at instantiation time. Retrieving an element from the queue will always return
 
+  the one with the highest priority.'
+email:
+- transfire@gmail.com
+executables: []
 extensions: []
-
-extra_rdoc_files: 
-- README
-- MANIFEST
-- RELEASE
-- LICENSE
-- HISTORY
-files: 
-- test/test_pqueue.rb
-- RELEASE
-- LICENSE
-- README
-- HISTORY
-- meta/created
-- meta/repository
-- meta/homepage
-- meta/summary
-- meta/abstract
-- meta/package
-- meta/title
-- meta/released
-- meta/version
-- meta/license
-- meta/authors
-- meta/project
+extra_rdoc_files:
+- HISTORY.rdoc
+- README.rdoc
+- COPYING.rdoc
+files:
+- .ruby
+- lib/pqueue/legacy.rb
 - lib/pqueue.rb
-- MANIFEST
-has_rdoc: true
-homepage: http://death.rubyforge.org/
+- test/test_pqueue.rb
+- HISTORY.rdoc
+- README.rdoc
+- COPYING.rdoc
+homepage: http://rubyworks.github.com/pqueue
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --inline-source
-- --title
-- pqueue api
-- --main
-- README
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: death
-rubygems_version: 1.3.4
+rubyforge_project: 
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: A priority queue is like a standard queue, except that each inserted
-test_files: 
-- test/test_pqueue.rb
+summary: Queue of Prioritized Elements
+test_files: []