min_max 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aef5e878c1412daa7a16bf7aad72afff1bdcc4cfa37709e6a88601d6ef2f1a93
-  data.tar.gz: 74f22abb3ad7a47e654cf6033d0512e00344a373e21aa18e46f86a9d38e6dc17
+  metadata.gz: 48b9b64396908ffd54a712e8a8e9b4eb6546e0538a6c168a69d67304dc6fcf1d
+  data.tar.gz: 487b79da6a3a3f99ab408af1feb17ebe33c21c08b7c64b9e20e5b259bcf764bf
 SHA512:
-  metadata.gz: 0b992bc50cd6e4920503b8a9257916dc3cb83326126c9e56c38fb693bbf513335573f8c7730386109044de48f58dd6e8a9c1da7f4a6e91e9f28e2aeb981cd23c
-  data.tar.gz: e5f84db084190697f2d8ab7738b70fc82ae2b4a23466936d47e74aef27e46dd39f1f2e5885b1a7d3f876f28aadc0dfc747dabffe36c05eaa3f4661f7424091bf
+  metadata.gz: '086026e3dfe0851390e4090e700aed60a27eaaf70ae53beb9a50164fd78a024797513994b2bd3c67995b29a655c6c8ca755b19ff42797e12190fae9bac10f4c6'
+  data.tar.gz: b7cebaf1da79607d638628c1ef2d54ff11126902e9c1072d4c2bfd1db883db662d323c9e760134c76941747f447494141122e2a4dad6dd0ddc9a65682bfcfd9f

data/README.md

@@ -1,7 +1,8 @@
-# MinMax
+# MinMax Heap
 
