d_heap 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 585cdfa768be7f778b92fa500d952f4207b98ea46378d7289f2ff936bc1f06f0
-  data.tar.gz: d306234243d78a9dfd0ef9beb06e569ddd9915f2c733ebd9109953fc84584e11
+  metadata.gz: c8c06927edbc903bc67c3f52bf6d7027a1c9b04d7860acc712a29b4298fd7adf
+  data.tar.gz: e347372e483f9d2b46deb5ad78cc6eb4ab9f28a427853e01282f035abdf475b7
 SHA512:
-  metadata.gz: dd379eecd4bc218b62729d2fdd39773ffbf1e248fb83eeffda910f439644ad5ed8588cf1e8fd4de807ca074f3165e073300d584eb64fae2c54aeed5206374cfc
-  data.tar.gz: 7fac571f7d14bb2a7b6d2773fe531a803474587a83508710c4898c15649117558aaa399151d5be3dd49f07afbb06ffd38fe55161e07e483cee729c4f1efdbb20
+  metadata.gz: 124b615e62c6f6e58b3f8ff55bd7471f99960eab5e937dc40354f067112750fbebdcb0540585ec615d1d713f005fc40d2840a9b6ff4c9b6e6f62dcf374f56d9c
+  data.tar.gz: 391af9443b13e0902a813cfb9712fdf98ea414d27d9406348ef25aa5ec03a47488b7c2bbbf066bbbfe50e69f04fec95413eb705c5c45c5185172c5b63777c059

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    d_heap (0.1.0)
+    d_heap (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -94,10 +94,69 @@ Read the `rdoc` for more detailed documentation and examples.
 
 _TODO: put benchmarks here._
 
+## Analysis
+
+### Time complexity
+
+Both sift operations can perform (log[d] n = log n / log d) swaps.
+Swap up performs only a single comparison per swap: O(1).
+Swap down performs as many as d comparions per swap: O(d).
+
+Inserting an item is O(log n / log d).
+Deleting the root is O(d log n / log d).
+
+Assuming every inserted item is eventually deleted from the root, d=4 requires
+the fewest comparisons for combined insert and delete:
+ * (1 + 2) lg 2 = 4.328085
+ * (1 + 3) lg 3 = 3.640957
+ * (1 + 4) lg 4 = 3.606738
+ * (1 + 5) lg 5 = 3.728010
+ * (1 + 6) lg 6 = 3.906774
+ * etc...
+
+Leaf nodes require no comparisons to shift down, and higher values for d have
+higher percentage of leaf nodes:
+ * d=2 has ~50% leaves,
+ * d=3 has ~67% leaves,
+ * d=4 has ~75% leaves,
+ * and so on...
+
+See https://en.wikipedia.org/wiki/D-ary_heap#Analysis for deeper analysis.
+
+### Space complexity
+
+Because the heap is a complete binary tree, space usage is linear, regardless
+of d.  However higher d values may provide better cache locality.
+
+We can run comparisons much much faster for Numeric or String objects than for
+ruby objects which delegate comparison to internal Numeric or String objects.
+And it is often advantageous to use extrinsic scores for uncomparable items.
+For this, our internal array uses twice as many entries (one for score and one
+for value) as it would if it only supported intrinsic comparison or used an
+un-memoized "sort_by" proc.
+
+### Timers
+
+Additionally, when used to sort timers, we can reasonably assume that:
+ * New timers usually sort after most existing timers.
+ * Most timers will be canceled before executing.
+ * Canceled timers usually sort after most existing timers.
+
+So, if we are able to delete an item without searching for it, by keeping a map
+of positions within the heap, most timers can be inserted and deleted in O(1)
+time.  Canceling a non-leaf timer can be further optimized by marking it as
+canceled without immediately removing it from the heap.  If the timer is
+rescheduled before we garbage collect, adjusting its position will usually be
+faster than a delete and re-insert.
+
 ## Alternative data structures
 
 Depending on what you're doing, maintaining a sorted `Array` using
-`#bsearch_index` and `#insert` might be faster!
+`#bsearch_index` and `#insert` might be faster!  Although it is technically
+O(n) for insertions, the implementations for `memcpy` or `memmove` can be *very*
+fast on modern architectures.  Also, it can be faster O(n) on average, if
+insertions are usually near the end of the array.  You should run benchmarks
+with your expected scenarios to determine which is right.
 
 If it is important to be able to quickly enumerate the set or find the ranking
 of values in it, then you probably want to use a self-balancing binary search
@@ -105,9 +164,9 @@ tree (e.g. a red-black tree) or a skip-list.
 
 A Hashed Timing Wheel or Heirarchical Timing Wheels (or some variant in that
 family of data structures) can be constructed to have effectively O(1) running
-time in most cases.  However, the implementation for that data structure is much
-more complex than a heap.  If a 4-ary heap is good enough for go's timers,
-it should be suitable for many use cases.
+time in most cases.  However, the implementation for that data structure is more
+complex than a heap.  If a 4-ary heap is good enough for go's timers, it should
+be suitable for many use cases.
 
 ## Development
 

data/ext/d_heap/d_heap.c

@@ -3,6 +3,26 @@
 ID id_ivar_a;
 ID id_ivar_d;
 
+#define DHEAP_GET_A(self) rb_ivar_get(self, id_ivar_a)
+#define DHEAP_GET_D(self) rb_ivar_get(self, id_ivar_d)
+
+#define DHEAP_SIZE(ary) (RARRAY_LEN(ary) / 2)
+#define DHEAP_LAST_IDX(ary) (DHEAP_SIZE(ary) - 1)
+#define DHEAP_VALUE(ary, idx) rb_ary_entry(ary, idx * 2 + 1)
+#define DHEAP_SCORE(ary, idx) rb_ary_entry(ary, idx * 2)
+#define DHEAP_ASSIGN(ary, idx, scr, val) \
+    rb_ary_store(ary, idx * 2,     scr); \
+    rb_ary_store(ary, idx * 2 + 1, val);
+#define DHEAP_APPEND(ary, scr, val) \
+    rb_ary_push(ary, scr); \
+    rb_ary_push(ary, val);
+#define DHEAP_DROP_LAST(ary) ( \
+        rb_ary_pop(ary), \
+        rb_ary_pop(ary) \
+    ) // score, value
+#define IDX_PARENT(idx) ((idx - 1) / d)
+#define IDX_CHILD0(idx) ((idx * d) + 1)
+
 #define DHEAP_Check_d_size(d) \
     if (d < 2) { \
         rb_raise(rb_eIndexError, "DHeap d=%d is too small", d); \
@@ -11,86 +31,95 @@ ID id_ivar_d;
         rb_raise(rb_eIndexError, "DHeap d=%d is too large", d); \
     }
 
