mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/pool.rb

@@ -0,0 +1,91 @@
+# = Pool
+#
+# Generalized object pool implementation. Implemented as a thread
+# safe stack. Exclusive locking is needed both for push and pop.
+#
+# == Author
+#
+# * George Moschovitis
+#
+# == Todo
+#
+# * Could use the SizedQueue/Queue?
+#
+# == Copying
+#
+# Copyright (c) 2004 George Moschovitis
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'thread'
+require 'monitor'
+
+# = Pool
+#
+# Generalized object pool implementation. Implemented as a thread
+# safe stack. Exclusive locking is needed both for push and pop.
+#
+class Pool < Array
+
+  include MonitorMixin
+
+  def initialize
+    super
+    @cv = new_cond()
+  end
+
+  # Add, restore an object to the pool.
+
+  def push(obj)
+    synchronize do
+      super
+      @cv.signal()
+    end
+  end
+
+  # Obtain an object from the pool.
+
+  def pop
+    synchronize do
+      @cv.wait_while { empty? }
+      super
+    end
+  end
+
+  # Obtains an object, passes it to a block for processing
+  # and restores it to the pool.
+
+  def obtain
+    result = nil
+    begin
+      obj = pop()
+      result = yield(obj)
+    ensure
+      push(obj)
+    end
+    return result
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+=begin #testing
+
+=end

data/lib/gems/facets-2.4.5/lib/more/facets/pqueue.rb

@@ -0,0 +1,449 @@
+# = PQueue
+#
+# 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.
+#
+# == Thanks
+#
+#   Rick Bradley 2003/02/02, patch for Ruby 1.6.5. Thank you!
+#
+# == Authors
+#
+# * Olivier Renaud
+# * K.Kodama (Created original PQueue.rb)
+# * Ronald Butler (reated original Heap.rb)
+#
+# == Copying
+#
+# Copyright (c) 2005 K.Kodama, Ronald Butler, Olivier Renaud
+
+# = PQueue
+#
+# 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
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin #test
+
+  require 'test/unit'
+
+  class TC_PQueue < Test::Unit::TestCase
+    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} }
+    end
+
+    def test_top
+      assert_equal(ARY_TEST.max, PQueue.new(ARY_TEST).top)
+      assert_nil(PQueue.new.top)
+    end
+
+    def test_pop
+      sorted_ary = ARY_TEST.sort
+      q = PQueue.new(ARY_TEST)
+      ARY_TEST.size.times do
+        assert_equal(sorted_ary.pop, q.pop)
+      end
+      assert_equal(0, q.size)
+      assert_nil(PQueue.new.pop)
+    end
+
+    def test_insertion
+      q = PQueue.new(ARY_TEST)
+      assert_equal(ARY_TEST.size, q.size)
+
+      ret = q.push(24)
+      assert_equal(q, ret)
+      assert_equal(ARY_TEST.size+1, q.size)
+
+      ret = q.push_all(ARY_TEST_2)
+      assert_equal(q, ret)
+      assert_equal(ARY_TEST.size+1+ARY_TEST_2.size, q.size)
+
+      q = PQueue.new(ARY_TEST)
+      r = PQueue.new(ARY_TEST_2)
+      q.push_all(r)
+      assert_equal(ARY_TEST.size + ARY_TEST_2.size, q.size)
+    end
+
+    def test_clear
+      q = PQueue.new(ARY_TEST).clear
+      assert_equal(q, q.clear)
+      assert_equal(0, q.size)
+    end
+
+    def test_replace
+      q = PQueue.new(ARY_TEST)
+      q.replace(ARY_TEST_2)
+      assert_equal(ARY_TEST_2.size, q.size)
+
+      q = PQueue.new(ARY_TEST)
+      q.replace(PQueue.new(ARY_TEST_2))
+      assert_equal(ARY_TEST_2.size, q.size)
+    end
+
+    def test_inspect
+      assert_equal("<PQueue: size=#{ARY_TEST.size}, top=#{ARY_TEST.max}>",
+                   PQueue.new(ARY_TEST).inspect)
+    end
+
+    def test_to_a
+      q = PQueue.new(ARY_TEST)
+      assert_equal(ARY_TEST.sort.reverse, q.sort)
+      q = PQueue.new(0..4)
+      assert_equal([4,3,2,1,0], q.sort)
+    end
+
+    def pop_array
+      q = PQueue.new(ARY_TEST)
+      assert_equal(ARY_TEST.sort.reverse[0..5], q.pop_array(5))
+      q = PQueue.new(ARY_TEST)
+      assert_equal(ARY_TEST.sort.reverse, q.pop_array)
+    end
+
+    def test_include
+      q = PQueue.new(ARY_TEST + [21] + ARY_TEST_2)
+      assert_equal(true, q.include?(21))
+
+      q = PQueue.new(ARY_TEST - [15])
+      assert_equal(false, q.include?(15))
+    end
+
+    def test_assert_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
+      q = PQueue.new
+      assert_nil(q.replace_top(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)
+      assert_equal(q, h)
+    end
+
+    def test_dup
+      q = PQueue.new(ARY_TEST)
+      assert_equal(q, q.dup)
+    end
+
+    def test_array_copied
+      ary = ARY_TEST.dup
+      q = PQueue.new(ary)
+      q.pop
+      assert_equal(ARY_TEST, ary)
+
+      ary = ARY_TEST.dup
+      q = PQueue.new
+      q.replace(ary)
+      q.pop
+      assert_equal(ARY_TEST, ary)
+
+      ary = ARY_TEST.dup
+      q = PQueue.new([1])
+      q.push_all(ary)
+      q.pop
+      assert_equal(ARY_TEST, ary)
+
+      q = PQueue.new(ARY_TEST)
+      r = q.dup
+      q.pop
+      assert_not_equal(q, r)
+    end
+  end
+
+=end