-The MinMax gem provides a high-performance minmax heap implementation for Ruby, written in Rust. 
-This gem allows for the creation of a min-max-heap and supporting operations like pushing and popping multiple items, iterating over heap items, and converting heaps to arrays. 
+The MinMax Heap gem provides a high-performance minmax heap implementation for Ruby, written in Rust. 
+The gem wraps the excellent [min-max-heap-rs](https://github.com/tov/min-max-heap-rs) Rust library.
+It allows for the creation of a min-max-heap and supporting operations like pushing and popping multiple items, iterating over heap items, and converting heaps to arrays. 
 
 ## Features
 
@@ -23,8 +24,13 @@ Add this line to your application's Gemfile:
 
 ```ruby
 gem 'min_max'
+
+# or manually specify target . E.g.
+
+CARGO_BUILD_TARGET=x86_64-apple-darwin gem install min_max
 ```
 
+
 And then execute:
 
 ```bash
@@ -84,4 +90,13 @@ heap.length # Alias for size
 heap.clear
 ```
 
+## Count number of times an item is in the heap
+```ruby
+heap.count(item)
+```
+
+## Check if item is contained in the heap
+```ruby
+heap.contains?(item)
+```
 

data/ext/min_max/src/lib.rs

@@ -1,4 +1,3 @@
-use magnus::block::Proc;
 use magnus::scan_args::scan_args;
 use magnus::value::ReprValue;
 use magnus::{
@@ -7,73 +6,14 @@ use magnus::{
     prelude::*,
     Error, IntoValue, RArray, Ruby, Value,
 };
-use magnus::{eval, gc, DataTypeFunctions, RHash, RString, TypedData};
+use magnus::{DataTypeFunctions, Integer, TypedData};
 use min_max_heap::MinMaxHeap;
 use std::cell::RefCell;
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
+use std::rc::Rc;
 
 #[derive(Debug, Clone)]
 struct PriorityOrderableValue(i64, i64);
 
-#[macro_use]
-extern crate lazy_static;
-
-struct MEM(
-    RwLock<HashMap<i64, Box<Value>>>,
-    RwLock<HashMap<i64, RefCell<usize>>>,
-);
-
-impl MEM {
-    fn new() -> Self {
-        MEM(RwLock::new(HashMap::new()), RwLock::new(HashMap::new()))
-    }
-}
-
-unsafe impl Sync for MEM {}
-
-lazy_static! {
-    static ref MEMORY: MEM = MEM::new();
-}
-
-fn get_rb_obj(key: i64) -> Option<Value> {
-    let binding = (*MEMORY).0.read().unwrap();
-    let v = binding.get(&key).unwrap();
-    Some(**v)
-}
-
-fn pop_rb_obj(key: i64) -> Option<Value> {
-    let binding = (*MEMORY).1.read().unwrap();
-    let mut count = binding.get(&key).unwrap().borrow_mut();
-    if *count == 0 {
-        return None;
-    }
-    *count -= 1;
-    let res = if *count == 0 {
-        let val = (*MEMORY).0.write().unwrap().remove(&key).unwrap();
-        gc::unregister_address(&*val);
-        Some(*val)
-    } else {
-        let binding = (*MEMORY).0.read().unwrap();
-        let v = binding.get(&key).unwrap();
-        Some(**v)
-    };
-    res
-}
-
-fn push_rb_obj(key: i64, value: Value) -> i64 {
-    let mut binding = (*MEMORY).1.write().unwrap();
-    let mut count = binding.entry(key).or_insert(RefCell::new(0)).borrow_mut();
-
-    *count += 1;
-    if *count == 1 {
-        let boxed = Box::new(value);
-        gc::register_address(&*boxed);
-        (*MEMORY).0.write().unwrap().insert(key, boxed);
-    };
-    return key;
-}
-
 impl PartialOrd for PriorityOrderableValue {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
@@ -82,9 +22,8 @@ impl PartialOrd for PriorityOrderableValue {
 
 impl Ord for PriorityOrderableValue {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        match (self, other) {
-            (PriorityOrderableValue(p1, _), PriorityOrderableValue(p2, _)) => p1.cmp(p2),
-        }
+        let (PriorityOrderableValue(p1, _), PriorityOrderableValue(p2, _)) = (self, other);
+        p1.cmp(p2)
     }
 }
 
@@ -92,13 +31,8 @@ impl Eq for PriorityOrderableValue {}
 
 impl PartialEq for PriorityOrderableValue {
     fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (PriorityOrderableValue(p1, v1), PriorityOrderableValue(p2, v2)) => {
-                let v1_obj = get_rb_obj(*v1).unwrap();
-                let v2_obj = get_rb_obj(*v2).unwrap();
-                p1.eq(p2) && (v1_obj).eql(v2_obj).unwrap_or_default()
-            }
-        }
+        let (PriorityOrderableValue(p1, v1), PriorityOrderableValue(p2, v2)) = (self, other);
+        p1.eq(p2) && (v1).eq(v2)
     }
 }
 
@@ -106,50 +40,37 @@ unsafe impl Send for RubyMinMaxHeap {}
 #[derive(DataTypeFunctions, TypedData, Clone)]
 #[magnus(class = "MinMax", size, free_immediately, mark)]
 struct RubyMinMaxHeap {
-    heap: Arc<RefCell<MinMaxHeap<PriorityOrderableValue>>>,
-    priority_proc: Arc<Proc>,
+    heap: Rc<RefCell<MinMaxHeap<PriorityOrderableValue>>>,
 }
 
 impl RubyMinMaxHeap {
-    fn new(args: &[Value]) -> Result<Self, Error> {
-        let args = scan_args::<(), (), (), (), RHash, Option<Proc>>(args)?;
-        let prc: Option<Proc> = args.block;
-
+    fn new() -> Result<Self, Error> {
         Ok(RubyMinMaxHeap {
-            heap: Arc::new(RefCell::new(MinMaxHeap::new())),
-            priority_proc: prc
-                .unwrap_or_else(|| {
-                    let value: Value =
-                        eval("Proc.new {|x| x.respond_to?(:priority) ? x.priority : x.to_i }")
-                            .unwrap();
-                    Proc::from_value(value).unwrap()
-                })
-                .into(),
+            heap: Rc::new(RefCell::new(MinMaxHeap::new())),
         })
     }
 
-    fn push(&self, value: &[Value]) -> Result<(), Error> {
+    fn push(&self, values: RArray) -> Result<(), Error> {
         let mut hp = self.heap.borrow_mut();
-        value.iter().for_each(|v| {
-            let priority: i64 = (*self.priority_proc).call([*v]).unwrap_or_default();
-            let key = v.hash().unwrap().to_i64().unwrap();
-            hp.push(PriorityOrderableValue(priority, push_rb_obj(key, *v)));
+        let values_vec = values.to_vec::<(i64, i64)>().unwrap();
+        values_vec.into_iter().for_each(|(priority, key)| {
+            hp.push(PriorityOrderableValue(priority, key));
         });
         Ok(())
     }
 
-    fn peek_max(&self) -> Result<Option<Value>, Error> {
+    fn peek_max(&self) -> Result<Option<i64>, Error> {
         let hp = self.heap.borrow();
         match hp.peek_max() {
-            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            Some(PriorityOrderableValue(_, value)) => Ok(Some(*value)),
             _ => Ok(None),
         }
     }
 
-    fn peek_min(&self) -> Result<Option<Value>, Error> {
+    fn peek_min(&self) -> Result<Option<i64>, Error> {
         let hp = self.heap.borrow();
         match hp.peek_min() {
-            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            Some(PriorityOrderableValue(_, value)) => Ok(Some(*value)),
             _ => Ok(None),
         }
     }
@@ -162,20 +83,20 @@ impl RubyMinMaxHeap {
             let mut result = vec![];
             for _ in 0..c {
                 match { self.heap.borrow_mut() }.pop_max() {
-                    Some(PriorityOrderableValue(_, value)) => {
-                        result.push(pop_rb_obj(value).unwrap())
-                    }
+                    Some(PriorityOrderableValue(_, value)) => result.push(Integer::from_i64(value)),
                     _ => break,
                 }
             }
             let ary = RArray::new();
             ary.cat(&result)?;
-            Ok(Some(ary.into_value()))
+            Ok(Some(ary.as_value()))
         } else {
             let mut hp = self.heap.borrow_mut();
             let val = hp.pop_max();
             match val {
-                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+                Some(PriorityOrderableValue(_, value)) => {
+                    Ok(Some(Integer::from_i64(value).as_value()))
+                }
                 _ => Ok(None),
             }
         }
@@ -188,19 +109,21 @@ impl RubyMinMaxHeap {
         if let Some(c) = count {
             let mut result = vec![];
             for _ in 0..c {
-                match { self.heap.borrow_mut().pop_min() } {
-                    Some(PriorityOrderableValue(_, value)) => {
-                        result.push(pop_rb_obj(value).unwrap())
-                    }
+                match { self.heap.borrow_mut() }.pop_min() {
+                    Some(PriorityOrderableValue(_, value)) => result.push(Integer::from_i64(value)),
                     _ => break,
                 }
             }
             let ary = RArray::new();
             ary.cat(&result)?;
-            Ok(Some(ary.into_value()))
+            Ok(Some(ary.as_value()))
         } else {
-            match { self.heap.borrow_mut().pop_min() } {
-                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+            let mut hp = self.heap.borrow_mut();
+            let val = hp.pop_min();
+            match val {
+                Some(PriorityOrderableValue(_, value)) => {
+                    Ok(Some(Integer::from_i64(value).as_value()))
+                }
                 _ => Ok(None),
             }
         }
@@ -223,45 +146,14 @@ impl RubyMinMaxHeap {
                 .into_vec()
                 .into_iter()
                 .map(|orderable_value| match orderable_value {
-                    PriorityOrderableValue(_, value) => get_rb_obj(value).unwrap(),
+                    PriorityOrderableValue(_, value) => Integer::from_i64(value).as_value(),
                 });
             Yield::Iter(Box::new(iter))
         } else {
-            Yield::Enumerator(self.clone().into_value().enumeratorize("each", ()))
+            Yield::Enumerator(self.clone().into_value().enumeratorize("_each", ()))
         }
     }
 
-    fn to_a(&self) -> Result<RArray, Error> {
-        let each: Value = self.clone().into_value().funcall("each", ())?;
-        Ok(each.funcall("to_a", ())?)
-    }
-
-    fn inspect(&self) -> Result<RString, Error> {
-        let mut visited = std::collections::HashSet::new();
-        Ok(self.build_inspect(&mut visited)?)
-    }
-
-    fn build_inspect(
-        &self,
-        visited: &mut std::collections::HashSet<*const Self>,
-    ) -> Result<RString, Error> {
-        // Check for circular reference
-        if !visited.insert(self as *const Self) {
-            return Ok(RString::new("[Circular Reference Detected]"));
-        }
-
-        let to_a: Value = self.to_a()?.into_value();
-        let r: String = match to_a.funcall("inspect", ()) {
-            Ok(inspect_value) => inspect_value,
-            Err(_) => return Ok(RString::new("[Error inspecting array]")),
-        };
-
-        // Ensure the current object is removed from the visited set to allow re-visiting in future calls
-        visited.remove(&(self as *const Self));
-
-        Ok(RString::new(&format!("MinMax{}", r)))
-    }
-
     fn to_a_asc(&self) -> Result<RArray, Error> {
         let ary = RArray::new();
 
@@ -272,7 +164,7 @@ impl RubyMinMaxHeap {
             .into_vec_asc()
             .iter()
             .map(|orderable_value| match orderable_value {
-                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+                PriorityOrderableValue(_, value) => Integer::from_i64(*value).as_value(),
             })
             .collect();
         ary.cat(&sorted)?;
@@ -289,35 +181,33 @@ impl RubyMinMaxHeap {
             .into_vec_desc()
             .iter()
             .map(|orderable_value| match orderable_value {
-                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+                PriorityOrderableValue(_, value) => Integer::from_i64(*value).as_value(),
             })
             .collect();
         ary.cat(&sorted)?;
         Ok(ary)
     }
 
-    fn clear(&self) -> Option<()> {
-        Some(self.heap.borrow_mut().clear())
+    fn clear(&self) {
+        self.heap.borrow_mut().clear()
     }
 }
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let rb_c_min_max = define_class("MinMax", ruby.class_object())?;
-    rb_c_min_max.define_singleton_method("new", function!(RubyMinMaxHeap::new, -1))?;
-    rb_c_min_max.define_method("_push", method!(RubyMinMaxHeap::push, -1))?;
+    rb_c_min_max.define_singleton_method("_new", function!(RubyMinMaxHeap::new, 0))?;
+    rb_c_min_max.define_method("_push", method!(RubyMinMaxHeap::push, 1))?;
     rb_c_min_max.define_method("_pop_max", method!(RubyMinMaxHeap::pop_max, -1))?;
     rb_c_min_max.define_method("_pop_min", method!(RubyMinMaxHeap::pop_min, -1))?;
     rb_c_min_max.define_method("empty?", method!(RubyMinMaxHeap::is_empty, 0))?;
-    rb_c_min_max.define_method("each", method!(RubyMinMaxHeap::each, 0))?;
-    rb_c_min_max.define_method("peek_min", method!(RubyMinMaxHeap::peek_min, 0))?;
-    rb_c_min_max.define_method("peek_max", method!(RubyMinMaxHeap::peek_max, 0))?;
-    rb_c_min_max.define_method("to_a", method!(RubyMinMaxHeap::to_a, 0))?;
-    rb_c_min_max.define_method("to_a_asc", method!(RubyMinMaxHeap::to_a_asc, 0))?;
-    rb_c_min_max.define_method("to_a_desc", method!(RubyMinMaxHeap::to_a_desc, 0))?;
+    rb_c_min_max.define_method("_each", method!(RubyMinMaxHeap::each, 0))?;
+    rb_c_min_max.define_method("_peek_min", method!(RubyMinMaxHeap::peek_min, 0))?;
+    rb_c_min_max.define_method("_peek_max", method!(RubyMinMaxHeap::peek_max, 0))?;
+    rb_c_min_max.define_method("_to_a_asc", method!(RubyMinMaxHeap::to_a_asc, 0))?;
+    rb_c_min_max.define_method("_to_a_desc", method!(RubyMinMaxHeap::to_a_desc, 0))?;
     rb_c_min_max.define_method("clear", method!(RubyMinMaxHeap::clear, 0))?;
     rb_c_min_max.define_method("size", method!(RubyMinMaxHeap::size, 0))?;
     rb_c_min_max.define_method("length", method!(RubyMinMaxHeap::size, 0))?;
-    rb_c_min_max.define_method("inspect", method!(RubyMinMaxHeap::inspect, 0))?;
     Ok(())
 }

data/lib/min_max/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 class MinMax
-  VERSION = "0.1.2"
-
+  VERSION = "0.1.4"
 end

data/lib/min_max.rb

@@ -6,28 +6,111 @@ require_relative "min_max/min_max"
 class MinMax
   class Error < StandardError; end
 
+  attr_reader :priority_blk, :storage, :counts, :mtx
+
   def self.[](*args, &blk)
-    new(&blk).tap{|s| s.push(*args) }
+    new(*args, &blk)
   end
 
-  def mtx
-    @_mtx  ||= Mutex.new
+  def self.new(*args, &blk)
+    self._new.tap{|s|
+      s.instance_eval{
+        @priority_blk = (blk || proc{|x| (x.respond_to?(:priority) ? x.priority : x.to_i ) rescue 0})
+        @storage = Hash.new
+        @counts = Hash.new(0)
+        @mtx  ||= Mutex.new
+      }
+      s.push(*args)
+    }
   end
 
   def push(*args)
-    mtx.synchronize { _push(*args) }
+    mtx.synchronize do
+      mapped = args.map do |a|
+          self.counts[a.hash] += 1
+          self.storage[a.hash] = a
+          [
+            self.priority_blk.call(a),
+            a.hash
+          ]
+      end
+       _push(mapped)
+    end
+    self
   end
 
   def add(*args)
-    mtx.synchronize { _push(*args) }
+    push(*args)
   end
 
   def pop_max(*args)
-    mtx.synchronize { _pop_max(*args) }
+    mtx.synchronize {
+      popped = _pop_max(*args)
+      popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
+    }
   end
 
   def pop_min(*args)
-    mtx.synchronize { _pop_min(*args) }
+    mtx.synchronize {
+      popped = _pop_min(*args)
+      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)
+  end
+
+  def peek_max(*args)
+    peeked = _peek_max(*args)
+    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  end
+
+  def each(*args, &blk)
+    if block_given?
+      mtx.synchronize { _each(*args).map{|p| blk[retrieve(p, false)] } }
+    else
+      to_enum(:each, *args)
+    end
+  end
+
+  def to_a
+    each.to_a
+  end
+
+  def count(val)
+    counts.has_key?(val.hash) ? counts[val.hash] : 0
   end
+
+  def contains?(val)
+    counts.has_key?(val.hash) && counts[val.hash] > 0
+  end
+
+  def to_a_asc
+    mtx.synchronize { _to_a_asc.map{|p| retrieve(p, false) } }
+  end
+
+  def to_a_desc
+    mtx.synchronize { _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 ? ", ..." : ""}]"
+  end
+
+  private
+  def retrieve(hash, remove=true)
+    if remove
+      if (self.counts[hash] -= 1) == 0
+        self.storage.delete(hash)
+      else
+        self.storage[hash]
+      end
+    else
+      self.storage[hash]
+    end
+  end
+
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: min_max
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-24 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys