min_max 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d739946dcb0939e2e05893222c927f4dea0eda65da5c0a00156402de3e49c29
-  data.tar.gz: 61b4453a94b93bb2ccefd0787a751cef5d3ef380ac0ed591c73c3b0afddc394b
+  metadata.gz: 012d1e5c570db138f41f8ac8556dde89598878d15fc9176a7006bdd33e5deaf5
+  data.tar.gz: 70a8c3a7bb6afdaf23260ccd56c87acd1bd85e49d40d9231fbb316bf6beb4917
 SHA512:
-  metadata.gz: 70dd4402ca82a60cffbc451ea134ca9fc34391f28311d23726d22055bfc01db9ba62002f0d54c76282888993613f2bf5618dcfa7a964da39c6995747401f3a3f
-  data.tar.gz: 31ada4f8ed50624701e389c6a1d50b83b75a585ef703d2f18c6511498dc9373647fa1f88d959ccdcbf56336d38dc550e1ce96710644f65970f2341549f843d53
+  metadata.gz: bc3d399e2eae53e244c0bb3a5d502cf725e3b4d4b0d941e1c96d9f0ceeee367a4688ec191116c75d94bed5bbc4470c59626e53da13c85afb24fd44df1f6668bc
+  data.tar.gz: d98bef37722feef1534e85f709f95dcaf314dc5f9013b32e10d667c653b97c3274e8f210fa42d2fdeb6f1fdb63c9f4a62da2d1cfd44ae2178b1439d79c56e8a8

data/README.md

@@ -100,3 +100,14 @@ heap.count(item)
 heap.contains?(item)
 ```
 
+## Performance
+You can run the `benchmarks/benchmarks.rb` file inside this repository for comparison to other popular heap libraries:
+* [rb_heap](https://github.com/florian/rb_heap)
+* [algorithms](https://github.com/kanwei/algorithms)
+* [ruby-heap](https://github.com/general-CbIC/ruby-heap)
+* [pqueue](https://github.com/rubyworks/pqueue)
+
+min-max should be the fastest to pop from a large heap, often by a significant margin, while also offering both min and max operations from a single heap.
+Some options are faster at pushing individual items, but the difference is within the same order of magnitude.
+Batch pushing to min-max also significantly increases insert speed.
+

data/benchmarks/benchmarks.rb

@@ -73,13 +73,13 @@ pqueue = PQueue.new()
 mm_hp = MinMax[]
 
 Benchmark.bm do |x|
-  x.report("push_algos_heap"){ data.each{|d| pqueue.push(d) } }
+  x.report("push_pqueue_heap"){ data.each{|d| pqueue.push(d) } }
   x.report("push_mm_heap"){ data.each{|d| mm_hp.push(d) } }
   x.report("push_mm_heap_batches"){ mm_hp = MinMax[]; data.each_slice(1000){|d| mm_hp.push(*d) } }
 end
 
 Benchmark.bm do |x|
-  x.report("pop_algos_heap"){ 100_000.times{|d| minheap.pop } }
+  x.report("pop_pqueue_heap"){ 100_000.times{|d| pqueue.pop } }
   x.report("pop_mm_heap"){ 100_000.times{|d| mm_hp.pop_min } }
   x.report("pop_mm_heap_batches"){ 1000.times{|d| mm_hp.pop_min(100) } }
 end

data/lib/min_max/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class MinMax
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/min_max.rb

@@ -6,7 +6,7 @@ require_relative "min_max/min_max"
 class MinMax
   class Error < StandardError; end
 
-  attr_reader :priority_blk, :storage, :mtx
+  attr_reader :priority_blk, :storage
 
   def self.[](*args, &blk)
     new(*args, &blk)
@@ -17,7 +17,6 @@ class MinMax
       s.instance_eval{
         @priority_blk = (blk || proc{|x| x.respond_to?(:priority) ? x.priority : x.to_i })
         @storage = Hash.new{|h,k| h[k] = [0, nil] }
-        @mtx  ||= Mutex.new
       }
       s.push(*args)
     }
@@ -51,19 +50,27 @@ class MinMax
     popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
   end
 
-  def peek_min(*args)
-    peeked = _peek_min(*args)
-    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  def peek_min
+    retrieve(_peek_min, false)
   end
 
-  def peek_max(*args)
-    peeked = _peek_max(*args)
-    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  def peek_max
+    retrieve(_peek_max, false)
+  end
+
+  def first
+    peek_min
+  end
+
+  def last
+    peek_max
   end
 
   def each(*args, &blk)
     if block_given?
-      mtx.synchronize { _each(*args).map{|p| blk[retrieve(p, false)] } }
+      _each(*args) do |p|
+        blk[retrieve(p, false)]
+      end
     else
       to_enum(:each, *args)
     end
@@ -82,15 +89,15 @@ class MinMax
   end
 
   def to_a_asc
-    mtx.synchronize { _to_a_asc.map{|p| retrieve(p, false) } }
+    _to_a_asc.map{|p| retrieve(p, false) }
   end
 
   def to_a_desc
-    mtx.synchronize { _to_a_desc.map{|p| retrieve(p, false) } }
+    _to_a_desc.map{|p| retrieve(p, false) }
   end
 
   def inspect
-    "MinMax[#{_each.first(10).map{|v| retrieve(v, false).to_s }.join(", ")}#{size > 10 ? ", ..." : ""}]"
+    "MinMax[#{each.first(10).map(&:to_s).join(", ")}#{size > 10 ? ", ..." : ""}]"
   end
 
   private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: min_max
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Wouter Coppieters
@@ -94,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: A min max heap extension for Ruby