-#define DHEAP_Check_Sift_Idx(sift_idx, last_idx) \
-    if (sift_idx < 0) { \
-        rb_raise(rb_eIndexError, "sift_idx %ld too small", sift_idx); \
+#define DHEAP_Check_Sift_Idx(sift_index, last_index) \
+    if (sift_index < 0) { \
+        rb_raise(rb_eIndexError, "sift_index %ld too small", sift_index); \
     } \
-    else if (last_idx < sift_idx) { \
-        rb_raise(rb_eIndexError, "sift_idx %ld too large", sift_idx); \
+    else if (last_index < sift_index) { \
+        rb_raise(rb_eIndexError, "sift_index %ld too large", sift_index); \
     }
 
-#define DHEAP_Load_Sift_Vals(heap_array, dval, idxval) \
-    Check_Type(dval, T_FIXNUM); \
-    int d = FIX2INT(dval); \
-    long sift_idx = NUM2LONG(idxval);
-
-#define DHEAP_Check_Sift_Args(heap_array, d, sift_idx) \
+#define DHEAP_Check_Sift_Args(heap_array, d, sift_index) \
     DHEAP_Check_d_size(d); \
     Check_Type(heap_array, T_ARRAY); \
-    long last_idx = RARRAY_LEN(heap_array) - 1; \
-    DHEAP_Check_Sift_Idx(sift_idx, last_idx); \
+    long last_index = DHEAP_LAST_IDX(heap_array); \
+    DHEAP_Check_Sift_Idx(sift_index, last_index); \
     \
-    VALUE sift_val = rb_ary_entry(heap_array, sift_idx);
+    VALUE sift_value = DHEAP_VALUE(heap_array, sift_index); \
+    VALUE sift_score = DHEAP_SCORE(heap_array, sift_index);
 
 VALUE
-dheap_ary_sift_up(VALUE heap_array, int d, long sift_idx) {
-    DHEAP_Check_Sift_Args(heap_array, d, sift_idx);
+dheap_ary_sift_up(VALUE heap_array, int d, long sift_index) {
+    DHEAP_Check_Sift_Args(heap_array, d, sift_index);
+    struct cmp_opt_data cmp_opt = { 0, 0 };
     // sift it up to where it belongs
-    for (long parent_idx; 0 < sift_idx; sift_idx = parent_idx) {
-        parent_idx = (sift_idx - 1) / d;
-        VALUE parent_val = rb_ary_entry(heap_array, parent_idx);
+    for (long parent_index; 0 < sift_index; sift_index = parent_index) {
+        // puts(rb_sprintf("sift up(%"PRIsVALUE", %d, %ld)", heap_array, d, sift_index));
+        parent_index = IDX_PARENT(sift_index);
+        VALUE parent_score = DHEAP_SCORE(heap_array, parent_index);
 
         // parent is smaller: heap is restored
-        if (CMP_LTE(parent_val, sift_val)) break;
+        if (CMP_LTE(parent_score, sift_score, cmp_opt)) break;
 
         // parent is larger: swap and continue sifting up
-        rb_ary_store(heap_array, sift_idx, parent_val);
-        rb_ary_store(heap_array, parent_idx, sift_val);
+        VALUE parent_value = DHEAP_VALUE(heap_array, parent_index);
+        DHEAP_ASSIGN(heap_array, sift_index, parent_score, parent_value);
+        DHEAP_ASSIGN(heap_array, parent_index, sift_score, sift_value);
     }
-    return LONG2NUM(sift_idx);
+    // puts(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap_array, d, sift_index));
+    return LONG2NUM(sift_index);
 }
 
-
 VALUE
-dheap_ary_sift_down(VALUE heap_array, int d, long sift_idx) {
-    DHEAP_Check_Sift_Args(heap_array, d, sift_idx);
+dheap_ary_sift_down(VALUE heap_array, int d, long sift_index) {
+    DHEAP_Check_Sift_Args(heap_array, d, sift_index);
+    struct cmp_opt_data cmp_opt = { 0, 0 };
+
      // iteratively sift it down to where it belongs
-    for (long child_idx; sift_idx < last_idx; sift_idx = child_idx) {
+    for (long child_index; sift_index < last_index; sift_index = child_index) {
+        // puts(rb_sprintf("sift dn(%"PRIsVALUE", %d, %ld)", heap_array, d, sift_index));
         // find first child index, and break if we've reached the last layer
-        long child_idx0 = sift_idx * d + 1;
-        child_idx = child_idx0;
-        if (last_idx < child_idx0) break;
-
-        // find the min child (and its child_idx)
-        // requires "d" comparisons. (d - 1 to find min child; + 1 vs sift_val)
-        VALUE child_val = rb_ary_entry(heap_array, child_idx0);
-        for (int i = 1; i < d; i++) {
-            long sibling_idx = child_idx0 + i;
-            if (last_idx < sibling_idx) break;
-
-            VALUE sibling_val = rb_ary_entry(heap_array, sibling_idx);
-
-            if (CMP_LT(sibling_val, child_val)) {
-                child_val = sibling_val;
-                child_idx = sibling_idx;
+        long child_idx0 = child_index = IDX_CHILD0(sift_index);
+        if (last_index < child_idx0) break;
+
+        // find the min child (and its child_index)
+        // requires "d" comparisons to find min child and compare to sift_score
+        VALUE child_score = DHEAP_SCORE(heap_array, child_idx0);
+        child_index = child_idx0;
+        for (int i = 1; i < d; ++i) {
+            long sibling_index = child_idx0 + i;
+            if (last_index < sibling_index) break;
+
+            VALUE sibling_score = DHEAP_SCORE(heap_array, sibling_index);
+
+            if (CMP_LT(sibling_score, child_score, cmp_opt)) {
+                child_score = sibling_score;
+                child_index = sibling_index;
             }
         }
 
         // child is larger: heap is restored
-        if (CMP_GT(child_val, sift_val)) break;
+        if (CMP_LTE(sift_score, child_score, cmp_opt)) break;
 
         // child is smaller: swap and continue sifting down
-        rb_ary_store(heap_array, sift_idx, child_val);
-        rb_ary_store(heap_array, child_idx, sift_val);
+        VALUE child_value = DHEAP_VALUE(heap_array, child_index);
+        DHEAP_ASSIGN(heap_array, sift_index, child_score, child_value);
+        DHEAP_ASSIGN(heap_array, child_index, sift_score, sift_value);
     }
-    return LONG2NUM(sift_idx);
+    // puts(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap_array, d, sift_index));
+    return LONG2NUM(sift_index);
 }
 
+#define DHEAP_Load_Sift_Vals(heap_array, dval, idxval) \
+    Check_Type(dval, T_FIXNUM); \
+    int d = FIX2INT(dval); \
+    long sift_index = NUM2LONG(idxval);
+
 /*
  * call-seq:
- *    DHeap.array_sift_up(heap_array, d, sift_idx)
+ *    DHeap.array_sift_up(heap_array, d, sift_index)
  *
- * Treats +heap_array+ as a +d+-ary heap and sifts up from +sift_idx+ to restore
+ * Treats +heap_array+ as a +d+-ary heap and sifts up from +sift_index+ to restore
  * the heap property.
  *
  * Time complexity: O(d log n / log d).  If the average up shifted element sorts
@@ -100,14 +129,14 @@ dheap_ary_sift_down(VALUE heap_array, int d, long sift_idx) {
 static VALUE
 dheap_sift_up_s(VALUE unused, VALUE heap_array, VALUE dval, VALUE idxval) {
     DHEAP_Load_Sift_Vals(heap_array, dval, idxval);
-    return dheap_ary_sift_up(heap_array, d, sift_idx);
+    return dheap_ary_sift_up(heap_array, d, sift_index);
 }
 
 /*
  * call-seq:
- *    DHeap.array_sift_down(heap_array, d, sift_idx)
+ *    DHeap.array_sift_down(heap_array, d, sift_index)
  *
- * Treats +heap_array+ as a +d+-ary heap and sifts down from +sift_idx+ to
+ * Treats +heap_array+ as a +d+-ary heap and sifts down from +sift_index+ to
  * restore the heap property.
  *
  * Time complexity: O(d log n / log d).  If the average down shifted element
@@ -117,7 +146,7 @@ dheap_sift_up_s(VALUE unused, VALUE heap_array, VALUE dval, VALUE idxval) {
 static VALUE
 dheap_sift_down_s(VALUE unused, VALUE heap_array, VALUE dval, VALUE idxval) {
     DHEAP_Load_Sift_Vals(heap_array, dval, idxval);
-    return dheap_ary_sift_down(heap_array, d, sift_idx);
+    return dheap_ary_sift_down(heap_array, d, sift_index);
 }
 
 static VALUE
@@ -133,11 +162,35 @@ dheap_initialize(int argc, VALUE *argv, VALUE self) {
     return self;
 }
 
-static inline VALUE dheap_get_a(VALUE dheap) { return rb_ivar_get(dheap, id_ivar_a); }
-static inline VALUE dheap_get_d(VALUE dheap) { return rb_ivar_get(dheap, id_ivar_d); }
+static VALUE dheap_size(VALUE self) {
+    VALUE ary = DHEAP_GET_A(self);
+    long size = DHEAP_SIZE(ary);
+    return LONG2NUM(size);
+}
 
-static VALUE dheap_a(VALUE dheap) { return dheap_get_a(dheap); }
-static VALUE dheap_d(VALUE dheap) { return dheap_get_d(dheap); }
+static VALUE dheap_empty_p(VALUE self) {
+    VALUE ary = DHEAP_GET_A(self);
+    long size = DHEAP_SIZE(ary);
+    return size == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE dheap_attr_d(VALUE self) { return DHEAP_GET_D(self); }
+
+static VALUE
+dheap_freeze(VALUE self) {
+    VALUE ary = DHEAP_GET_A(self);
+    ID id_freeze = rb_intern("freeze");
+    rb_funcall(ary, id_freeze, 0);
+    return rb_call_super(0, NULL);
+}
+
+static VALUE
+dheap_ary_push(VALUE ary, int d, VALUE val, VALUE scr)
+{
+    DHEAP_APPEND(ary, scr, val);
+    long last_index = DHEAP_LAST_IDX(ary);
+    return dheap_ary_sift_up(ary, d, last_index);
+}
 
 /*
  * Push val onto the end of the heap, then sift up to maintain heap property.
@@ -146,12 +199,16 @@ static VALUE dheap_d(VALUE dheap) { return dheap_get_d(dheap); }
  *
  */
 static VALUE
-dheap_push(VALUE dheap, VALUE val) {
-    VALUE heap_a = dheap_get_a(dheap);
-    VALUE heap_d = dheap_get_d(dheap);
-    rb_ary_push(heap_a, val);
-    long last_idx = RARRAY_LEN(heap_a) - 1;
-    return dheap_sift_up_s(Qnil, heap_a, heap_d, LONG2NUM(last_idx));
+dheap_push(int argc, VALUE *argv, VALUE self) {
+    rb_check_arity(argc, 1, 2);
+    VALUE scr  = argv[0];
+    VALUE val  = argc < 2 ? scr : argv[1];
+
+    VALUE ary  = DHEAP_GET_A(self);
+    VALUE dval = DHEAP_GET_D(self);
+    int d = FIX2INT(dval);
+
+    return dheap_ary_push(ary, d, val, scr);
 }
 
 /*
@@ -163,39 +220,87 @@ dheap_push(VALUE dheap, VALUE val) {
  *
  */
 static VALUE
-dheap_left_shift(VALUE dheap, VALUE val) {
-    dheap_push(dheap, val);
-    return dheap;
+dheap_left_shift(VALUE self, VALUE val) {
+    dheap_push(1, &val, self);
+    return self;
+}
+
+#define DHEAP_Pop_Init(self) \
+    VALUE ary  = DHEAP_GET_A(self); \
+    VALUE dval = DHEAP_GET_D(self); \
+    long last_index = DHEAP_LAST_IDX(ary); \
+
+#define DHEAP_Pop_SwapLastAndSiftDown(ary, dval, last_index, sift_value) \
+    if (last_index == 0) { DHEAP_DROP_LAST(ary); return pop_value; } \
+    VALUE sift_value = DHEAP_VALUE(ary, last_index); \
+    VALUE sift_score = DHEAP_SCORE(ary, last_index); \
+    DHEAP_ASSIGN(ary, 0, sift_score, sift_value); \
+    DHEAP_DROP_LAST(ary); \
+    dheap_ary_sift_down(ary, FIX2INT(dval), 0);
+
+static VALUE
+dheap_peek(VALUE self) {
+    VALUE ary = DHEAP_GET_A(self);
+    return DHEAP_VALUE(ary, 0);
 }
 
 /*
  * Pops the minimum value from the top of the heap, sifting down to maintain
  * heap property.
  *
- * Time complexity: O(log n / log d).
+ * Time complexity: O(d log n / log d).
  *
  */
 static VALUE
-dheap_pop(VALUE dheap) {
-    VALUE heap_a = dheap_get_a(dheap);
-    VALUE heap_d = dheap_get_d(dheap);
-    long last_idx = RARRAY_LEN(heap_a) - 1;
+dheap_pop(VALUE self) {
+    DHEAP_Pop_Init(self);
+    if (last_index <  0) return Qnil;
+    VALUE pop_value = DHEAP_VALUE(ary, 0);
+
+    DHEAP_Pop_SwapLastAndSiftDown(ary, dval, last_index, sift_value);
+    return pop_value;
+}
+
+/*
+ * Pops the minimum value from the top of the heap, sifting down to maintain
+ * heap property.
+ *
+ * Time complexity: O(d log n / log d).
+ *
+ */
+static VALUE
+dheap_pop_lte(VALUE self, VALUE below_score) {
+    DHEAP_Pop_Init(self);
+    if (last_index <  0) return Qnil;
+    VALUE pop_value = DHEAP_VALUE(ary, 0);
+
+    VALUE pop_score = DHEAP_SCORE(ary, 0);
+    struct cmp_opt_data cmp_opt = { 0, 0 };
+    if (below_score && !CMP_LTE(pop_score, below_score, cmp_opt)) return Qnil;
 
-    /*
-     * short-circuit empty or nearly empty
-     */
-    if (last_idx <= 0) return rb_ary_pop(heap_a);
+    DHEAP_Pop_SwapLastAndSiftDown(ary, dval, last_index, sift_value);
+    return pop_value;
+}
 
-    /*
-     * swap with last, then sift down
-     */
-    VALUE pop_val  = rb_ary_entry(heap_a, 0);
-    VALUE sift_val = rb_ary_entry(heap_a, last_idx);
-    rb_ary_store(heap_a, 0, sift_val);
-    rb_ary_pop(heap_a);
-    dheap_sift_down_s(Qnil, heap_a, heap_d, LONG2NUM(0));
+/*
+ * Pops the minimum value from the top of the heap, sifting down to maintain
+ * heap property.
+ *
+ * Time complexity: O(d log n / log d).
+ *
+ */
+static VALUE
+dheap_pop_lt(VALUE self, VALUE below_score) {
+    DHEAP_Pop_Init(self);
+    if (last_index <  0) return Qnil;
+    VALUE pop_value = DHEAP_VALUE(ary, 0);
+
+    VALUE pop_score = DHEAP_SCORE(ary, 0);
+    struct cmp_opt_data cmp_opt = { 0, 0 };
+    if (below_score && !CMP_LT(pop_score, below_score, cmp_opt)) return Qnil;
 
-    return pop_val;
+    DHEAP_Pop_SwapLastAndSiftDown(ary, dval, last_index, sift_value);
+    return pop_value;
 }
 
 void
@@ -206,14 +311,20 @@ Init_d_heap(void)
     id_ivar_d = rb_intern_const("d");
 
     rb_cDHeap = rb_define_class("DHeap", rb_cObject);
-    rb_define_method(rb_cDHeap, "initialize", dheap_initialize, -1);
-    rb_define_method(rb_cDHeap, "d", dheap_d, 0);
-    rb_define_private_method(rb_cDHeap, "_ary_", dheap_a, 0);
-
     rb_define_singleton_method(rb_cDHeap, "heap_sift_down", dheap_sift_down_s, 3);
     rb_define_singleton_method(rb_cDHeap, "heap_sift_up",   dheap_sift_up_s, 3);
 
-    rb_define_method(rb_cDHeap, "push", dheap_push, 1);
-    rb_define_method(rb_cDHeap, "<<",   dheap_left_shift,  1);
-    rb_define_method(rb_cDHeap, "pop",  dheap_pop,  0);
+    rb_define_method(rb_cDHeap, "initialize", dheap_initialize, -1);
+    rb_define_method(rb_cDHeap, "d", dheap_attr_d, 0);
+    rb_define_method(rb_cDHeap, "freeze", dheap_freeze, 0);
+
+    rb_define_method(rb_cDHeap, "size", dheap_size, 0);
+    rb_define_method(rb_cDHeap, "empty?", dheap_empty_p, 0);
+
+    rb_define_method(rb_cDHeap, "peek",    dheap_peek, 0);
+    rb_define_method(rb_cDHeap, "push",    dheap_push, -1);
+    rb_define_method(rb_cDHeap, "<<",      dheap_left_shift, 1);
+    rb_define_method(rb_cDHeap, "pop",     dheap_pop, 0);
+    rb_define_method(rb_cDHeap, "pop_lt",  dheap_pop_lt, 1);
+    rb_define_method(rb_cDHeap, "pop_lte", dheap_pop_lte, 1);
 }

data/ext/d_heap/d_heap.h

@@ -3,31 +3,72 @@
 
 #include "ruby.h"
 
-// This is somewhat a arbitary boundary, but it is highly unlikely that the
-// gains from fewer levels can outweight doing this many comparisons per level.
-// Since the comparisons will still be executed using <=> on ruby objects, it's
-// likely they will be too slow to make any d > 8 worthwhile.
-#define DHEAP_MAX_D 128
+// d=4 uses the fewest comparisons for insert + delete-min (in the worst case).
 #define DHEAP_DEFAULT_D 4
 
-#define CMP_LT(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) < 0)
-#define CMP_LTE(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) <= 0)
-#define CMP_GT(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) > 0)
-#define CMP_GTE(a, b) \
-    (rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b) >= 0)
+// This is a somewhat arbitary maximum. But benefits from more leaf nodes
+// are very unlikely to outweigh the increasinly higher number of worst-case
+// comparisons as d gets further from 4.
+#define DHEAP_MAX_D 32
+
+
+#define CMP_LT(a, b, cmp_opt) \
+    (OPTIMIZED_CMP(a, b, cmp_opt) < 0)
+#define CMP_LTE(a, b, cmp_opt) \
+    (OPTIMIZED_CMP(a, b, cmp_opt) <= 0)
+#define CMP_GT(a, b, cmp_opt) \
+    (OPTIMIZED_CMP(a, b, cmp_opt) > 0)
+#define CMP_GTE(a, b, cmp_opt) \
+    (OPTIMIZED_CMP(a, b, cmp_opt) >= 0)
 
 VALUE rb_cDHeap;
 ID id_cmp;
 
+// from internal/numeric.h
+#ifndef INTERNAL_NUMERIC_H
+int rb_float_cmp(VALUE x, VALUE y);
+#endif /* INTERNAL_NUMERIC_H */
+
+// from internal/compar.h
+#ifndef INTERNAL_COMPAR_H
+#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
+
+enum {
+    cmp_opt_Integer,
+    cmp_opt_String,
+    cmp_opt_Float,
+    cmp_optimizable_count
+};
+
+struct cmp_opt_data {
+    unsigned int opt_methods;
+    unsigned int opt_inited;
+};
+
+#define NEW_CMP_OPT_MEMO(type, value) \
+    NEW_PARTIAL_MEMO_FOR(type, value, cmp_opt)
+#define CMP_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(cmp_opt_,type))
+#define CMP_OPTIMIZABLE(data, type) \
+    (((data).opt_inited & CMP_OPTIMIZABLE_BIT(type)) ? \
+     ((data).opt_methods & CMP_OPTIMIZABLE_BIT(type)) : \
+     (((data).opt_inited |= CMP_OPTIMIZABLE_BIT(type)), \
+      rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && \
+      ((data).opt_methods |= CMP_OPTIMIZABLE_BIT(type))))
+
+#define OPTIMIZED_CMP(a, b, data) \
+    ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(data, Integer)) ? \
+     (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : \
+     (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(data, String)) ? \
+     rb_str_cmp(a, b) : \
+     (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b) && CMP_OPTIMIZABLE(data, Float)) ? \
+     rb_float_cmp(a, b) : \
+     rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
+
 #define puts(v) { \
     ID sym_puts = rb_intern("puts"); \
     rb_funcall(rb_mKernel, sym_puts, 1, v); \
 }
 
-VALUE dheap_ary_sift_up(VALUE heap_array, int d, long sift_idx);
-VALUE dheap_ary_sift_down(VALUE heap_array, int d, long sift_idx);
+#endif /* INTERNAL_COMPAR_H */
 
 #endif /* D_HEAP_H */

data/lib/d_heap.rb

@@ -3,36 +3,8 @@ require "d_heap/version"
 
 class DHeap
 
-  def initialize_dup(other)
-    super
-    _ary_.replace(_ary_.dup)
-  end
-
-  def freeze
-    _ary_.freeze
-    super
-  end
-
-  def peek
-    _ary_[0]
-  end
-
-  def empty?
-    _ary_.empty?
-  end
-
-  def size
-    _ary_.size
-  end
-
-  def each_in_order
-    return to_enum(__method__) unless block_given?
-    heap = dup
-    yield val until heap.emptu?
-  end
-
-  def to_a
-    _ary_.dup
+  def initialize_copy(other)
+    raise NotImplementedError, "initialize_copy should deep copy array"
   end
 
 end

data/lib/d_heap/version.rb

@@ -1,3 +1,3 @@
 class DHeap
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: d_heap
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - nicholas a. evans
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-23 00:00:00.000000000 Z
+date: 2020-12-24 00:00:00.000000000 Z
 dependencies: []
 description: |
   A C extension implementation of a d-ary heap data structure, suitable for