penguin_queue 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d70fcdcdbb5aebbebec83821a6127e80fc6f583
-  data.tar.gz: 0efca553d509e7a8951f9c3cd44315dff21d632b
+  metadata.gz: bb2b3114b3a347a0a1f30b0bd72180595e385f4e
+  data.tar.gz: bad8b670607f5eec92c26795de6b0f2217571c5e
 SHA512:
-  metadata.gz: bceb560f69ff8e4f61afcc0a227ad7d43c10b960c0d4a1c487c3e874eb51a9950573521ef4c5159f55d6ab87ad38d8f7d0a9d80ea8e003cab4be93c4542b873a
-  data.tar.gz: 4fa133b95cf698d674ba7ae9eb5831500a213f2f78a0781237f6d9345dc5a67bc50b742818b91639488d4496656457292ce57842f0b8bcf43eaab4735e67b3b6
+  metadata.gz: 7ae75f4e9505ebe8a27ed745899a493768d46ef51e863f4beb1ce90afb0cbc1145983a05d87c37814cfab2459178fb57c929432d50d438f83afb3fd942ddd1bc
+  data.tar.gz: 8636a9b92b784fae27a3e5870e805ceec105035a533382b0f6c4ad22627b0c621653839f47d90f324dd7a32f0efa120dbab661ae824559b5a846371a3992a6bf

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.3.0
+  - 2.4.0
+before_install: gem install bundler -v 1.13.7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    penguin_queue (0.1.2)
+    penguin_queue (0.1.3)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,4 +1,9 @@
-# Priority Queue
+# Penguin Queue
+
+[![Build Status](https://travis-ci.org/tompng/penguin_queue.svg?branch=master)](https://travis-ci.org/tompng/penguin_queue)
+
+Ruby priority-queue library
+
 ```ruby
 10000.times { array << rand; array.delete(array.min) } #=> slow when array.size is large
 10000.times { pq << rand; pq.deq } #=> fast even if pq.size is large
@@ -38,7 +43,7 @@ pq.size.times.map { pq.deq } #=> [8, 6, 4, 2, 0]
 ```ruby
 # initialize
 PenguinQueue.new
-PenguinQueue.new(order) # min(default) or max
+PenguinQueue.new(order) # :min(default) or :max
 PenguinQueue.new(&calc_priority_from_element_proc)
 # enqueue
 <<(e) enq(e) push(e) unshift(e)

data/ext/penguin_queue/penguin_queue.c

@@ -1,12 +1,24 @@
 #include <ruby.h>
 
-static ID id_priority, id_cmp, id_call, id_order, id_max, id_min;
+static ID id_priority, id_cmp, id_call, id_max, id_min;
 #define RB_STR_BUF_CAT(rstr, cstr) rb_str_buf_cat((rstr), (cstr), sizeof(cstr)-1);
 struct node {
   long index, id;
   VALUE queue, priority, value;
 };
-VALUE node_class;
+struct queue_data{
+  long counter;
+  int compare_sgn;
+  VALUE heap, compare_by;
+};
+#define NODE_DECLARE_PTR(name) struct node *name;
+#define NODE_GET_PTR(self, name) Data_Get_Struct(self, struct node, name);
+#define QUEUE_DECLARE_PTR(name) struct queue_data *name;
+#define QUEUE_GET_PTR(self, name) Data_Get_Struct(self, struct queue_data, name);
+#define NODE_PREPARE(self, name) NODE_DECLARE_PTR(name);NODE_GET_PTR(self, name);
+#define QUEUE_PREPARE(self, name) QUEUE_DECLARE_PTR(name);QUEUE_GET_PTR(self, name);
+
+VALUE queue_class, node_class;
 void node_mark(struct node *ptr){
   rb_gc_mark(ptr->queue);
   rb_gc_mark(ptr->priority);
@@ -21,7 +33,6 @@ VALUE node_alloc_internal(long index, long id, VALUE queue, VALUE priority, VALU
   ptr->value = value;
   return Data_Wrap_Struct(node_class, node_mark, RUBY_DEFAULT_FREE, ptr);
 }
-#define NODE_PREPARE(self, name) struct node *name;Data_Get_Struct(self, struct node, name);
 VALUE node_pri(VALUE self){
   NODE_PREPARE(self, ptr);
   return ptr->priority;
@@ -31,8 +42,8 @@ VALUE node_val(VALUE self){
   return ptr->value;
 }
 VALUE node_inspect(VALUE self){
-  NODE_PREPARE(self, nptr);
   VALUE str = rb_str_buf_new(0);
+  NODE_PREPARE(self, nptr);
   rb_str_buf_append(str, rb_class_name(CLASS_OF(self)));
   RB_STR_BUF_CAT(str, "{priority: ");
   rb_str_buf_append(str, rb_inspect(nptr->priority));
@@ -42,13 +53,8 @@ VALUE node_inspect(VALUE self){
   return str;
 }
 
-struct queue_data{
-  long counter;
-  int compare_sgn;
-  VALUE heap, compare_by;
-};
-
 long compare(VALUE a, VALUE b){
+#ifdef RB_FIXNUM_P
   if(RB_FIXNUM_P(a)&&RB_FIXNUM_P(b))
     return (long)a > (long)b ? 1 : (long)a < (long)b ? -1 : 0;
   if(RB_FLOAT_TYPE_P(a)&&RB_FLOAT_TYPE_P(b)){
@@ -57,14 +63,14 @@ long compare(VALUE a, VALUE b){
   }
   if(RB_TYPE_P(a, T_STRING)&&RB_TYPE_P(b, T_STRING))
     return rb_str_cmp(a, b);
-  VALUE cmp = rb_funcall(a, id_cmp, 1, b);
-  if(NIL_P(cmp))rb_cmperr(a,b);
-  return rb_fix2long(cmp);
+  return rb_fix2long(rb_funcall(a, id_cmp, 1, b));
+#else
+  return FIX2LONG(rb_funcall(a, id_cmp, 1, b));
+#endif
 }
 
 long compare_id(long a, long b){return a>b?1:a<b?-1:0;}
 
-#define QUEUE_PREPARE(self, name) struct queue_data *name;Data_Get_Struct(self, struct queue_data, name);
 #define OPTHASH_GIVEN_P(opts) (argc > 0 && !NIL_P((opts) = rb_check_hash_type(argv[argc-1])) && (--argc, 1))
 
 void queue_mark(struct queue_data *self){
@@ -87,8 +93,8 @@ VALUE queue_alloc(VALUE klass){
 }
 
 VALUE queue_initialize(int argc, VALUE *argv, VALUE self){
+  VALUE order;
   QUEUE_PREPARE(self, ptr);
-  VALUE opts, order;
   if(argc == 0)return self;
   rb_scan_args(argc, argv, "1", &order);
   if(order == ID2SYM(id_max)){
@@ -108,16 +114,19 @@ VALUE queue_clear(VALUE self){
 }
 
 void queue_up(VALUE self, VALUE node){
+  int sgn;
   QUEUE_PREPARE(self, ptr);
-  int sgn = ptr->compare_sgn;
+  sgn = ptr->compare_sgn;
   RARRAY_PTR_USE(ptr->heap, heap, {
+    long index;
     NODE_PREPARE(node, nptr);
-    long index = nptr->index;
+    index = nptr->index;
     while(index > 1){
+      long cmp;
       long pindex = index/2;
       VALUE pnode = heap[pindex];
       NODE_PREPARE(pnode, pptr);
-      long cmp = compare(pptr->priority, nptr->priority)*sgn;
+      cmp = compare(pptr->priority, nptr->priority)*sgn;
       if(!cmp)cmp=compare_id(pptr->id, nptr->id);
       if(cmp<0)break;
       pptr->index = index;
@@ -130,20 +139,24 @@ void queue_up(VALUE self, VALUE node){
 }
 
 void queue_down(VALUE self, VALUE node){
+  int sgn;
+  long length;
   QUEUE_PREPARE(self, ptr);
-  int sgn = ptr->compare_sgn;
-  long length = RARRAY_LEN(ptr->heap);
+  sgn = ptr->compare_sgn;
+  length = RARRAY_LEN(ptr->heap);
   RARRAY_PTR_USE(ptr->heap, heap, {
+    long index;
     NODE_PREPARE(node, nptr);
-    long index = nptr->index;
+    index = nptr->index;
     while(2*index < length){
       long lindex = 2*index;
       VALUE lnode = heap[lindex];
       NODE_PREPARE(lnode, lptr);
       if(lindex+1 < length){
+        long cmp;
         VALUE rnode = heap[lindex+1];
         NODE_PREPARE(rnode, rptr);
-        long cmp = compare(lptr->priority, rptr->priority)*sgn;
+        cmp = compare(lptr->priority, rptr->priority)*sgn;
         if(!cmp)cmp=compare_id(lptr->id, rptr->id);
         if(cmp >= 0){
           lindex += 1;
@@ -164,19 +177,24 @@ void queue_down(VALUE self, VALUE node){
 }
 
 VALUE queue_remove_node(VALUE self, VALUE node){
+  int sgn;
+  long length;
+  QUEUE_DECLARE_PTR(ptr);
+  NODE_DECLARE_PTR(nptr);
   if(!rb_obj_is_kind_of(node, node_class))return Qnil;
-  QUEUE_PREPARE(self, ptr);
-  NODE_PREPARE(node, nptr);
-  int sgn = ptr->compare_sgn;
-  long length = RARRAY_LEN(ptr->heap);
+  QUEUE_GET_PTR(self, ptr);
+  NODE_GET_PTR(node, nptr);
+  sgn = ptr->compare_sgn;
+  length = RARRAY_LEN(ptr->heap);
   if(nptr->index >= length || RARRAY_AREF(ptr->heap, nptr->index) != node)return Qnil;
   RARRAY_PTR_USE(ptr->heap, heap, {
+    long cmp;
     VALUE replace_node = rb_ary_pop(ptr->heap);
-    if(replace_node == node)return Qnil;
     NODE_PREPARE(replace_node, rptr);
+    if(replace_node == node)return Qnil;
     heap[nptr->index] = replace_node;
     rptr->index = nptr->index;
-    long cmp = compare(rptr->priority, nptr->priority)*sgn;
+    cmp = compare(rptr->priority, nptr->priority)*sgn;
     if(!cmp)cmp = compare_id(rptr->id, nptr->id);
     if(cmp > 0){
       queue_down(nptr->queue, replace_node);
@@ -194,12 +212,17 @@ VALUE node_remove(VALUE self){
 }
 
 void node_update_priority_internal(VALUE node, VALUE priority){
-  NODE_PREPARE(node, nptr);
-  QUEUE_PREPARE(nptr->queue, ptr);
-  int sgn = ptr->compare_sgn;
-  VALUE priority_was = nptr->priority;
+  int sgn;
+  long cmp;
+  VALUE priority_was;
+  NODE_DECLARE_PTR(nptr);
+  QUEUE_DECLARE_PTR(ptr);
+  NODE_GET_PTR(node, nptr);
+  QUEUE_GET_PTR(nptr->queue, ptr);
+  sgn = ptr->compare_sgn;
+  priority_was = nptr->priority;
   nptr->priority = priority;
-  long cmp = compare(priority, priority_was)*sgn;
+  cmp = compare(priority, priority_was)*sgn;
   if(cmp == 0)return;
   RARRAY_PTR_USE(ptr->heap, heap, {
     if(heap[nptr->index] != node)return;
@@ -212,16 +235,20 @@ void node_update_priority_internal(VALUE node, VALUE priority){
 }
 
 VALUE node_update_priority(VALUE node, VALUE priority){
-  NODE_PREPARE(node, nptr);
-  QUEUE_PREPARE(nptr->queue, ptr);
+  NODE_DECLARE_PTR(nptr);
+  QUEUE_DECLARE_PTR(ptr);
+  NODE_GET_PTR(node, nptr);
+  QUEUE_GET_PTR(nptr->queue, ptr);
   if(ptr->compare_by != Qnil)rb_raise(rb_eRuntimeError, "priority update not supported on queue initialized with block");
   node_update_priority_internal(node, priority);
   return priority;
 }
 
 VALUE node_update_value(VALUE node, VALUE value){
-  NODE_PREPARE(node, nptr);
-  QUEUE_PREPARE(nptr->queue, ptr);
+  NODE_DECLARE_PTR(nptr);
+  QUEUE_DECLARE_PTR(ptr);
+  NODE_GET_PTR(node, nptr);
+  QUEUE_GET_PTR(nptr->queue, ptr);
   nptr->value = value;
   if(ptr->compare_by != Qnil){
     VALUE priority = rb_funcall(ptr->compare_by, id_call, 1, value);
@@ -231,12 +258,14 @@ VALUE node_update_value(VALUE node, VALUE value){
 }
 
 VALUE queue_enq_vp(VALUE self, VALUE value, VALUE priority){
+  long length;
+  VALUE node;
   QUEUE_PREPARE(self, ptr);
   if(ptr->compare_by != Qnil){
     priority = rb_funcall(ptr->compare_by, id_call, 1, value);
   }
-  long length = RARRAY_LEN(ptr->heap);
-  VALUE node = node_alloc_internal(length, ptr->counter, self, priority, value);
+  length = RARRAY_LEN(ptr->heap);
+  node = node_alloc_internal(length, ptr->counter, self, priority, value);
   ptr->counter++;
   rb_ary_push(ptr->heap, node);
   queue_up(self, node);
@@ -258,8 +287,9 @@ VALUE queue_push(VALUE self, VALUE value){
 }
 
 VALUE queue_first_node(VALUE self){
+  long length;
   QUEUE_PREPARE(self, ptr);
-  long length = RARRAY_LEN(ptr->heap);
+  length = RARRAY_LEN(ptr->heap);
   if(length == 1)return Qnil;
   RARRAY_PTR_USE(ptr->heap, heap, {
     return heap[1];
@@ -267,20 +297,23 @@ VALUE queue_first_node(VALUE self){
 }
 VALUE queue_first(VALUE self){
   VALUE node = queue_first_node(self);
+  NODE_DECLARE_PTR(nptr);
   if(node == Qnil)return Qnil;
-  NODE_PREPARE(node, nptr);
+  NODE_GET_PTR(node, nptr);
   return nptr->value;
 }
 VALUE queue_first_with_priority(VALUE self){
   VALUE node = queue_first_node(self);
+  NODE_DECLARE_PTR(nptr);
   if(node == Qnil)return Qnil;
-  NODE_PREPARE(node, nptr);
+  NODE_GET_PTR(node, nptr);
   return rb_ary_new_from_args(2, nptr->value, nptr->priority);
 }
 
 VALUE queue_deq_node(VALUE self){
+  long length;
   QUEUE_PREPARE(self, ptr);
-  long length = RARRAY_LEN(ptr->heap);
+  length = RARRAY_LEN(ptr->heap);
   if(length == 1)return Qnil;
   RARRAY_PTR_USE(ptr->heap, heap, {
     VALUE first = heap[1];
@@ -296,19 +329,23 @@ VALUE queue_deq_node(VALUE self){
 VALUE queue_deq(int argc, VALUE *argv, VALUE self){
   if(argc == 0){
     VALUE node = queue_deq_node(self);
+    NODE_DECLARE_PTR(nptr);
     if(node == Qnil)return Qnil;
-    NODE_PREPARE(node, nptr);
+    NODE_GET_PTR(node, nptr);
     return nptr->value;
   }else{
-    VALUE nv;
+    VALUE nv, result;
+    int i;
+    long n, length;
+    QUEUE_DECLARE_PTR(ptr);
     rb_scan_args(argc, argv, "1", &nv);
-    long n = NUM2LONG(nv);
+    n = NUM2LONG(nv);
     if(n<0)rb_raise(rb_eArgError, "negative array size");
-    QUEUE_PREPARE(self, ptr);
-    long length = RARRAY_LEN(ptr->heap)-1;
+    QUEUE_GET_PTR(self, ptr);
+    length = RARRAY_LEN(ptr->heap)-1;
     if(n>length)n=length;
-    VALUE result = rb_ary_new_capa(n);
-    for(int i=0;i<n;i++){
+    result = rb_ary_new_capa(n);
+    for(i=0;i<n;i++){
       VALUE node = queue_deq_node(self);
       NODE_PREPARE(node, nptr);
       rb_ary_push(result, nptr->value);
@@ -318,8 +355,9 @@ VALUE queue_deq(int argc, VALUE *argv, VALUE self){
 }
 VALUE queue_deq_with_priority(VALUE self){
   VALUE node = queue_deq_node(self);
+  NODE_DECLARE_PTR(nptr);
   if(node == Qnil)return Qnil;
-  NODE_PREPARE(node, nptr);
+  NODE_GET_PTR(node, nptr);
   return rb_ary_new_from_args(2, nptr->value, nptr->priority);
 }
 
@@ -341,8 +379,8 @@ VALUE queue_is_max(VALUE self){
   return QUEUE_PTR_IS_MIN(ptr) ? Qfalse : Qtrue;
 }
 VALUE queue_inspect(VALUE self){
-  QUEUE_PREPARE(self, ptr);
   VALUE str = rb_str_buf_new(0);
+  QUEUE_PREPARE(self, ptr);
   rb_str_buf_append(str, rb_class_name(CLASS_OF(self)));
   RB_STR_BUF_CAT(str, "{order: ");
   if(QUEUE_PTR_IS_MIN(ptr)){
@@ -363,7 +401,7 @@ void Init_penguin_queue(void){
   id_max = rb_intern("max");
   id_min = rb_intern("min");
 
-  VALUE queue_class = rb_define_class("PenguinQueue", rb_cObject);
+  queue_class = rb_define_class("PenguinQueue", rb_cObject);
   rb_define_alloc_func(queue_class, queue_alloc);
   rb_define_method(queue_class, "initialize", queue_initialize, -1);
   rb_define_method(queue_class, "size", queue_size, 0);

data/lib/penguin_queue/version.rb

@@ -1,3 +1,3 @@
 class PenguinQueue
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/penguin_queue.gemspec

@@ -13,6 +13,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{C Ext Priority Queue (binary heap)}
   spec.homepage      = "https://github.com/tompng/penguin_queue"
   spec.license       = "MIT"
+  spec.required_ruby_version = '>= 2.2.0'
   spec.extensions    = %w[ext/penguin_queue/extconf.rb]
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: penguin_queue
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - tompng
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-20 00:00:00.000000000 Z
+date: 2017-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -99,7 +100,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="