d_heap 0.1.0 → 0.4.0

data/docs/profile.txt

@@ -0,0 +1,392 @@
+Profiling run at 2021-01-10 21:34:56 -0500
+ruby v2.7.2, DHeap v0.3.0
+
+~~~~~~ filling @dheap_bm_random_vals with 1.0M ~~~~~~
+########################################################################
+# Profile w/ N=5 (i=1000000)
+# (n.b. RubyProf & tracepoint can change relative performance.
+#       A sampling profiler can provide more accurate relative metrics.
+########################################################################
+
+Filling    push and resort ---------------------------
+Profiling  push and resort ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 2.639873
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 31.49      2.640     0.831     0.000     1.808        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 25.69      1.219     0.678     0.000     0.541  1000000   DHeap::Benchmarks::Sorting#<<  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:35
+ 15.00      0.396     0.396     0.000     0.000  1000000   Array#sort!                    
+ 12.38      0.462     0.327     0.000     0.136  1000000   DHeap::Benchmarks::Sorting#pop /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:42
+  5.50      0.145     0.145     0.000     0.000  1000000   Array#push                     
+  5.13      0.136     0.136     0.000     0.000  1000000   Array#shift                    
+  4.81      0.127     0.127     0.000     0.000  1000000   Array#fetch                    
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   bsearch + insert ---------------------------
+Profiling bsearch + insert ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 2.634233
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 30.73      2.634     0.810     0.000     1.825        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 25.94      1.228     0.683     0.000     0.545  1000000   DHeap::Benchmarks::BSearch#<<  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:61
+ 14.83      0.391     0.391     0.000     0.000  1000000   Array#bsearch_index            
+ 12.79      0.462     0.337     0.000     0.125  1000000   DHeap::Benchmarks::BSearch#pop /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:70
+  5.85      0.154     0.154     0.000     0.000  1000000   Array#insert                   
+  5.10      0.134     0.134     0.000     0.000  1000000   Array#fetch                    
+  4.76      0.125     0.125     0.000     0.000  1000000   Array#pop                      
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   ruby binary heap ---------------------------
+Profiling ruby binary heap ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 4.940103
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 37.38      1.973     1.846     0.000     0.126  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:80
+ 33.66      2.042     1.663     0.000     0.380  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:96
+ 16.10      4.940     0.795     0.000     4.145        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+  2.64      0.130     0.130     0.000     0.000  1000000   Array#pop                      
+  2.63      0.130     0.130     0.000     0.000  1000000   Array#first                    
+  2.62      0.130     0.130     0.000     0.000  1000000   Array#fetch                    
+  2.56      0.126     0.126     0.000     0.000  1000000   Array#push                     
+  2.43      0.120     0.120     0.000     0.000  1000000   Array#last                     
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   quaternary DHeap ---------------------------
+Profiling quaternary DHeap ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 1.231464
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 60.13      1.231     0.741     0.000     0.491        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 16.72      0.206     0.206     0.000     0.000  1000000   DHeap#<<                       
+ 12.85      0.158     0.158     0.000     0.000  1000000   DHeap#pop                      
+ 10.30      0.127     0.127     0.000     0.000  1000000   Array#fetch                    
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+########################################################################
+# Profile w/ N=1365 (i=1000000)
+# (n.b. RubyProf & tracepoint can change relative performance.
+#       A sampling profiler can provide more accurate relative metrics.
+########################################################################
+
+Filling    push and resort ---------------------------
+Profiling  push and resort ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 41.950612
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 94.10     39.478    39.478     0.000     0.000  1000000   Array#sort!                    
+  2.11     41.951     0.884     0.000    41.066        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+  1.68     40.328     0.707     0.000    39.621  1000000   DHeap::Benchmarks::Sorting#<<  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:35
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   bsearch + insert ---------------------------
+Profiling bsearch + insert ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 3.559064
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 37.92      1.349     1.349     0.000     0.000  1000000   Array#bsearch_index            
+ 22.76      3.559     0.810     0.000     2.749        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 18.47      2.157     0.657     0.000     1.499  1000000   DHeap::Benchmarks::BSearch#<<  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:61
+  9.45      0.462     0.336     0.000     0.125  1000000   DHeap::Benchmarks::BSearch#pop /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:70
+  4.21      0.150     0.150     0.000     0.000  1000000   Array#insert                   
+  3.67      0.131     0.131     0.000     0.000  1000000   Array#fetch                    
+  3.53      0.125     0.125     0.000     0.000  1000000   Array#pop                      
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   ruby binary heap ---------------------------
+Profiling ruby binary heap ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 11.581886
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 52.04      6.160     6.027     0.000     0.132  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:80
+ 35.10      4.453     4.065     0.000     0.388  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:96
+  7.21     11.582     0.835     0.000    10.747        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+  1.16      0.134     0.134     0.000     0.000  1000000   Array#fetch                    
+  1.14      0.132     0.132     0.000     0.000  1000000   Array#push                     
+  1.14      0.132     0.132     0.000     0.000  1000000   Array#pop                      
+  1.13      0.131     0.131     0.000     0.000  1000000   Array#first                    
+  1.08      0.125     0.125     0.000     0.000  1000000   Array#last                     
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   quaternary DHeap ---------------------------
+Profiling quaternary DHeap ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 1.431426
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 50.61      1.431     0.724     0.000     0.707        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 21.61      0.309     0.309     0.000     0.000  1000000   DHeap#<<                       
+ 19.18      0.275     0.275     0.000     0.000  1000000   DHeap#pop                      
+  8.59      0.123     0.123     0.000     0.000  1000000   Array#fetch                    
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+########################################################################
+# Profile w/ N=87381 (i=1000000)
+# (n.b. RubyProf & tracepoint can change relative performance.
+#       A sampling profiler can provide more accurate relative metrics.
+########################################################################
+
+Filling   bsearch + insert ---------------------------
+Profiling bsearch + insert ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 5.894803
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 34.53      2.035     2.035     0.000     0.000  1000000   Array#bsearch_index            
+ 30.22      1.782     1.782     0.000     0.000  1000000   Array#insert                   
+ 13.74      5.895     0.810     0.000     5.085        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 11.52      4.496     0.679     0.000     3.817  1000000   DHeap::Benchmarks::BSearch#<<  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:61
+  5.70      0.459     0.336     0.000     0.124  1000000   DHeap::Benchmarks::BSearch#pop /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:70
+  2.20      0.130     0.130     0.000     0.000  1000000   Array#fetch                    
+  2.10      0.124     0.124     0.000     0.000  1000000   Array#pop                      
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   ruby binary heap ---------------------------
+Profiling ruby binary heap ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 16.514635
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 45.67      7.926     7.542     0.000     0.384  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:96
+ 45.43      7.630     7.502     0.000     0.128  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:80
+  5.00     16.515     0.826     0.000    15.688        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
+Filling   quaternary DHeap ---------------------------
+Profiling quaternary DHeap ---------------------------
+Measure Mode: wall_time
+Thread ID: 1360
+Fiber ID: 1340
+Total: 1.622729
+Sort by: self_time
+
+ %self      total      self      wait     child     calls  name                           location
+ 44.66      1.623     0.725     0.000     0.898        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 27.42      0.445     0.445     0.000     0.000  1000000   DHeap#pop                      
+ 20.41      0.331     0.331     0.000     0.000  1000000   DHeap#<<                       
+  7.51      0.122     0.122     0.000     0.000  1000000   Array#fetch                    
+
+* recursively called methods
+
+Columns are:
+
+  %self     - The percentage of time spent in this method, derived from self_time/total_time.
+  total     - The time spent in this method and its children.
+  self      - The time spent in this method.
+  wait      - The amount of time this method waited for other threads.
+  child     - The time spent in this method's children.
+  calls     - The number of times this method was called.
+  name      - The name of the method.
+  location  - The location of the method.
+
+The interpretation of method names is:
+
+  * MyObject#test - An instance method "test" of the class "MyObject"
+  * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+

