lazy_priority_queue 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad75f66fb343a6f9ccf9f3d531172bf550c47901
-  data.tar.gz: 454b6fed5f8e191d41c50a35ba90668ef44fe2c5
+  metadata.gz: b680e6b802c52236c0dcca0d886a6972f35d303b
+  data.tar.gz: dbbc45bb9bf1522279ba8ad7c016f584bd98620a
 SHA512:
-  metadata.gz: 6375ce0f1ed00787843eaf642489d069e9f799c331b638b424b5c4c1494c79cc553a71be0a61fa63a706bf17fa810c4da653d73cc6614dc2e2fa9e4cfc7c9c7b
-  data.tar.gz: 07c52e047784873415bc5a1e1d7e47c77d72e32ebcfe4855699002548527489602f05b163a4555a00a1d2eb54a13f2eba52948fee8e1f8ab72687c55cac53a39
+  metadata.gz: 46bfa4d71d535dc4df7da9781df4e7b7d354a343e41b6da429cd9d9aad17b1cf23cbaf7e76962115e17c5ad99cc37e91315b0d0aab7d20d2548eb0f9c022ec06
+  data.tar.gz: e9277abcf22ae9c4db96636a10620f4ec87a4eb5687de440cad4b201311341c4190edd77cd8af69e049a11975e2ff2b3bf3b11f11320b479a17782ab6b88021d

data/lib/lazy_priority_queue.rb

@@ -1,5 +1,4 @@
 class LazyPriorityQueue
-
   Node = Struct.new :element,
                     :key,
                     :rank,
@@ -7,15 +6,18 @@ class LazyPriorityQueue
                     :left_child,
                     :right_sibling
 
-  def initialize top_condition, &heap_property
+  def initialize(top_condition, &heap_property)
+    @top = nil
     @roots = []
     @references = {}
     @top_condition = top_condition
     @heap_property = heap_property
   end
 
-  def enqueue element, key
-    raise 'The provided element already is in the queue.' if @references[element]
+  def enqueue(element, key)
+    if @references[element]
+      raise 'The provided element already is in the queue.'
+    end
 
     node = Node.new element, key, 0
 
@@ -25,17 +27,20 @@ class LazyPriorityQueue
 
     element
   end
-  alias_method :push, :enqueue
-  alias_method :insert, :enqueue
+  alias push enqueue
+  alias insert enqueue
 
-  def change_priority element, new_key
+  def change_priority(element, new_key)
     node = @references[element]
 
     raise 'Element provided is not in the queue.' unless node
 
     test_node = node.clone
     test_node.key = new_key
-    raise 'Priority can only be changed to a more prioritary value.' unless @heap_property[test_node, node]
+
+    unless @heap_property[test_node, node]
+      raise 'Priority can only be changed to a more prioritary value.'
+    end
 
     node.key = new_key
     node = sift_up node
@@ -45,7 +50,7 @@ class LazyPriorityQueue
   end
 
   def peek
-    @top and @top.element
+    @top && @top.element
   end
 
   def dequeue
@@ -66,25 +71,30 @@ class LazyPriorityQueue
     end
 
     @roots = coalesce @roots
-    @top = @roots.inject { |top, node| select top, node }
+    @top = @roots.inject { |top, node| select(top, node) }
 
     element
   end
-  alias_method :pop, :dequeue
+  alias pop dequeue
 
-  def delete element
+  def delete(element)
     change_priority element, @top_condition
     dequeue
   end
 
-  def empty?; @references.empty? end
-  def size; @references.size end
-  alias_method :length, :size
+  def empty?
+    @references.empty?
+  end
+
+  def size
+    @references.size
+  end
+  alias length size
 
   private
 
-  def sift_up node
-    return node unless node.parent and not @heap_property[node.parent, node]
+  def sift_up(node)
+    return node unless node.parent && !@heap_property[node.parent, node]
 
     node.parent.key, node.key = node.key, node.parent.key
     node.parent.element, node.element = node.element, node.parent.element
@@ -95,11 +105,11 @@ class LazyPriorityQueue
     sift_up node.parent
   end
 
-  def select parent_node, child_node
+  def select(parent_node, child_node)
     @heap_property[parent_node, child_node] ? parent_node : child_node
   end
 
-  def coalesce trees
+  def coalesce(trees)
     coalesced_trees = []
 
     while tree = trees.pop
@@ -116,11 +126,21 @@ class LazyPriorityQueue
     coalesced_trees.compact
   end
 
-  def add node_one, node_two
-    raise 'Both nodes must hold the same rank.' if node_one.rank != node_two.rank
-    raise 'Both nodes must be roots (no parents).' if node_one.parent || node_two.parent
+  def add(node_one, node_two)
+    if node_one.rank != node_two.rank
+      raise 'Both nodes must hold the same rank.'
+    end
 
-    adder_node, addend_node = @heap_property[node_one, node_two] ? [node_one, node_two] : [node_two, node_one]
+    if node_one.parent || node_two.parent
+      raise 'Both nodes must be roots (no parents).'
+    end
+
+    adder_node, addend_node =
+      if @heap_property[node_one, node_two]
+        [node_one, node_two]
+      else
+        [node_two, node_one]
+      end
 
     addend_node.parent = adder_node
 
@@ -137,20 +157,24 @@ end
 
 class MinPriorityQueue < LazyPriorityQueue
   def initialize
-    super(-Float::INFINITY) { |parent_node, child_node| parent_node.key <= child_node.key }
+    super(-Float::INFINITY) do |parent_node, child_node|
+      parent_node.key <= child_node.key
+    end
   end
 
-  alias_method :decrease_key, :change_priority
-  alias_method :min, :peek
-  alias_method :extract_min, :dequeue
+  alias decrease_key change_priority
+  alias min peek
+  alias extract_min dequeue
 end
 
 class MaxPriorityQueue < LazyPriorityQueue
   def initialize
-    super( Float::INFINITY) { |parent_node, child_node| parent_node.key >= child_node.key }
+    super(Float::INFINITY) do |parent_node, child_node|
+      parent_node.key >= child_node.key
+    end
   end
 
-  alias_method :increase_key, :change_priority
-  alias_method :max, :peek
-  alias_method :extract_max, :dequeue
+  alias increase_key change_priority
+  alias max peek
+  alias extract_max dequeue
 end

metadata

@@ -1,19 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: lazy_priority_queue
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Matías Battocchia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-12 00:00:00.000000000 Z
-dependencies: []
-description: Lazy priority queue is a pure Ruby priority queue which implements a
-  lazy binomial heap. It supports the change priority operation, being suitable for
-  algorithms like Dijkstra's shortest path and Prim's minimum spanning tree. It can
-  be instantiated as a min-priority queue as well as a max-priority queue.
+date: 2016-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A priority queue which implements a lazy binomial heap. It supports the
+  change priority operation, being suitable for algorithms like Dijkstra's shortest
+  path and Prim's minimum spanning tree. It can be instantiated as a min-priority
+  queue as well as a max-priority queue.
 email: matias@riseup.net
 executables: []
 extensions: []
@@ -22,7 +50,7 @@ files:
 - lib/lazy_priority_queue.rb
 homepage: https://github.com/matiasbattocchia/lazy_priority_queue
 licenses:
-- MIT
+- FreeBSD
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -40,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A priority queue implemented using a lazy binomial heap. It allows change