d_heap 0.3.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,58 +1,190 @@
+#include <float.h>
 #include "d_heap.h"
 
+#define SCORE_AS_LONG_DOUBLE 1
+
 ID id_cmp; // <=>
-ID id_ivar_values;
-ID id_ivar_scores;
-ID id_ivar_d;
+ID id_abs; // abs
 
-#define Get_DHeap(hobj, hstruct) ((hstruct) = get_dheap_struct(hobj))
+#ifdef SCORE_AS_LONG_DOUBLE
+    #define SCORE long double
+#else
+    #define SCORE VALUE
+#endif
 
-#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)
+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_SIZE(heap) (RARRAY_LEN((heap)->scores))
 #define DHEAP_VALUE(heap, idx) RARRAY_AREF((heap)->values, idx)
-#define DHEAP_SCORE(heap, idx) RARRAY_AREF((heap)->scores, idx)
-#define DHEAP_ASSIGN(heap, idx, scr, val) \
-    rb_ary_store(heap->scores, idx, scr); \
-    rb_ary_store(heap->values, idx, val);
-#define DHEAP_APPEND(heap, scr, val) \
-    rb_ary_push((heap)->scores, scr); \
-    rb_ary_push((heap)->values, val);
-#define DHEAP_DROP_LAST(heap) ( \
-        rb_ary_pop(heap->scores), \
-        rb_ary_pop(heap->values) \
-    ) // score, value
+#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)
 
-#define DHEAP_Check_d_size(d) \
-    if (d < 2) { \
+// 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) { \
+    }                                                         \
+    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) \
-    if (index < 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) { \
+    }                                                                 \
+    else if (last_index < index) {                                    \
         rb_raise(rb_eIndexError, "DHeap index %ld too large", index); \
-    }
-
-struct dheap_struct {
-    int d;
-    VALUE scores;
-    VALUE values;
-};
-typedef struct dheap_struct dheap_t;
+    }                                                                 \
+} 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 );
 }
 
@@ -60,15 +192,36 @@ 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 = sizeof(*heap);
+    size_t size = 0;
+    size += sizeof(*heap);
+#ifdef SCORE_AS_LONG_DOUBLE
+    size += sizeof(long double) * heap->capa;
+#endif
     return size;
 }
 
@@ -76,7 +229,7 @@ static const rb_data_type_t dheap_data_type = {
     "DHeap",
     {
         (void (*)(void*))dheap_mark,
-        (void (*)(void*))RUBY_DEFAULT_FREE,
+        (void (*)(void*))dheap_free,
         (size_t (*)(const void *))dheap_memsize,
         dheap_compact_callback(dheap_compact),
     },
@@ -92,9 +245,16 @@ dheap_s_alloc(VALUE klass)
 
     obj = TypedData_Make_Struct(klass, dheap_t, &dheap_data_type, heap);
     heap->d = DHEAP_DEFAULT_D;
-    heap->scores = Qnil;
     heap->values = Qnil;
 
+#ifdef SCORE_AS_LONG_DOUBLE
+    heap->size = 0;
+    heap->capa = 0;
+    heap->cscores = NULL;
+#else
+    heap->scores = Qnil;
+#endif
+
     return obj;
 }
 
@@ -103,10 +263,62 @@ get_dheap_struct(VALUE self)
 {
     dheap_t *heap;
     TypedData_Get_Struct(self, dheap_t, &dheap_data_type, heap);
-    Check_Type(heap->scores, T_ARRAY);
+    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);
+    }
+
+    // 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.
@@ -115,107 +327,94 @@ get_dheap_struct(VALUE self)
  */
 static VALUE
 dheap_initialize(int argc, VALUE *argv, VALUE self) {
-    rb_check_arity(argc, 0, 1);
     dheap_t *heap;
+    int d;
+
+    rb_check_arity(argc, 0, 1);
     TypedData_Get_Struct(self, dheap_t, &dheap_data_type, heap);
 
-    int d = DHEAP_DEFAULT_D;
-    if (argc) {
-        d = NUM2INT(argv[0]);
-    }
+    d = argc ? NUM2INT(argv[0]) : DHEAP_DEFAULT_D;
     DHEAP_Check_d_size(d);
     heap->d = d;
 
-    heap->scores = rb_ary_new_capa(10000);
-    heap->values = rb_ary_new_capa(10000);
+    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;
 }
 