data/ext/d_heap/d_heap.c

@@ -1,219 +1,762 @@
+#include <float.h>
 #include "d_heap.h"
 
-ID id_ivar_a;
-ID id_ivar_d;
+#define SCORE_AS_LONG_DOUBLE 1
 
-#define DHEAP_Check_d_size(d) \
-    if (d < 2) { \
-        rb_raise(rb_eIndexError, "DHeap d=%d is too small", d); \
-    } \
-    if (d > DHEAP_MAX_D) { \
-        rb_raise(rb_eIndexError, "DHeap d=%d is too large", d); \
+ID id_cmp; // <=>
+ID id_abs; // abs
+
+#ifdef SCORE_AS_LONG_DOUBLE
+    #define SCORE long double
+#else
+    #define SCORE VALUE
+#endif
+
+typedef struct dheap_struct {
+    int d;
+    VALUE values;
+#ifdef SCORE_AS_LONG_DOUBLE
+    long size;
+    long capa;
+    SCORE *cscores;
+#else
+    VALUE scores;  // T_ARRAY of comparable objects
+#endif
+} dheap_t;
+
+#define DHEAP_VALUE(heap, idx) RARRAY_AREF((heap)->values, idx)
+#define DHEAP_IDX_LAST(heap) (DHEAP_SIZE((heap)) - 1)
+#define DHEAP_IDX_PARENT(heap, idx) (((idx) - 1) / (heap)->d)
+#define DHEAP_IDX_CHILD0(heap, idx) (((idx) * (heap)->d) + 1)
+
+#ifdef SCORE_AS_LONG_DOUBLE
+    #define DHEAP_SIZE(heap) ((heap)->size)
+#else
+    #define DHEAP_SIZE(heap) (RARRAY_LEN((heap)->scores))
+#endif
+
+#ifdef SCORE_AS_LONG_DOUBLE
+    #define DHEAP_SCORE(heap, idx)                                       \
+       (idx < 0 || heap->size <= idx ? (SCORE)0 :                        \
+        ((heap)->cscores[idx]))
+#else
+    #define DHEAP_SCORE(heap, idx) RARRAY_AREF((heap)->scores, idx)
+#endif
+
+#ifdef SCORE_AS_LONG_DOUBLE
+
+#define CMP_LT(a, b)  (a <  b)
+#define CMP_LTE(a, b) (a <= b)
+#define CMP_GT(a, b)  (a >  b)
+#define CMP_GTE(a, b) (a >= b)
+
+#if LDBL_MANT_DIG < SIZEOF_UNSIGNED_LONG_LONG * 8
+#error 'unsigned long long' should fit into 'long double' mantissa
+#endif
+
+// copied and modified from ruby's object.c
+#define FIX2SCORE(x) (long double)FIX2LONG(x)
+// We could translate a much wider range of values to long double by
+// implementing a new `rb_big2ldbl(x)` function. But requires reaching into
+// T_BIGNUM internals.
+static inline long double
+BIG2SCORE(VALUE x)
+{
+    if (RBIGNUM_POSITIVE_P(x)) {
+        unsigned long long ull = rb_big2ull(x);
+        return (long double)ull;
+    } else {
+        unsigned long long ull;
+        long double ldbl;
+        x = rb_funcall(x, id_abs, 0);
+        ull  = rb_big2ull(x);
+        ldbl = (long double) ull;
+        return -ldbl;
+    }
+}
+#define INT2SCORE(x) \
+    (FIXNUM_P(x) ? FIX2SCORE(x) : BIG2SCORE(x))
+#define NUM2SCORE(x)                                                     \
+    (FIXNUM_P(x) ? FIX2SCORE(x) :                                        \
+     RB_TYPE_P(x, T_BIGNUM) ? BIG2SCORE(x) :                             \
+     (Check_Type(x, T_FLOAT), (long double)RFLOAT_VALUE(x)))
+static inline long double
+RAT2SCORE(VALUE x)
+{
+    VALUE num = rb_rational_num(x);
+    VALUE den = rb_rational_den(x);
+    return NUM2SCORE(num) / NUM2SCORE(den);
+}
+
+/*
+ * Convert both T_FIXNUM and T_FLOAT (and sometimes T_BIGNUM, T_RATIONAL,
+ * String, etc) to SCORE
+ * * with no loss of precision (where possible for Integer and Float),
+ * * raises an exception if
+ *   * a positive integer is too large for unsigned long long (should be 64bit)
+ *   * a negative integer is too small for   signed long long (should be 64bit)
+ * * reduced to long double (should be 80 or 128 bit) if it is Rational
+ * * reduced to double precision if the value is convertable by Float(x)
+ */
+static inline long double
+VAL2SCORE(VALUE score)
+{
+    // assert that long double can hold 'unsigned long long':
+    // static_assert(sizeof(unsigned long long) * 8 <= LDBL_MANT_DIG);
+    // assert that long double can hold T_FLOAT
+    // static_assert(sizeof(double) <= sizeof(long double));
+
+    switch (TYPE(score)) {
+        case T_FIXNUM:
+            return FIX2SCORE(score);
+        case T_BIGNUM:
+            return BIG2SCORE(score);
+        case T_RATIONAL:
+            return RAT2SCORE(score);
+        default:
+            return (long double)(NUM2DBL(rb_Float(score)));
+    }
+}
+
+#else
+
+#define VAL2SCORE(score) (score)
+
+#define CMP_LT(a, b)  (optimized_cmp(a, b) <  0)
+#define CMP_LTE(a, b) (optimized_cmp(a, b) <= 0)
+#define CMP_GT(a, b)  (optimized_cmp(a, b) >  0)
+#define CMP_GTE(a, b) (optimized_cmp(a, b) >= 0)
+
+// from internal/compar.h
+#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
+/*
+ * short-circuit evaluation for a few basic types.
+ *
+ * Only Integer, Float, and String are optimized,
+ * and only when both arguments are the same type.
+ */
+static inline int
+optimized_cmp(SCORE a, SCORE b) {
+    if (a == b) // Fixnum equality and object equality
+        return 0;
+    if (FIXNUM_P(a) && FIXNUM_P(b))
+        return (FIX2LONG(a) < FIX2LONG(b)) ? -1 : 1;
+    if (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b))
+    {
+        double x, y;
+        x = RFLOAT_VALUE(a);
+        y = RFLOAT_VALUE(b);
+        if (isnan(x) || isnan(y)) rb_cmperr(a, b); // raise ArgumentError
+        return (x < y) ? -1 : ((x == y) ? 0 : 1);
+    }
+    if (RB_TYPE_P(a, T_BIGNUM) && RB_TYPE_P(b, T_BIGNUM))
+        return FIX2INT(rb_big_cmp(a, b));
+    if (STRING_P(a) && STRING_P(b))
+        return rb_str_cmp(a, b);
+
+    // give up on an optimized version and just call (a <=> b)
+    return rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b);
+}
+
+#endif
+
+#define DHEAP_Check_d_size(d) do {                            \
+    if (d < 2) {                                              \
+        rb_raise(rb_eArgError, "DHeap d=%d is too small", d); \
+    }                                                         \
+    if (d > DHEAP_MAX_D) {                                    \
+        rb_raise(rb_eArgError, "DHeap d=%d is too large", d); \
+    }                                                         \
+} while (0)
+
+#define DHEAP_Check_Index(index, last_index) do {                     \
+    if (index < 0) {                                                  \
+        rb_raise(rb_eIndexError, "DHeap index %ld too small", index); \
+    }                                                                 \
+    else if (last_index < index) {                                    \
+        rb_raise(rb_eIndexError, "DHeap index %ld too large", index); \
+    }                                                                 \
+} while (0)
+
+static void
+dheap_compact(void *ptr)
+{
+    dheap_t *heap = ptr;
+#ifndef SCORE_AS_LONG_DOUBLE
+    if (heap->scores) dheap_gc_location( heap->scores );
+#endif
+    if (heap->values) dheap_gc_location( heap->values );
+}
+
+static void
+dheap_mark(void *ptr)
+{
+    dheap_t *heap = ptr;
+#ifndef SCORE_AS_LONG_DOUBLE
+    if (heap->scores) rb_gc_mark_movable(heap->scores);
+#endif
+    if (heap->values) rb_gc_mark_movable(heap->values);
+}
+
+static void
+dheap_free(void *ptr)
+{
+#ifdef SCORE_AS_LONG_DOUBLE
+    dheap_t *heap = ptr;
+    heap->size = 0;
+    if (heap->cscores) {
+        ruby_xfree(heap->cscores);
+        heap->cscores = NULL;
+    }
+    heap->capa = 0;
+#endif
+    xfree(ptr);
+}
+
+static size_t
+dheap_memsize(const void *ptr)
+{
+    const dheap_t *heap = ptr;
+    size_t size = 0;
+    size += sizeof(*heap);
+#ifdef SCORE_AS_LONG_DOUBLE
+    size += sizeof(long double) * heap->capa;
+#endif
+    return size;
+}
+
+static const rb_data_type_t dheap_data_type = {
+    "DHeap",
+    {
+        (void (*)(void*))dheap_mark,
+        (void (*)(void*))dheap_free,
+        (size_t (*)(const void *))dheap_memsize,
+        dheap_compact_callback(dheap_compact),
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+dheap_s_alloc(VALUE klass)
+{
+    VALUE obj;
+    dheap_t *heap;
+
+    obj = TypedData_Make_Struct(klass, dheap_t, &dheap_data_type, heap);
+    heap->d = DHEAP_DEFAULT_D;
+    heap->values = Qnil;
+
+#ifdef SCORE_AS_LONG_DOUBLE
+    heap->size = 0;
+    heap->capa = 0;
+    heap->cscores = NULL;
+#else
+    heap->scores = Qnil;
+#endif
+
+    return obj;
+}
+
+static inline dheap_t *
+get_dheap_struct(VALUE self)
+{
+    dheap_t *heap;
+    TypedData_Get_Struct(self, dheap_t, &dheap_data_type, heap);
+    Check_Type(heap->values, T_ARRAY); // ensure it's been initialized
+    return heap;
+}
+
+#ifdef SCORE_AS_LONG_DOUBLE
+
+static void
+dheap_set_capa(dheap_t *heap, long new_capa)
+{
+    long double *new, *old;
+    // Do nothing if we already have the capacity or are resizing too small
+    if (new_capa <= heap->capa) return;
+    if (new_capa <= heap->size) return;
+
+    // allocate
+    new = ruby_xcalloc(new_capa, sizeof(long double));
+    old = heap->cscores;
+
+    // copy contents
+    if (old) {
+        MEMCPY(new, old, long double, heap->size);
+        ruby_xfree(old);
     }
 
-#define DHEAP_Check_Sift_Idx(sift_idx, last_idx) \
-    if (sift_idx < 0) { \
-        rb_raise(rb_eIndexError, "sift_idx %ld too small", sift_idx); \
-    } \
-    else if (last_idx < sift_idx) { \
-        rb_raise(rb_eIndexError, "sift_idx %ld too large", sift_idx); \
+    // set vars
+    heap->cscores = new;
+    heap->capa = new_capa;
+}
+
+static void
+dheap_ensure_room_for_push(dheap_t *heap, long incr_by)
+{
+    long new_size = heap->size + incr_by;
+
+    // check for overflow of new_size
+    if (DHEAP_MAX_SIZE - incr_by < heap->size)
+        rb_raise(rb_eIndexError, "index %ld too big", new_size);
+
+    // if it existing capacity is too small
+    if (heap->capa < new_size) {
+        // double it...
+        long new_capa = new_size * 2;
+        if (DHEAP_CAPA_INCR_MAX < new_size)
+            new_size = new_size + DHEAP_CAPA_INCR_MAX;
+        // check for overflow of new_capa
+        if (DHEAP_MAX_SIZE / 2 < new_size) new_capa = DHEAP_MAX_SIZE;
+        // cap max incr_by
+        if (heap->capa + DHEAP_CAPA_INCR_MAX < new_capa)
+            new_capa = heap->capa + DHEAP_CAPA_INCR_MAX;
+
+        dheap_set_capa(heap, new_capa);
     }
+}
+
+#endif
+
+/*
+ * @overload initialize(d = DHeap::DEFAULT_D)
+ *   Initialize a _d_-ary min-heap.
+ *
+ *   @param d [Integer] maximum number of children per parent
+ */
+static VALUE
+dheap_initialize(int argc, VALUE *argv, VALUE self) {
+    dheap_t *heap;
+    int d;
+
+    rb_check_arity(argc, 0, 1);
+    TypedData_Get_Struct(self, dheap_t, &dheap_data_type, heap);
+
+    d = argc ? NUM2INT(argv[0]) : DHEAP_DEFAULT_D;
+    DHEAP_Check_d_size(d);
+    heap->d = d;
+
+    heap->values = rb_ary_new_capa(DHEAP_DEFAULT_SIZE);
+
+#ifdef SCORE_AS_LONG_DOUBLE
+    dheap_set_capa(heap, DHEAP_DEFAULT_SIZE);
+#else
+    heap->scores = rb_ary_new_capa(DHEAP_DEFAULT_SIZE);
+#endif
+
+    return self;
+}
+
+/* :nodoc: */
+static VALUE
+dheap_initialize_copy(VALUE copy, VALUE orig)
+{
+    dheap_t *heap_copy;
+    dheap_t *heap_orig = get_dheap_struct(orig);
+
+    rb_check_frozen(copy);
+    TypedData_Get_Struct(copy, dheap_t, &dheap_data_type, heap_copy);
 
-#define DHEAP_Load_Sift_Vals(heap_array, dval, idxval) \
-    Check_Type(dval, T_FIXNUM); \
-    int d = FIX2INT(dval); \
-    long sift_idx = NUM2LONG(idxval);
+    heap_copy->d = heap_orig->d;
 
-#define DHEAP_Check_Sift_Args(heap_array, d, sift_idx) \
-    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); \
-    \
-    VALUE sift_val = rb_ary_entry(heap_array, sift_idx);
+    heap_copy->values = rb_ary_new();
+    rb_ary_replace(heap_copy->values, heap_orig->values);
+
+#ifdef SCORE_AS_LONG_DOUBLE
+    dheap_set_capa(heap_copy, heap_orig->capa);
+    heap_copy->size = heap_orig->size;
+    if (heap_copy->size)
+        MEMCPY(heap_orig->cscores, heap_copy->cscores, long double, heap_orig->size);
+#else
+    heap_copy->scores = rb_ary_new();
+    rb_ary_replace(heap_copy->scores, heap_orig->scores);
+#endif
+
+    return copy;
+}
+
+static inline void
+dheap_assign(dheap_t *heap, long idx, SCORE score, VALUE value)
+{
+#ifdef SCORE_AS_LONG_DOUBLE
+    heap->cscores[idx] = score;
+    rb_ary_store(heap->values, idx, value);
+#else
+    rb_ary_store(heap->scores, idx, score);
+    rb_ary_store(heap->values, idx, value);
+#endif
+}
 
 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(dheap_t *heap, long sift_index) {
+    VALUE sift_value;
+    SCORE sift_score;
+
+    long last_index = DHEAP_IDX_LAST(heap);
+    DHEAP_Check_Index(sift_index, last_index);
+
+    sift_value = DHEAP_VALUE(heap, sift_index);
+    sift_score = DHEAP_SCORE(heap, sift_index);
+
     // 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) {
+        SCORE parent_score;
+        VALUE parent_value;
+
+        debug(rb_sprintf("sift up(%"PRIsVALUE", %d, %ld)", heap->values, heap->d, sift_index));
+        parent_index = DHEAP_IDX_PARENT(heap, sift_index);
+        parent_score = DHEAP_SCORE(heap, parent_index);
 
         // parent is smaller: heap is restored
-        if (CMP_LTE(parent_val, sift_val)) break;
+        if (CMP_LTE(parent_score, sift_score)) 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);
+        parent_value = DHEAP_VALUE(heap, parent_index);
+        dheap_assign(heap, sift_index, parent_score, parent_value);
+        dheap_assign(heap, parent_index, sift_score, sift_value);
     }
-    return LONG2NUM(sift_idx);
+    debug(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap->values, heap->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(dheap_t *heap, long sift_index) {
+    VALUE sift_value;
+    SCORE sift_score;
+    long last_index = DHEAP_IDX_LAST(heap);
+    DHEAP_Check_Index(sift_index, last_index);
+
+    sift_value = DHEAP_VALUE(heap, sift_index);
+    sift_score = DHEAP_SCORE(heap, sift_index);
+
      // 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) {
+        long child_idx0, last_sibidx;
+        SCORE child_score;
+        VALUE child_value;
+
         // 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;
+        child_idx0 = child_index = DHEAP_IDX_CHILD0(heap, sift_index);
+        debug(rb_sprintf("sift dn(%"PRIsVALUE", %d, %ld)", heap->values, heap->d, 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
+        last_sibidx = child_idx0 + heap->d - 1;
+        if (last_index < last_sibidx) last_sibidx = last_index;
+        child_score = DHEAP_SCORE(heap, child_idx0);
+        child_index = child_idx0;
+        for (long sibling_index = child_idx0 + 1;
+                sibling_index <= last_sibidx;
+                ++sibling_index) {
+            SCORE sibling_score = DHEAP_SCORE(heap, sibling_index);
+
+            if (CMP_LT(sibling_score, child_score)) {
+                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)) 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);
+        child_value = DHEAP_VALUE(heap, child_index);
+        dheap_assign(heap, sift_index, child_score, child_value);
+        dheap_assign(heap, child_index, sift_score, sift_value);
     }
-    return LONG2NUM(sift_idx);
+    debug(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap->values, heap->d, sift_index));
+    return LONG2NUM(sift_index);
 }
 
 /*
- * call-seq:
- *    DHeap.array_sift_up(heap_array, d, sift_idx)
- *
- * Treats +heap_array+ as a +d+-ary heap and sifts up from +sift_idx+ to restore
- * the heap property.
- *
- * Time complexity: O(d log n / log d).  If the average up shifted element sorts
- * into the bottom layer (e.g. new timers), this can avg O(1).
+ * @return [Integer] the number of elements in the heap
+ */
+static VALUE
+dheap_size(VALUE self)
+{
+    dheap_t *heap = get_dheap_struct(self);
+    long size = DHEAP_SIZE(heap);
+    return LONG2NUM(size);
+}
+
+/*
+ * @return [Boolean] is the heap empty?
+ */
+static VALUE
+dheap_empty_p(VALUE self)
+{
+    dheap_t *heap = get_dheap_struct(self);
+    long size = DHEAP_SIZE(heap);
+    return size == 0 ? Qtrue : Qfalse;
+}
+
+/*
+ * @return [Integer] the maximum number of children per parent
+ */
+static VALUE
+dheap_attr_d(VALUE self)
+{
+    dheap_t *heap = get_dheap_struct(self);
+    return INT2FIX(heap->d);
+}
+
+/*
+ * Freezes the heap as well as its underlying array, but does <i>not</i>
+ * deep-freeze the elements in the heap.
  *
+ * @return [self]
  */
 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);
+dheap_freeze(VALUE self) {
+    dheap_t *heap = get_dheap_struct(self);
+    ID id_freeze = rb_intern("freeze");
+    rb_funcall(heap->values, id_freeze, 0);
+#ifndef SCORE_AS_LONG_DOUBLE
+    rb_funcall(heap->scores, id_freeze, 0);
+#endif
+    return rb_call_super(0, NULL);
+}
+
+/* :nodoc: */
+static VALUE
+dheap_init_clone(VALUE clone, VALUE orig, VALUE kwfreeze)
+{
+    dheap_initialize_copy(clone, orig);
+    if (RTEST(kwfreeze) || (kwfreeze == Qnil && OBJ_FROZEN(orig))) {
+        rb_funcall(clone, rb_intern("freeze"), 0);
+    }
+    return clone;
 }
 
 /*
- * call-seq:
- *    DHeap.array_sift_down(heap_array, d, sift_idx)
+ * @overload push(score, value = score)
+ *
+ * Push a value onto heap, using a score to determine sort-order.
  *
- * Treats +heap_array+ as a +d+-ary heap and sifts down from +sift_idx+ to
- * restore the heap property.
+ * Ideally, the score should be a frozen value that can be efficiently compared
+ * to other scores, e.g. an Integer or Float or (maybe) a String
  *
- * Time complexity: O(d log n / log d).  If the average down shifted element
- * sorts into the bottom layer (e.g. canceled timers), this can avg O(1).
+ * Time complexity: <b>O(log n / log d)</b> <i>(worst-case)</i>
  *
+ * @param score [#<=>] a value that can be compared to other scores.
+ * @param value [Object] an object that is associated with the score.
+ *
+ * @return [Integer] the index of the value's final position.
  */
 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);