-/*
-static inline VALUE
-make_dheap_element(VALUE score, VALUE value)
+/* :nodoc: */
+static VALUE
+dheap_initialize_copy(VALUE copy, VALUE orig)
 {
-    elem_t *elem;
-    VALUE obj = TypedData_Make_Struct(
-            rb_cObject,
-            elem_t,
-            &dheap_elem_type,
-            elem);
-    elem->score = score;
-    elem->value = value;
-    return obj;
-}
+    dheap_t *heap_copy;
+    dheap_t *heap_orig = get_dheap_struct(orig);
 
-#define IsDHeapElem(value) rb_typeddata_is_kind_of((value), &dheap_elem_type)
-#define Get_DHeap_Elem(value) \
-    TypedData_Get_Struct((obj), elem_t, &dheap_elem_type, (elem))
+    rb_check_frozen(copy);
+    TypedData_Get_Struct(copy, dheap_t, &dheap_data_type, heap_copy);
 
-static inline elem_t *
-get_dheap_element(VALUE obj)
-{
-    elem_t *elem;
-    TypedData_Get_Struct((obj), elem_t, &dheap_elem_type, (elem));
-    return elem;
-}
+    heap_copy->d = heap_orig->d;
 
-*/
+    heap_copy->values = rb_ary_new();
+    rb_ary_replace(heap_copy->values, heap_orig->values);
 
-#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)
+#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
 
-/*
- * 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(VALUE a, VALUE 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);
+    return copy;
+}
 
-    // give up on an optimized version and just call (a <=> b)
-    return rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b);
+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(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);
 
-    VALUE sift_value = DHEAP_VALUE(heap, sift_index);
-    VALUE sift_score = DHEAP_SCORE(heap, sift_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_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);
-        VALUE parent_score = DHEAP_SCORE(heap, parent_index);
+        parent_score = DHEAP_SCORE(heap, parent_index);
 
         // parent is smaller: heap is restored
         if (CMP_LTE(parent_score, sift_score)) break;
 
         // parent is larger: swap and continue sifting up
-        VALUE 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);
+        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);
     }
     debug(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap->values, heap->d, sift_index));
     return LONG2NUM(sift_index);
@@ -223,29 +422,35 @@ dheap_ary_sift_up(dheap_t *heap, long sift_index) {
 
 VALUE
 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);
 
-    VALUE sift_value = DHEAP_VALUE(heap, sift_index);
-    VALUE sift_score = DHEAP_SCORE(heap, sift_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_index; sift_index < last_index; sift_index = child_index) {
-        debug(rb_sprintf("sift dn(%"PRIsVALUE", %d, %ld)", heap->values, heap->d, sift_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 = child_index = DHEAP_IDX_CHILD0(heap, sift_index);
+        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
-        long last_sibidx = child_idx0 + heap->d - 1;
+        last_sibidx = child_idx0 + heap->d - 1;
         if (last_index < last_sibidx) last_sibidx = last_index;
-        VALUE child_score = DHEAP_SCORE(heap, child_idx0);
+        child_score = DHEAP_SCORE(heap, child_idx0);
         child_index = child_idx0;
         for (long sibling_index = child_idx0 + 1;
                 sibling_index <= last_sibidx;
                 ++sibling_index) {
-            VALUE sibling_score = DHEAP_SCORE(heap, sibling_index);
+            SCORE sibling_score = DHEAP_SCORE(heap, sibling_index);
 
             if (CMP_LT(sibling_score, child_score)) {
                 child_score = sibling_score;
@@ -257,9 +462,9 @@ dheap_ary_sift_down(dheap_t *heap, long sift_index) {
         if (CMP_LTE(sift_score, child_score)) break;
 
         // child is smaller: swap and continue sifting down
-        VALUE 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);
+        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);
     }
     debug(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap->values, heap->d, sift_index));
     return LONG2NUM(sift_index);
@@ -307,11 +512,24 @@ static VALUE
 dheap_freeze(VALUE self) {
     dheap_t *heap = get_dheap_struct(self);
     ID id_freeze = rb_intern("freeze");
-    rb_funcall(heap->scores, id_freeze, 0);
     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;
+}
+
 /*
  * @overload push(score, value = score)
  *
@@ -329,14 +547,30 @@ dheap_freeze(VALUE self) {
  */
 static VALUE
 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 scr, val;