+dheap_push(int argc, VALUE *argv, VALUE self) {
+    VALUE scr, val;
+    dheap_t *heap;
+    long last_index;
+    rb_check_frozen(self);
+
+    rb_check_arity(argc, 1, 2);
+    heap = get_dheap_struct(self);
+    scr = argv[0];
+    val = argc < 2 ? scr : argv[1];
+
+#ifdef SCORE_AS_LONG_DOUBLE
+    do {
+        long double score_as_ldbl = VAL2SCORE(scr);
+        dheap_ensure_room_for_push(heap, 1);
+        ++heap->size;
+        last_index = DHEAP_IDX_LAST(heap);
+        heap->cscores[last_index] = score_as_ldbl;
+    } while (0);
+#else
+    rb_ary_push((heap)->scores, scr);
+    last_index = DHEAP_IDX_LAST(heap);
+#endif
+    rb_ary_push((heap)->values, val);
+
+    return dheap_ary_sift_up(heap, last_index);
 }
 
+/*
+ * Pushes a comparable value onto the heap.
+ *
+ * The value will be its own score.
+ *
+ * Time complexity: <b>O(log n / log d)</b> <i>(worst-case)</i>
+ *
+ * @param value [#<=>] a value that can be compared to other heap members.
+ * @return [self]
+ */
 static VALUE
-dheap_initialize(int argc, VALUE *argv, VALUE self) {
-    rb_check_arity(argc, 0, 1);
-    int d = DHEAP_DEFAULT_D;
-    if (argc) {
-        d = NUM2INT(argv[0]);
-    }
-    DHEAP_Check_d_size(d);
-    rb_ivar_set(self, id_ivar_d, INT2FIX(d));
-    rb_ivar_set(self, id_ivar_a, rb_ary_new());
+dheap_left_shift(VALUE self, VALUE value) {
+    dheap_push(1, &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); }
+#ifdef SCORE_AS_LONG_DOUBLE
+    #define DHEAP_DROP_LAST(heap) do {                                   \
+        rb_ary_pop(heap->values);                                        \
+        --heap->size;                                                    \
+    } while (0)
+#else
+    #define DHEAP_DROP_LAST(heap) do {                                   \
+        rb_ary_pop(heap->values);                                        \
+        rb_ary_pop(heap->scores);                                        \
+    } while (0)
+#endif
+static inline void
+dheap_pop_swap_last_and_sift_down(dheap_t *heap, long last_index)
+{
+    if (last_index == 0) {
+        DHEAP_DROP_LAST(heap);
+    }
+    else
+    {
+        VALUE sift_value = DHEAP_VALUE(heap, last_index);
+        SCORE sift_score = DHEAP_SCORE(heap, last_index);
+        dheap_assign(heap, 0, sift_score, sift_value);
+        DHEAP_DROP_LAST(heap);
+        dheap_ary_sift_down(heap, 0);
+    }
+}
 