+    dheap_t *heap;
+    long last_index;
+    rb_check_frozen(self);
 
-    dheap_t *heap = get_dheap_struct(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);
 
-    DHEAP_APPEND(heap, scr, val);
-    long last_index = DHEAP_IDX_LAST(heap);
     return dheap_ary_sift_up(heap, last_index);
 }
 
@@ -356,14 +590,17 @@ dheap_left_shift(VALUE self, VALUE value) {
     return self;
 }
 
-/*
-    dheap_t hstruct; \
-    Get_DHeap(self, hstruct); \
-    VALUE values = hstruct.values; \
-    VALUE scores = hstruct.scores; \
-    VALUE dval = INT2FIX(hstruct.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)
 {
@@ -373,13 +610,41 @@ dheap_pop_swap_last_and_sift_down(dheap_t *heap, long last_index)
     else
     {
         VALUE sift_value = DHEAP_VALUE(heap, last_index);
-        VALUE sift_score = DHEAP_SCORE(heap, last_index);
-        DHEAP_ASSIGN(heap, 0, sift_score, sift_value);
+        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);
     }
 }
 
+#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
+
+/*
+ * 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_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.
  *
@@ -400,11 +665,13 @@ dheap_peek(VALUE self) {
  */
 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;
-    VALUE pop_value = DHEAP_VALUE(heap, 0);
+    pop_value = DHEAP_VALUE(heap, 0);
 
     dheap_pop_swap_last_and_sift_down(heap, last_index);
     return pop_value;
@@ -413,20 +680,25 @@ dheap_pop(VALUE self) {
 /*
  * Pops the minimum value only if it is less than or equal to a max score.
  *
- * @param max_score [#<=>] the maximum score to be popped
+ * @param max_score [#to_f] the maximum score to be popped
  *
  * @see #pop
  */
 static VALUE
 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;
-    VALUE pop_value = DHEAP_VALUE(heap, 0);
+    pop_value = DHEAP_VALUE(heap, 0);
 
-    VALUE pop_score = DHEAP_SCORE(heap, 0);
-    if (max_score && !CMP_LTE(pop_score, max_score)) return Qnil;
+    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;
@@ -435,20 +707,25 @@ dheap_pop_lte(VALUE self, VALUE max_score) {
 /*
  * Pops the minimum value only if it is less than a max score.
  *
- * @param max_score [#<=>] the maximum score to be popped
+ * @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_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);
 
     if (last_index <  0) return Qnil;
-    VALUE pop_value = DHEAP_VALUE(heap, 0);
+    pop_value = DHEAP_VALUE(heap, 0);
 
-    VALUE pop_score = DHEAP_SCORE(heap, 0);
-    if (max_score && !CMP_LT(pop_score, max_score)) return Qnil;
+    do {
+        SCORE max = VAL2SCORE(max_score);
+        SCORE pop_score = DHEAP_SCORE(heap, 0);
+        if (max && !CMP_LT(pop_score, max)) return Qnil;
+    } while (0);
 
     dheap_pop_swap_last_and_sift_down(heap, last_index);
     return pop_value;
@@ -458,9 +735,7 @@ void
 Init_d_heap(void)
 {
     id_cmp = rb_intern_const("<=>");
-    id_ivar_values = rb_intern_const("values");
-    id_ivar_scores = rb_intern_const("scores");
-    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);
@@ -469,13 +744,16 @@ Init_d_heap(void)
     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_attr_d, 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_method(rb_cDHeap, "size", dheap_size, 0);
-    rb_define_method(rb_cDHeap, "empty?", dheap_empty_p, 0);
-
+    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, "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);