-static VALUE dheap_a(VALUE dheap) { return dheap_get_a(dheap); }
-static VALUE dheap_d(VALUE dheap) { return dheap_get_d(dheap); }
+#ifdef SCORE_AS_LONG_DOUBLE
+    #define DHEAP_CLEAR(heap) do {                                       \
+        rb_ary_clear(heap->values);                                      \
+        heap->size = 0;                                                  \
+    } while (0)
+#else
+    #define DHEAP_CLEAR(heap) do {                                       \
+        rb_ary_clear(heap->values);                                      \
+        rb_ary_clear(heap->scores);                                      \
+    } while (0)
+#endif
 
 /*
- * Push val onto the end of the heap, then sift up to maintain heap property.
+ * Returns the next value on the heap to be popped without popping it.
  *
- * Returns the index of the value's final position.
+ * Time complexity: <b>O(1)</b> <i>(worst-case)</i>
+ * @return [Object] the next value to be popped without popping it.
+ */
+static VALUE
+dheap_clear(VALUE self) {
+    dheap_t *heap = get_dheap_struct(self);
+    rb_check_frozen(self);
+    if (0 < DHEAP_SIZE(heap)) {
+        DHEAP_CLEAR(heap);
+    }
+    return self;
+}
+
+/*
+ * Returns the next value on the heap to be popped without popping it.
  *
+ * Time complexity: <b>O(1)</b> <i>(worst-case)</i>
+ * @return [Object] the next value to be popped without popping it.
  */
 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_peek(VALUE self) {
+    dheap_t *heap = get_dheap_struct(self);
+    if (DHEAP_IDX_LAST(heap) < 0) return Qnil;
+    return DHEAP_VALUE(heap, 0);
 }
 
 /*
- * Push val onto the end of the heap, then sift up to maintain heap property.
+ * Pops the minimum value from the top of the heap
  *
- * Time complexity: O(d log n / log d).
+ * Time complexity: <b>O(d log n / log d)</b> <i>(worst-case)</i>
+ */
+static VALUE
+dheap_pop(VALUE self) {
+    VALUE pop_value;
+    dheap_t *heap = get_dheap_struct(self);
+    long last_index = DHEAP_IDX_LAST(heap);
+    rb_check_frozen(self);
+
+    if (last_index < 0) return Qnil;
+    pop_value = DHEAP_VALUE(heap, 0);
+
+    dheap_pop_swap_last_and_sift_down(heap, last_index);
+    return pop_value;
+}
+
+/*
+ * Pops the minimum value only if it is less than or equal to a max score.
  *
- * Returns +self+.
+ * @param max_score [#to_f] the maximum score to be popped
  *
+ * @see #pop
  */
 static VALUE
-dheap_left_shift(VALUE dheap, VALUE val) {
-    dheap_push(dheap, val);
-    return dheap;
+dheap_pop_lte(VALUE self, VALUE max_score) {
+    VALUE pop_value;
+    dheap_t *heap = get_dheap_struct(self);
+    long last_index = DHEAP_IDX_LAST(heap);
+    rb_check_frozen(self);
+
+    if (last_index <  0) return Qnil;
+    pop_value = DHEAP_VALUE(heap, 0);
+
+    do {
+        SCORE max = VAL2SCORE(max_score);
+        SCORE pop_score = DHEAP_SCORE(heap, 0);
+        if (max && !CMP_LTE(pop_score, max)) return Qnil;
+    } while (0);
+
+    dheap_pop_swap_last_and_sift_down(heap, last_index);
+    return pop_value;
 }
 
 /*
- * Pops the minimum value from the top of the heap, sifting down to maintain
- * heap property.
+ * Pops the minimum value only if it is less than a max score.
  *
- * Time complexity: O(log n / log d).
+ * @param max_score [#to_f] the maximum score to be popped
  *
+ * Time complexity: <b>O(d log n / log d)</b> <i>(worst-case)</i>
  */
 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_lt(VALUE self, VALUE max_score) {
+    VALUE pop_value;
+    dheap_t *heap = get_dheap_struct(self);
+    long last_index = DHEAP_IDX_LAST(heap);
+    rb_check_frozen(self);
 
-    /*
-     * short-circuit empty or nearly empty
-     */
-    if (last_idx <= 0) return rb_ary_pop(heap_a);
+    if (last_index <  0) return Qnil;
+    pop_value = DHEAP_VALUE(heap, 0);
 
-    /*
-     * 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));
+    do {
+        SCORE max = VAL2SCORE(max_score);
+        SCORE pop_score = DHEAP_SCORE(heap, 0);
+        if (max && !CMP_LT(pop_score, max)) return Qnil;
+    } while (0);
 
-    return pop_val;
+    dheap_pop_swap_last_and_sift_down(heap, last_index);
+    return pop_value;
 }
 
 void
 Init_d_heap(void)
 {
     id_cmp = rb_intern_const("<=>");
-    id_ivar_a = rb_intern_const("ary");
-    id_ivar_d = rb_intern_const("d");
+    id_abs = rb_intern_const("abs");
 
     rb_cDHeap = rb_define_class("DHeap", rb_cObject);
+    rb_define_alloc_func(rb_cDHeap, dheap_s_alloc);
+
+    rb_define_const(rb_cDHeap, "MAX_D", INT2NUM(DHEAP_MAX_D));
+    rb_define_const(rb_cDHeap, "DEFAULT_D", INT2NUM(DHEAP_DEFAULT_D));
+
     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_method(rb_cDHeap, "initialize_copy", dheap_initialize_copy, 1);
+    rb_define_private_method(rb_cDHeap, "__init_clone__", dheap_init_clone, 2);
+    rb_define_method(rb_cDHeap, "freeze", dheap_freeze, 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, "d",       dheap_attr_d, 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, "clear",   dheap_clear, 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);
 }