d_heap 0.6.1 → 0.7.0

data/docs/profile.txt

@@ -1,29 +1,28 @@
-Profiling run at 2021-01-10 21:34:56 -0500
-ruby v2.7.2, DHeap v0.3.0
+Profiling run at 2021-02-01 00:43:34 -0500
+ruby v2.7.2, DHeap v0.6.1
 
 ~~~~~~ filling @dheap_bm_random_vals with 1.0M ~~~~~~
 ########################################################################
-# Profile w/ N=5 (i=1000000)
+# Profile w/ N=10 (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 ---------------------------
+Filling   ruby binary heap ---------------------------
+Profiling ruby binary heap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 2.639873
+Thread ID: 1400
+Fiber ID: 1380
+Total: 5.194751
 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                    
+ 41.50      2.156     2.156     0.000     0.000  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:107
+ 36.37      2.137     1.889     0.000     0.247  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:121
+ 14.92      5.195     0.775     0.000     4.420        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+  2.46      0.128     0.128     0.000     0.000  1000000   Array#fetch
+  2.41      0.125     0.125     0.000     0.000  1000000   Array#pop
+  2.35      0.122     0.122     0.000     0.000  1000000   Array#first
 
 * recursively called methods
 
@@ -43,22 +42,19 @@ 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 ---------------------------
+Filling   quaternary DHeap ---------------------------
+Profiling quaternary DHeap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 2.634233
+Thread ID: 1400
+Fiber ID: 1380
+Total: 1.103473
 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                      
+ 64.92      1.103     0.716     0.000     0.387        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 12.09      0.133     0.133     0.000     0.000  1000000   DHeap#<<
+ 11.82      0.130     0.130     0.000     0.000  1000000   DHeap#pop
+ 11.16      0.123     0.123     0.000     0.000  1000000   Array#fetch
 
 * recursively called methods
 
@@ -78,23 +74,27 @@ 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=100 (i=1000000)
+# (n.b. RubyProf & tracepoint can change relative performance.
+#       A sampling profiler can provide more accurate relative metrics.
+########################################################################
+
 Filling   ruby binary heap ---------------------------
 Profiling ruby binary heap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 4.940103
+Thread ID: 1400
+Fiber ID: 1380
+Total: 7.422039
 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                     
+ 47.72      3.542     3.542     0.000     0.000  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:107
+ 36.82      2.984     2.733     0.000     0.251  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:121
+ 10.39      7.422     0.771     0.000     6.651        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+  1.71      0.127     0.127     0.000     0.000  1000000   Array#pop
+  1.69      0.125     0.125     0.000     0.000  1000000   Array#fetch
+  1.67      0.124     0.124     0.000     0.000  1000000   Array#first
 
 * recursively called methods
 
@@ -117,16 +117,16 @@ The interpretation of method names is:
 Filling   quaternary DHeap ---------------------------
 Profiling quaternary DHeap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 1.231464
+Thread ID: 1400
+Fiber ID: 1380
+Total: 1.163539
 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                    
+ 64.38      1.164     0.749     0.000     0.414        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 12.52      0.146     0.146     0.000     0.000  1000000   DHeap#<<
+ 12.43      0.145     0.145     0.000     0.000  1000000   DHeap#pop
+ 10.67      0.124     0.124     0.000     0.000  1000000   Array#fetch
 
 * recursively called methods
 
@@ -147,23 +147,26 @@ The interpretation of method names is:
   * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
 
 ########################################################################
-# Profile w/ N=1365 (i=1000000)
+# Profile w/ N=1000 (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 ---------------------------
+Filling   ruby binary heap ---------------------------
+Profiling ruby binary heap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 41.950612
+Thread ID: 1400
+Fiber ID: 1380
+Total: 9.693127
 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
+ 52.28      5.068     5.068     0.000     0.000  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:107
+ 35.52      3.702     3.443     0.000     0.259  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:121
+  8.18      9.693     0.793     0.000     8.900        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+  1.36      0.131     0.131     0.000     0.000  1000000   Array#pop
+  1.35      0.131     0.131     0.000     0.000  1000000   Array#fetch
+  1.32      0.128     0.128     0.000     0.000  1000000   Array#first
 
 * recursively called methods
 
@@ -183,22 +186,19 @@ 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 ---------------------------
+Filling   quaternary DHeap ---------------------------
+Profiling quaternary DHeap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 3.559064
+Thread ID: 1400
+Fiber ID: 1380
+Total: 1.125575
 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                      
+ 64.22      1.126     0.723     0.000     0.403        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 13.16      0.148     0.148     0.000     0.000  1000000   DHeap#<<
+ 12.01      0.135     0.135     0.000     0.000  1000000   DHeap#pop
+ 10.62      0.119     0.119     0.000     0.000  1000000   Array#fetch
 
 * recursively called methods
 
@@ -218,23 +218,24 @@ 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=10000 (i=1000000)
+# (n.b. RubyProf & tracepoint can change relative performance.
+#       A sampling profiler can provide more accurate relative metrics.
+########################################################################
+
 Filling   ruby binary heap ---------------------------
 Profiling ruby binary heap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 11.581886
+Thread ID: 1400
+Fiber ID: 1380
+Total: 13.737007
 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                     
+ 49.46      6.794     6.794     0.000     0.000  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:107
+ 41.97      6.017     5.765     0.000     0.251  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:121
+  5.80     13.737     0.796     0.000    12.941        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
 
 * recursively called methods
 
@@ -257,16 +258,16 @@ The interpretation of method names is:
 Filling   quaternary DHeap ---------------------------
 Profiling quaternary DHeap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 1.431426
+Thread ID: 1400
+Fiber ID: 1380
+Total: 1.179968
 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                    
+ 62.48      1.180     0.737     0.000     0.443        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 13.86      0.164     0.164     0.000     0.000  1000000   DHeap#<<
+ 13.46      0.159     0.159     0.000     0.000  1000000   DHeap#pop
+ 10.20      0.120     0.120     0.000     0.000  1000000   Array#fetch
 
 * recursively called methods
 
@@ -287,58 +288,23 @@ The interpretation of method names is:
   * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
 
 ########################################################################
-# Profile w/ N=87381 (i=1000000)
+# Profile w/ N=100000 (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
+Thread ID: 1400
+Fiber ID: 1380
+Total: 16.425915
 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
+ 50.99      8.623     8.376     0.000     0.247  1000000   DHeap::Benchmarks::RbHeap#pop  /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:121
+ 41.82      6.869     6.869     0.000     0.000  1000000   DHeap::Benchmarks::RbHeap#<<   /home/nick/src/d_heap/lib/d_heap/benchmarks/implementations.rb:107
+  4.89     16.426     0.803     0.000    15.623        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
 
 * recursively called methods
 
@@ -361,16 +327,16 @@ The interpretation of method names is:
 Filling   quaternary DHeap ---------------------------
 Profiling quaternary DHeap ---------------------------
 Measure Mode: wall_time
-Thread ID: 1360
-Fiber ID: 1340
-Total: 1.622729
+Thread ID: 1400
+Fiber ID: 1380
+Total: 1.205573
 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                    
+ 59.14      1.206     0.713     0.000     0.493        1   DHeap::Benchmarks::Scenarios#repeated_push_pop /home/nick/src/d_heap/lib/d_heap/benchmarks.rb:81
+ 16.93      0.204     0.204     0.000     0.000  1000000   DHeap#pop
+ 13.88      0.167     0.167     0.000     0.000  1000000   DHeap#<<
+ 10.05      0.121     0.121     0.000     0.000  1000000   Array#fetch
 
 * recursively called methods
 

data/ext/d_heap/.rubocop.yml

@@ -0,0 +1,7 @@
+---
+inherit_from:
+  - "../../.rubocop.yml"
+
+Style/GlobalVars:
+  AllowedVariables:
+    - "$defs"

data/ext/d_heap/d_heap.c

@@ -1,165 +1,126 @@
+#include "ruby.h"
 #include <float.h>
 #include <math.h>
-#include "ruby.h"
 
-/********************************************************************
- *
- * Type definitions
- *
- ********************************************************************/
-
-typedef struct dheap_struct dheap_t;
-typedef struct dheap_entry ENTRY;
+#if CHAR_BIT != 8
+#    error "DHeap assumes 8-bit bytes"
+#endif
 
-// TODO: convert SCORE to a union, and use an ENTRY flag for its type
-typedef long double SCORE;
+#if SIZE_MAX != ULONG_MAX
+#    error "DHeap assumes 'size_t' is 'unsigned long'"
+#endif
 
 #if LDBL_MANT_DIG < SIZEOF_UNSIGNED_LONG_LONG * 8
-#error 'unsigned long long' must fit into 'long double' mantissa
+#    error "DHeap assumes 'long double' mantissa can store 'unsigned long long'"
 #endif
 
 // TODO: test this code on a 32 bit system (it MUST have some bugs!)
+// TODO: perhaps just convert from "unsigned long long" to "uint64_t"!
 #if SIZEOF_UNSIGNED_LONG_LONG * 8 != 64
-#error 'unsigned long long' must be 64bits
+#    error "DHeap assumes 64-bit 'unsigned long long'"
 #endif
 
+/********************************************************************
+ *
+ * Type definitions
+ *
+ ********************************************************************/
+
+typedef struct dheap_struct dheap_t;
+typedef struct dheap_entry  ENTRY;
+
+typedef double SCORE;
+
 /********************************************************************
  *
  * Struct definitions
  *
  ********************************************************************/
 
-struct dheap_struct {
-    int d;
-    long size;
-    long capa;
+struct dheap_struct
+{
+    int    d;
+    size_t size;
+    size_t capa;
     ENTRY *entries;
+#ifdef DHEAP_MAP
+    VALUE indexes; // Hash
+#endif
 };
 
-struct dheap_entry {
+struct dheap_entry
+{
     SCORE score;
     VALUE value;
 };
 
+#define DHEAPMAP_P(heap) UNLIKELY(RTEST((heap)->indexes))
+
 /********************************************************************
  *
  * Constant definitions
  *
  ********************************************************************/
 
-#define DHEAP_DEFAULT_D 4
-#define DHEAP_MAX_D INT_MAX
+#define DHEAP_DEFAULT_D 6
+#define DHEAP_MAX_D     INT_MAX
 
-// sizeof(ENTRY) => 32 bytes
+// sizeof(ENTRY) => 16 bytes, 128-bits
 // one kilobyte = 32 * 32 bytes
-#define DHEAP_DEFAULT_CAPA 32
-#define DHEAP_MAX_CAPA (LONG_MAX / (int)sizeof(ENTRY))
+#define DHEAP_DEFAULT_CAPA  32
+#define DHEAP_MAX_CAPA      (SIZE_MAX / (int)sizeof(ENTRY))
 #define DHEAP_CAPA_INCR_MAX (10 * 1024 * 1024 / (int)sizeof(ENTRY))
 
-static ID id_cmp; // <=>
-static ID id_abs; // abs
+static ID id_cmp;    // <=>
+static ID id_abs;    // abs
 static ID id_lshift; // <<
-static ID id_unary_minus; // -@
-static const ENTRY EmptyDheapEntry; // 0 value for safety overwrite after pop
+static ID id_uminus; // -@
+
 static const rb_data_type_t dheap_data_type;
 
 /********************************************************************
  *
- * SCORE: casting to and from VALUE
- *    adapted from similar methods in ruby's object.c
+ * Metaprogramming macros
  *
  ********************************************************************/
 
-// ruby doesn't have a LDBL2NUM. :(
-// So this only accomplishes a subset of what that ought to do.
-static inline VALUE
-SCORE2NUM(SCORE s)
-{
-    if (floorl((long double) s) == s) {
-        if (s < 0) {
-            unsigned long long ull = (unsigned long long)(-s);
-            return rb_funcall(ULL2NUM(ull), id_unary_minus, 0, Qundef);
-        }
-        return ULL2NUM((unsigned long long)(s));
-    }
-    return rb_float_new((double)(s));
-}
-
-static inline SCORE
-FIX2SCORE(VALUE x)
-{
-    return (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, Qundef);
-        ull  = rb_big2ull(x);
-        ldbl = (long double) ull;
-        return -ldbl;
-    }
-}
+#define LIKELY   RB_LIKELY
+#define UNLIKELY RB_UNLIKELY
 
-static inline SCORE
-INT2SCORE(VALUE x)
-{
-    return (FIXNUM_P(x) ? FIX2SCORE(x) : BIG2SCORE(x));
-}
+#ifdef DHEAP_MAP
+#    define DHEAP_DISPATCH_EXPR(func, heap, ...)                               \
+        (DHEAPMAP_P(heap) ? dheapmap_##func(heap, __VA_ARGS__)                 \
+                          : dheap_##func(heap, __VA_ARGS__))
+#else
+#    define DHEAP_DISPATCH_EXPR(func, heap, ...)                               \
+        dheap_##func(heap, __VA_ARGS__);
+#endif
 
-static inline SCORE
-NUM2SCORE(VALUE x)
-{
-    return (FIXNUM_P(x) ? FIX2SCORE(x) :
-            RB_TYPE_P(x, T_BIGNUM) ? BIG2SCORE(x) :
-            (Check_Type(x, T_FLOAT), (long double)RFLOAT_VALUE(x)));
-}
+#ifdef DHEAP_MAP
+#    define DHEAP_DISPATCH_STMT(heap, macro, ...)                              \
+        do {                                                                   \
+            if (DHEAPMAP_P(heap)) {                                            \
+                macro(dheapmap, heap, __VA_ARGS__);                            \
+            } else {                                                           \
+                macro(dheap, heap, __VA_ARGS__);                               \
+            }                                                                  \
+        } while (0)
+#else
+#    define DHEAP_DISPATCH_STMT(heap, macro, ...)                              \
+        macro(dheap, heap, __VA_ARGS__)
+#endif
 
-static inline long double
-RAT2SCORE(VALUE x)
-{
-    VALUE num = rb_rational_num(x);
-    VALUE den = rb_rational_den(x);
-    return NUM2SCORE(num) / NUM2SCORE(den);
-}
+/********************************************************************
+ *
+ * SCORE: casting to and from VALUE
+ *    adapted from similar methods in ruby's object.c
+ *
+ ********************************************************************/
 
-/*
- * 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 SCORE
-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)));
-    }
-}
+#define SCORE2NUM(score) rb_float_new(score)
+#define VAL2SCORE(val)   NUM2DBL(RB_FLOAT_TYPE_P(val) ? val : rb_Float(val))
+#define CMP_LT(a, b)     ((a) < (b))
+#define CMP_LTE(a, b)    ((a) <= (b))
 
 /********************************************************************
  *
@@ -167,17 +128,28 @@ VAL2SCORE(VALUE score)
  *
  ********************************************************************/
 
-#define DHEAP_SCORE(heap, idx) ((heap)->entries[idx].score)
-#define DHEAP_VALUE(heap, idx) ((heap)->entries[idx].value)
+#define DHEAP_SCORE(heap, idx) (DHEAP_GET(heap, idx).score)
+#define DHEAP_VALUE(heap, idx) (DHEAP_GET(heap, idx).value)
 
-static inline VALUE
-DHEAP_ENTRY_ARY(dheap_t *heap, long idx)
-{
-    if (idx < 0 || heap->size <= idx) { return Qnil; }
-    return rb_ary_new_from_args(2,
-            DHEAP_VALUE(heap, 0),
-            SCORE2NUM(DHEAP_SCORE(heap, 0)));
-}
+#define DHEAP_ENTRY_ARY(heap, idx)                                             \
+    (((heap)->size <= (idx))                                                   \
+       ? Qnil                                                                  \
+       : rb_ary_new_from_args(                                                 \
+           2, DHEAP_VALUE(heap, idx), SCORE2NUM(DHEAP_SCORE(heap, idx))))
+
+#define DHEAP_GET(heap, idx) ((heap)->entries[idx])
+#define DHEAP_SET(T, heap, index, entry)                                       \
+    do {                                                                       \
+        DHEAP_GET(heap, index) = (entry);                                      \
+        DHEAP_SET_##T(heap, index, entry);                                     \
+    } while (0)
+
+#define DHEAP_SET_dheap(heap, index, entry) /* noop */
+
+#ifdef DHEAP_MAP
+#    define DHEAP_SET_dheapmap(heap, index, entry)                             \
+        rb_hash_aset((heap)->indexes, (entry).value, ULONG2NUM(index))
+#endif
 
 /********************************************************************
  *
@@ -185,22 +157,20 @@ DHEAP_ENTRY_ARY(dheap_t *heap, long idx)
  *
  ********************************************************************/
 
-#define DHEAP_IDX_LAST(heap) ((heap)->size - 1)
-#define DHEAP_IDX_PARENT(heap, idx) (((idx) - 1) / (heap)->d)
+#define DHEAP_IDX_LAST(heap)         ((heap)->size - 1)
+#define DHEAP_IDX_PARENT(heap, idx)  (((idx)-1) / (heap)->d)
 #define DHEAP_IDX_CHILD_0(heap, idx) (((idx) * (heap)->d) + 1)
 #define DHEAP_IDX_CHILD_D(heap, idx) (((idx) * (heap)->d) + (heap)->d)
 
-#ifdef __D_HEAP_DEBUG
-#define ASSERT_DHEAP_IDX_OK(heap, index) do {                          \
-    if (index < 0) {                                                  \
-        rb_raise(rb_eIndexError, "DHeap index %ld too small", index); \
-    }                                                                 \
-    else if (DHEAP_IDX_LAST(heap) < index) {                          \
-        rb_raise(rb_eIndexError, "DHeap index %ld too large", index); \
-    }                                                                 \
-} while (0)
+#ifdef DEBUG
+#    define ASSERT_DHEAP_IDX_OK(heap, index)                                   \
+        do {                                                                   \
+            if (DHEAP_IDX_LAST(heap) < index) {                                \
+                rb_raise(rb_eIndexError, "DHeap index %ld too large", index);  \
+            }                                                                  \
+        } while (0)
 #else
-#define ASSERT_DHEAP_IDX_OK(heap, index)
+#    define ASSERT_DHEAP_IDX_OK(heap, index)
 #endif
 
 /********************************************************************
@@ -214,113 +184,79 @@ static void
 dheap_compact(void *ptr)
 {
     dheap_t *heap = ptr;
-    for (long i = 0; i < heap->size; ++i) {
+    for (size_t i = 0; i < heap->size; ++i) {
         if (DHEAP_VALUE(heap, i))
-            rb_gc_location(DHEAP_VALUE(heap, i));
+            DHEAP_VALUE(heap, i) = rb_gc_location(DHEAP_VALUE(heap, i));
     }
+#    ifdef DHEAP_MAP
+    if (DHEAPMAP_P(heap)) heap->indexes = rb_gc_location(heap->indexes);
+#    endif
 }
 #else
-#define rb_gc_mark_movable(x) rb_gc_mark(x)
+#    define rb_gc_mark_movable(x) rb_gc_mark(x)
 #endif
 
 static void
 dheap_mark(void *ptr)
 {
     dheap_t *heap = ptr;
-    for (long i = 0; i < heap->size; ++i) {
-        if (DHEAP_VALUE(heap, i))
-            rb_gc_mark_movable(DHEAP_VALUE(heap,i));
+    for (size_t i = 0; i < heap->size; ++i) {
+        if (DHEAP_VALUE(heap, i)) rb_gc_mark_movable(DHEAP_VALUE(heap, i));
     }
+#ifdef DHEAP_MAP
+    if (DHEAPMAP_P(heap)) rb_gc_mark_movable(heap->indexes);
+#endif
 }
 
 static void
 dheap_free(void *ptr)
 {
     dheap_t *heap = ptr;
-    heap->size = 0;
+    heap->size    = 0;
     if (heap->entries) {
         xfree(heap->entries);
         heap->entries = NULL;
     }
     heap->capa = 0;
     xfree(ptr);
+#ifdef DHEAP_MAP
+    heap->indexes = Qnil;
+#endif
 }
 
 static size_t
 dheap_memsize(const void *ptr)
 {
     const dheap_t *heap = ptr;
-    size_t size = 0;
+    size_t         size = 0;
     size += sizeof(*heap);
     size += sizeof(ENTRY) * heap->capa;
     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,
+    { (void (*)(void *))dheap_mark,
+      (void (*)(void *))dheap_free,
+      (size_t(*)(const void *))dheap_memsize,
 #ifdef HAVE_RB_GC_MARK_MOVABLE
-        (void (*)(void*))dheap_compact, {0}
+      (void (*)(void *))dheap_compact,
+      { 0 }
 #else
-        {0}
+      { 0 }
 #endif
     },
-    0, 0,
+    0,
+    0,
     RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 /********************************************************************
  *
  * DHeap comparisons
- * TODO: bring back comparisons for score types other than `long double`.
  *
  ********************************************************************/
 
-#define CMP_LT(a, b)  ((a) <  (b))
-#define CMP_LTE(a, b) ((a) <= (b))
-
-/* #ifdef ORIG_SCORE_CMP_CODE */
-
-/* #define CMP_LT(a, b)  (optimized_cmp(a, b) <  0) */
-/* #define CMP_LTE(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 */
-
 /********************************************************************
  *
  * DHeap allocation and initialization and resizing
@@ -330,19 +266,21 @@ static const rb_data_type_t dheap_data_type = {
 static VALUE
 dheap_s_alloc(VALUE klass)
 {
-    VALUE obj;
+    VALUE    obj;
     dheap_t *heap;
 
-// TypedData_Make_Struct uses a non-std "statement expression"
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpedantic"
+    // TypedData_Make_Struct uses a non-std "statement expression"
     obj = TypedData_Make_Struct(klass, dheap_t, &dheap_data_type, heap);
 #pragma GCC diagnostic pop
-    heap->d = DHEAP_DEFAULT_D;
-
-    heap->size = 0;
-    heap->capa = 0;
+    heap->d       = DHEAP_DEFAULT_D;
+    heap->size    = 0;
+    heap->capa    = 0;
     heap->entries = NULL;
+#ifdef DHEAP_MAP
+    heap->indexes = Qnil;
+#endif
 
     return obj;
 }
@@ -355,8 +293,15 @@ get_dheap_struct(VALUE self)
     return heap;
 }
 
+static inline dheap_t *
+get_dheap_struct_unfrozen(VALUE self)
+{
+    rb_check_frozen(self);
+    return get_dheap_struct(self);
+}
+
 void
-dheap_set_capa(dheap_t *heap, long new_capa)
+dheap_set_capa(dheap_t *heap, size_t new_capa)
 {
     // Do nothing if we already have the capacity or are resizing too small
     if (new_capa <= heap->capa || new_capa <= heap->size) return;
@@ -371,27 +316,36 @@ dheap_set_capa(dheap_t *heap, long new_capa)
 }
 
 static void
-dheap_ensure_room_for_push(dheap_t *heap, long incr_by)
+dheap_incr_capa(dheap_t *heap, size_t new_size)
 {
-    long new_size = heap->size + incr_by;
+    size_t new_capa = heap->capa;
+    while (new_capa < new_size) {
+        if (new_capa <= DHEAP_CAPA_INCR_MAX) {
+            // double it... up to DHEAP_CAPA_INCR_MAX
+            new_capa *= 2;
+        } else if (DHEAP_MAX_CAPA - DHEAP_CAPA_INCR_MAX < heap->capa) {
+            // avoid overflow
+            new_capa = DHEAP_MAX_CAPA;
+        } else {
+            new_capa += DHEAP_CAPA_INCR_MAX;
+        }
+    }
+    dheap_set_capa(heap, new_capa);
+}
 
+static void
+dheap_ensure_room_for_push(dheap_t *heap, size_t incr_by)
+{
     // check for overflow of new_size
-    if (DHEAP_MAX_CAPA - 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_CAPA / 2 < new_size) new_capa = DHEAP_MAX_CAPA;
-        // 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);
+    if (DHEAP_MAX_CAPA - incr_by < heap->size) {
+        rb_raise(rb_eIndexError,
+                 "size increase overflow: %zu + %zu",
+                 heap->size,
+                 incr_by);
+    } else {
+        size_t new_size = heap->size + incr_by;
+        // if existing capacity is too small
+        if (heap->capa < new_size) dheap_incr_capa(heap, new_size);
     }
 }
 
@@ -399,34 +353,34 @@ static inline int
 dheap_value_to_int_d(VALUE num)
 {
     int d = NUM2INT(num);
-    if (d < 2) {
-        rb_raise(rb_eArgError, "DHeap d=%u is too small", d);
-    }
-    if (d > DHEAP_MAX_D) {
-        rb_raise(rb_eArgError, "DHeap d=%u is too large", d);
-    }
+    if (d < 2) rb_raise(rb_eArgError, "DHeap d=%u is too small", d);
+    if (d > DHEAP_MAX_D) rb_raise(rb_eArgError, "DHeap d=%u is too large", d);
     return d;
 }
 
-static inline long
-dheap_value_to_long_capa(VALUE num)
+static inline size_t
+dheap_value_to_capa(VALUE num)
 {
-    long capa = NUM2LONG(num);
+    size_t capa = NUM2ULONG(num);
     if (capa < 1) {
-        rb_raise(rb_eArgError, "DHeap capa=%lu must be positive", capa);
+        rb_raise(rb_eArgError, "DHeap capa=%zu must be positive", capa);
     }
     return capa;
 }
 
 static VALUE
-dheap_initialize(VALUE self, VALUE d, VALUE capa) {
+dheap_init(VALUE self, VALUE d, VALUE capa, VALUE map)
+{
     dheap_t *heap = get_dheap_struct(self);
 
-    if(heap->entries || heap->size || heap->capa)
+    if (heap->entries || heap->size || heap->capa)
         rb_raise(rb_eScriptError, "DHeap already initialized.");
 
     heap->d = dheap_value_to_int_d(d);
-    dheap_set_capa(heap, dheap_value_to_long_capa(capa));
+    dheap_set_capa(heap, dheap_value_to_capa(capa));
+#ifdef DHEAP_MAP
+    if (RTEST(map)) heap->indexes = rb_hash_new();
+#endif
 
     return self;
 }
@@ -435,18 +389,19 @@ dheap_initialize(VALUE self, VALUE d, VALUE capa) {
 static VALUE
 dheap_initialize_copy(VALUE copy, VALUE orig)
 {
-    dheap_t *heap_copy;
+    dheap_t *heap_copy = get_dheap_struct_unfrozen(copy);
     dheap_t *heap_orig = get_dheap_struct(orig);
 
-    rb_check_frozen(copy);
-    TypedData_Get_Struct(copy, dheap_t, &dheap_data_type, heap_copy);
-
     heap_copy->d = heap_orig->d;
 
     dheap_set_capa(heap_copy, heap_orig->capa);
     heap_copy->size = heap_orig->size;
     if (heap_copy->size)
         MEMCPY(heap_copy->entries, heap_orig->entries, ENTRY, heap_orig->size);
+#ifdef DHEAP_MAP
+    if (RTEST(heap_orig->indexes))
+        heap_copy->indexes = rb_hash_dup(heap_orig->indexes);
+#endif
 
     return copy;
 }
@@ -457,75 +412,54 @@ dheap_initialize_copy(VALUE copy, VALUE orig)
  *
  ********************************************************************/
 
-VALUE
-dheap_sift_up(dheap_t *heap, long index) {
-    ENTRY entry = heap->entries[index];
-
-    ASSERT_DHEAP_IDX_OK(heap, index);
-
-    // sift it up to where it belongs
-    for (long parent_index; 0 < index; index = parent_index) {
-        /* debug(rb_sprintf("sift up(%"PRIsVALUE", %d, %ld)", heap->values, heap->d, index)); */
-        parent_index = DHEAP_IDX_PARENT(heap, index);
-
-        // parent is smaller: heap is restored
-        if (CMP_LTE(DHEAP_SCORE(heap, parent_index), entry.score)) break;
-
-        // parent is larger: swap and continue sifting up
-        heap->entries[index] = heap->entries[parent_index];
-    }
-    heap->entries[index] = entry;
-    /* debug(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap->values, heap->d, index)); */
-    return LONG2NUM(index);
-}
+#define DHEAP_SIFT_UP(T, heap, i)                                              \
+    do {                                                                       \
+        size_t sift_idx = i;                                                   \
+        ENTRY  entry    = DHEAP_GET(heap, sift_idx);                           \
+        ASSERT_DHEAP_IDX_OK(heap, sift_idx);                                   \
+        for (size_t parent_idx; 0 < sift_idx; sift_idx = parent_idx) {         \
+            parent_idx = DHEAP_IDX_PARENT(heap, sift_idx);                     \
+            if (CMP_LTE(DHEAP_SCORE((heap), parent_idx), entry.score)) break;  \
+            DHEAP_SET(T, heap, sift_idx, DHEAP_GET(heap, parent_idx));         \
+        }                                                                      \
+        DHEAP_SET(T, heap, sift_idx, entry);                                   \
+    } while (0)
+
+static inline size_t
+dheap_min_child(dheap_t *heap, size_t parent, size_t last_index)
+{
+    size_t min_child = DHEAP_IDX_CHILD_0(heap, parent);
+    size_t last_sib  = DHEAP_IDX_CHILD_D(heap, parent);
+    if (UNLIKELY(last_index < last_sib)) last_sib = last_index;
 
-/*
- * this is a tiny bit more complicated than the binary heap version
- */
-static inline long
-dheap_find_min_child(dheap_t *heap, long parent, long last_index) {
-    long min_child = DHEAP_IDX_CHILD_0(heap, parent);
-    long last_sib  = DHEAP_IDX_CHILD_D(heap, parent);
-    if (last_index < last_sib) last_sib = last_index;
-
-    for (long sibidx = min_child + 1; sibidx <= last_sib; ++sibidx) {
-        if (CMP_LT(DHEAP_SCORE(heap, sibidx),
-                    DHEAP_SCORE(heap, min_child))) {
+    for (size_t sibidx = min_child + 1; sibidx <= last_sib; ++sibidx) {
+        if (CMP_LT(DHEAP_SCORE(heap, sibidx), DHEAP_SCORE(heap, min_child))) {
             min_child = sibidx;
         }
     }
     return min_child;
 }
 
-void
-dheap_sift_down(dheap_t *heap, long index, long last_index) {
-    if (last_index < 1 || DHEAP_IDX_PARENT(heap, last_index) < index) {
-        // short-circuit: no chance for a child
-        return;
-
-    } else {
-        ENTRY entry = heap->entries[index];
-
-        long last_parent = DHEAP_IDX_PARENT(heap, last_index);
-
-        ASSERT_DHEAP_IDX_OK(heap, index);
-
-        // iteratively sift it down to where it belongs
-        while (index <= last_parent) {
-            // find min child
-            long min_child = dheap_find_min_child(heap, index, last_index);
-
-            // child is larger: heap is restored
-            if (CMP_LTE(entry.score, DHEAP_SCORE(heap, min_child))) break;
-
-            // child is smaller: swap and continue sifting down
-            heap->entries[index] = heap->entries[min_child];
-            index = min_child;
-        }
-        heap->entries[index] = entry;
-        // debug(rb_sprintf("sifted (%"PRIsVALUE", %d, %ld)", heap->values, heap->d, index));
-    }
-}
+#define DHEAP_CAN_SIFT_DOWN(heap, index, last_index)                           \
+    (LIKELY(1 <= last_index && index <= DHEAP_IDX_PARENT(heap, last_index)))
+
+#define DHEAP_SIFT_DOWN(T, heap, i)                                            \
+    do {                                                                       \
+        size_t sift_idx = i;                                                   \
+        size_t last_idx = DHEAP_IDX_LAST(heap);                                \
+        ASSERT_DHEAP_IDX_OK(heap, sift_idx);                                   \
+        if (DHEAP_CAN_SIFT_DOWN(heap, sift_idx, last_idx)) {                   \
+            ENTRY  entry       = heap->entries[sift_idx];                      \
+            size_t last_parent = DHEAP_IDX_PARENT(heap, last_idx);             \
+            while (sift_idx <= last_parent) {                                  \
+                size_t min_child = dheap_min_child(heap, sift_idx, last_idx);  \
+                if (CMP_LTE(entry.score, DHEAP_SCORE(heap, min_child))) break; \
+                DHEAP_SET(T, heap, sift_idx, (heap)->entries[min_child]);      \
+                sift_idx = min_child;                                          \
+            }                                                                  \
+            DHEAP_SET(T, heap, sift_idx, entry);                               \
+        }                                                                      \
+    } while (0)
 
 /********************************************************************
  *
@@ -540,9 +474,11 @@ static VALUE
 dheap_size(VALUE self)
 {
     dheap_t *heap = get_dheap_struct(self);
-    return LONG2NUM(heap->size);
+    return ULONG2NUM(heap->size);
 }
 
+#define DHEAP_EMPTY_P(heap) UNLIKELY((heap)->size <= 0)
+
 /*
  * @return [Boolean] if the heap is empty
  */
@@ -550,7 +486,7 @@ static VALUE
 dheap_empty_p(VALUE self)
 {
     dheap_t *heap = get_dheap_struct(self);
-    return heap->size ? Qfalse : Qtrue;
+    return DHEAP_EMPTY_P(heap) ? Qtrue : Qfalse;
 }
 
 /*
@@ -569,13 +505,47 @@ dheap_attr_d(VALUE self)
  *
  ********************************************************************/
 
+#define DHEAP_PUSH(T, heap, entry)                                             \
+    do {                                                                       \
+        dheap_ensure_room_for_push(heap, 1);                                   \
+        DHEAP_SET(T, heap, (heap)->size, *(entry));                            \
+        ++heap->size;                                                          \
+        DHEAP_SIFT_UP(T, heap, DHEAP_IDX_LAST(heap));                          \
+    } while (0)
+
 static inline void
-dheap_push_entry(dheap_t *heap, ENTRY *entry) {
-    dheap_ensure_room_for_push(heap, 1);
-    heap->entries[heap->size] = *entry;
-    ++heap->size;
-    dheap_sift_up(heap, heap->size - 1);
+dheap_push_entry(VALUE self, ENTRY *entry)
+{
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    DHEAP_PUSH(dheap, heap, entry);
+}
+
+#ifdef DHEAP_MAP
+static inline void
+dheapmap_update_entry(dheap_t *heap, size_t index, ENTRY *entry)
+{
+    SCORE prev = DHEAP_SCORE(heap, index);
+    DHEAP_SET(dheapmap, heap, index, *entry);
+    if (CMP_LT(prev, entry->score)) {
+        DHEAP_SIFT_DOWN(dheapmap, heap, index);
+    } else {
+        DHEAP_SIFT_UP(dheapmap, heap, index);
+    }
+}
+
+static inline void
+dheapmap_push_entry(VALUE self, ENTRY *entry)
+{
+    dheap_t *heap   = get_dheap_struct_unfrozen(self);
+    VALUE    idxval = rb_hash_lookup2(heap->indexes, entry->value, Qfalse);
+    if (idxval) {
+        size_t index = NUM2ULONG(idxval);
+        dheapmap_update_entry(heap, index, entry);
+        return;
+    }
+    DHEAP_PUSH(dheapmap, heap, entry);
 }
+#endif
 
 /*
  * Inserts a value into the heap, using a score to determine sort-order.
@@ -590,26 +560,42 @@ dheap_push_entry(dheap_t *heap, ENTRY *entry) {
  * @return [self]
  */
 static VALUE
-dheap_insert(VALUE self, VALUE score, VALUE value) {
-    ENTRY entry;
-    dheap_t *heap = get_dheap_struct(self);
-    rb_check_frozen(self);
-
-    entry.score = VAL2SCORE(score);
-    entry.value = value;
-    dheap_push_entry(heap, &entry);
+dheap_insert(VALUE self, VALUE score, VALUE value)
+{
+    ENTRY entry = { VAL2SCORE(score), value };
+    dheap_push_entry(self, &entry);
+    return self;
+}
 
+#ifdef DHEAP_MAP
+/* (see DHeap#insert) */
+static VALUE
+dheapmap_insert(VALUE self, VALUE score, VALUE value)
+{
+    ENTRY entry = { VAL2SCORE(score), value };
+    dheapmap_push_entry(self, &entry);
     return self;
 }
+#endif
+
+static inline ENTRY
+dheap_push_args_to_entry(int argc, VALUE *argv)
+{
+    ENTRY entry;
+    rb_check_arity(argc, 1, 2);
+    entry.value = argv[0];
+    entry.score = VAL2SCORE(argc < 2 ? entry.value : argv[1]);
+    return entry;
+}
 
 /*
  * @overload push(value, score = value)
  *
  * Push a value onto heap, using a score to determine sort-order.
  *
- * Value comes first because the separate score is optional, and because it feels
- * like a more natural variation on +Array#push+ or +Queue#enq+.  If a score
- * isn't provided, the value must be an Integer or can be cast with
+ * Value comes first because the separate score is optional, and because it
+ * feels like a more natural variation on +Array#push+ or +Queue#enq+.  If a
+ * score isn't provided, the value must be an Integer or can be cast with
  * +Float(value)+.
  *
  * Time complexity: <b>O(log n / log d)</b> <i>(worst-case)</i>
@@ -620,18 +606,23 @@ dheap_insert(VALUE self, VALUE score, VALUE value) {
  * @return [self]
  */
 static VALUE
-dheap_push(int argc, VALUE *argv, VALUE self) {
-    dheap_t *heap = get_dheap_struct(self);
-    ENTRY entry;
-    rb_check_frozen(self);
-
-    rb_check_arity(argc, 1, 2);
-    entry.value = argv[0];
-    entry.score = VAL2SCORE(argc < 2 ? entry.value : argv[1]);
-    dheap_push_entry(heap, &entry);
+dheap_push(int argc, VALUE *argv, VALUE self)
+{
+    ENTRY entry = dheap_push_args_to_entry(argc, argv);
+    dheap_push_entry(self, &entry);
+    return self;
+}
 
+#ifdef DHEAP_MAP
+/* (see DHeap#push) */
+static VALUE
+dheapmap_push(int argc, VALUE *argv, VALUE self)
+{
+    ENTRY entry = dheap_push_args_to_entry(argc, argv);
+    dheapmap_push_entry(self, &entry);
     return self;
 }
+#endif
 
 /*
  * Pushes a value onto the heap.
@@ -645,17 +636,23 @@ dheap_push(int argc, VALUE *argv, VALUE self) {
  * @return [self]
  */
 static VALUE
-dheap_left_shift(VALUE self, VALUE value) {
-    dheap_t *heap = get_dheap_struct(self);
-    ENTRY entry;
-    rb_check_frozen(self);
-
-    entry.score = VAL2SCORE(value);
-    entry.value = value;
-    dheap_push_entry(heap, &entry);
+dheap_lshift(VALUE self, VALUE value)
+{
+    ENTRY entry = { VAL2SCORE(value), value };
+    dheap_push_entry(self, &entry);
+    return self;
+}
 
+#ifdef DHEAP_MAP
+/* (see DHeap#<<) */
+static VALUE
+dheapmap_lshift(VALUE self, VALUE value)
+{
+    ENTRY entry = { VAL2SCORE(value), value };
+    dheapmap_push_entry(self, &entry);
     return self;
 }
+#endif
 
 /********************************************************************
  *
@@ -663,23 +660,15 @@ dheap_left_shift(VALUE self, VALUE value) {
  *
  ********************************************************************/
 
-static inline void
-dheap_del0(dheap_t *heap)
-{
-    if (0 < --heap->size) {
-        heap->entries[0] = heap->entries[heap->size];
-        heap->entries[heap->size] = EmptyDheapEntry; // unnecessary to zero?
-        dheap_sift_down(heap, 0, heap->size - 1);
-    }
-}
-
-static inline VALUE
-dheap_pop0(dheap_t *heap)
-{
-    VALUE popped = DHEAP_VALUE(heap, 0);
-    dheap_del0(heap);
-    return popped;
-}
+#define PEEK_VALUE(heap)            DHEAP_VALUE(heap, 0)
+#define PEEK_SCORE(heap)            DHEAP_SCORE(heap, 0)
+#define PEEK_WITH_SCORE(heap)       DHEAP_ENTRY_ARY(heap, 0)
+#define PEEK_LT_P(heap, max_score)  _PEEK_CMP_P(heap, CMP_LT, max_score)
+#define PEEK_LTE_P(heap, max_score) _PEEK_CMP_P(heap, CMP_LTE, max_score)
+#define _PEEK_CMP_P(heap, cmp, score)                                          \
+    ((!DHEAP_EMPTY_P(heap) && cmp(PEEK_SCORE(heap), (score)))                  \
+       ? PEEK_VALUE(heap)                                                      \
+       : 0)
 
 /*
  * Returns the next value on the heap, and its score, without popping it
@@ -694,11 +683,12 @@ static VALUE
 dheap_peek_with_score(VALUE self)
 {
     dheap_t *heap = get_dheap_struct(self);
-    return DHEAP_ENTRY_ARY(heap, 0);
+    return PEEK_WITH_SCORE(heap);
 }
 
 /*
- * Returns the next score on the heap, without the value and without popping it.
+ * Returns the next score on the heap, without the value and without popping
+ * it.
  *
  * Time complexity: <b>O(1)</b> <i>(worst-case)</i>
  * @return [nil, Numeric] the next score, if there is one
@@ -710,8 +700,8 @@ static VALUE
 dheap_peek_score(VALUE self)
 {
     dheap_t *heap = get_dheap_struct(self);
-    if (DHEAP_IDX_LAST(heap) < 0) return Qnil;
-    return SCORE2NUM(DHEAP_SCORE(heap, 0));
+    if (DHEAP_EMPTY_P(heap)) return Qnil;
+    return SCORE2NUM(PEEK_SCORE(heap));
 }
 
 /*
@@ -727,9 +717,52 @@ static VALUE
 dheap_peek(VALUE self)
 {
     dheap_t *heap = get_dheap_struct(self);
-    return heap->size ? DHEAP_VALUE(heap, 0) : Qnil;
+    if (DHEAP_EMPTY_P(heap)) return Qnil;
+    return PEEK_VALUE(heap);
 }
 
+#define DHEAP_POP_COMMON_INIT(self)                                            \
+    dheap_t *heap = get_dheap_struct_unfrozen(self);                           \
+    if (DHEAP_EMPTY_P(heap)) return Qnil;
+
+#define DHEAP_DELETE_0(T, heap)                                                \
+    do {                                                                       \
+        _DELETE_ENTRY(T, heap, 0);                                             \
+        if (0 < --(heap)->size) {                                              \
+            DHEAP_SET(T, (heap), 0, (heap)->entries[(heap)->size]);            \
+            DHEAP_SIFT_DOWN(T, (heap), 0);                                     \
+        }                                                                      \
+    } while (0)
+
+#define _DELETE_ENTRY(T, heap, idx)    _DELETE_ENTRY_##T(heap, idx)
+#define _DELETE_ENTRY_dheap(heap, idx) /* noop */
+#define _DELETE_ENTRY_dheapmap(heap, idx)                                      \
+    rb_hash_delete(heap->indexes, DHEAP_VALUE(heap, idx))
+
+#define POP(T, heap, popped)            _POP(T, VALUE, heap, popped)
+#define POP_WITH_SCORE(T, heap, popped) _POP(T, WITH_SCORE, heap, popped)
+#define POP_LT(T, heap, max, popped)    _POP_CMP(T, heap, LT, max, popped)
+#define POP_LTE(T, heap, max, popped)   _POP_CMP(T, heap, LTE, max, popped)
+
+#define _POP_CMP(T, heap, cmp, cmp_score, popped)                              \
+    do {                                                                       \
+        if ((*(popped) = PEEK_##cmp##_P(heap, cmp_score))) {                   \
+            DHEAP_DELETE_0(T, heap);                                           \
+        } else {                                                               \
+            *(popped) = Qnil;                                                  \
+        }                                                                      \
+    } while (0)
+
+#define _POP(T, peek_type, heap, popped)                                       \
+    do {                                                                       \
+        if (DHEAP_EMPTY_P(heap)) {                                             \
+            *(popped) = Qnil;                                                  \
+        } else {                                                               \
+            *(popped) = PEEK_##peek_type(heap);                                \
+            DHEAP_DELETE_0(T, heap);                                           \
+        }                                                                      \
+    } while (0)
+
 /*
  * Pops the minimum value from the top of the heap
  *
@@ -745,10 +778,23 @@ dheap_peek(VALUE self)
 static VALUE
 dheap_pop(VALUE self)
 {
-    dheap_t *heap = get_dheap_struct(self);
-    rb_check_frozen(self);
-    return heap->size ? dheap_pop0(heap) : Qnil;
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP(dheap, heap, &popped);
+    return popped;
+}
+
+#ifdef DHEAP_MAP
+/* (see DHeap#pop) */
+static VALUE
+dheapmap_pop(VALUE self)
+{
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP(dheapmap, heap, &popped);
+    return popped;
 }
+#endif
 
 /*
  * Pops the minimum value from the top of the heap, along with its score.
@@ -763,13 +809,27 @@ dheap_pop(VALUE self)
 static VALUE
 dheap_pop_with_score(VALUE self)
 {
-    dheap_t *heap = get_dheap_struct(self);
-    VALUE ary = DHEAP_ENTRY_ARY(heap, 0);
-    rb_check_frozen(self);
-    if (ary != Qnil) { dheap_pop0(heap); }
-    return ary;
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP_WITH_SCORE(dheap, heap, &popped);
+    return popped;
 }
 
+#ifdef DHEAP_MAP
+/* (see DHeap#pop_with_score) */
+static VALUE
+dheapmap_pop_with_score(VALUE self)
+{
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP_WITH_SCORE(dheapmap, heap, &popped);
+    return popped;
+}
+#endif
+
+#define DHEAP_POP_IF(heap, cmp, max_score)                                     \
+    if (!cmp(PEEK_SCORE(heap), VAL2SCORE(max_score))) return Qnil
+
 /*
  * Pops the minimum value only if it is less than or equal to a max score.
  *
@@ -787,13 +847,24 @@ dheap_pop_with_score(VALUE self)
 static VALUE
 dheap_pop_lte(VALUE self, VALUE max_score)
 {
-    dheap_t *heap = get_dheap_struct(self);
-    rb_check_frozen(self);
-    if (heap->size <= 0) return Qnil;
-    if (!CMP_LTE(DHEAP_SCORE(heap, 0), VAL2SCORE(max_score))) return Qnil;
-    return dheap_pop0(heap);
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP_LTE(dheap, heap, VAL2SCORE(max_score), &popped);
+    return popped;
 }
 
+#ifdef DHEAP_MAP
+/* (see DHeap#pop_lte) */
+static VALUE
+dheapmap_pop_lte(VALUE self, VALUE max_score)
+{
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP_LTE(dheapmap, heap, VAL2SCORE(max_score), &popped);
+    return popped;
+}
+#endif
+
 /*
  * Pops the minimum value only if it is less than a max score.
  *
@@ -811,31 +882,39 @@ dheap_pop_lte(VALUE self, VALUE max_score)
 static VALUE
 dheap_pop_lt(VALUE self, VALUE max_score)
 {
-    dheap_t *heap = get_dheap_struct(self);
-    rb_check_frozen(self);
-    if (heap->size <= 0) return Qnil;
-    if (!CMP_LT(DHEAP_SCORE(heap, 0), VAL2SCORE(max_score))) return Qnil;
-    return dheap_pop0(heap);
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP_LT(dheap, heap, VAL2SCORE(max_score), &popped);
+    return popped;
 }
 
-#define DHEAP_PEEK_LT_P(heap, max_score) \
-    (heap->size && CMP_LT(DHEAP_SCORE(heap, 0), max_score))
-
+#ifdef DHEAP_MAP
+/* (see DHeap#pop_lt) */
 static VALUE
-dheap_pop_all_below0(dheap_t *heap, SCORE max_score, VALUE array)
+dheapmap_pop_lt(VALUE self, VALUE max_score)
 {
-    if (!RTEST(array)) { array = rb_ary_new(); }
-    if (RB_TYPE_P(array, T_ARRAY)) {
-        while (DHEAP_PEEK_LT_P(heap, max_score)) {
-            rb_ary_push(array, dheap_pop0(heap));
-        }
-    } else {
-        while (DHEAP_PEEK_LT_P(heap, max_score)) {
-            rb_funcall(array, id_lshift, 1, dheap_pop0(heap));
-        }
-    }
-    return array;
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    VALUE    popped;
+    POP_LT(dheapmap, heap, VAL2SCORE(max_score), &popped);
+    return popped;
 }
+#endif
+
+#define POP_ALL_BELOW(T, heap, max_score, array)                               \
+    do {                                                                       \
+        VALUE val = Qnil;                                                      \
+        if (RB_TYPE_P(array, T_ARRAY)) {                                       \
+            while ((val = PEEK_LT_P(heap, max_score))) {                       \
+                DHEAP_DELETE_0(T, heap);                                       \
+                rb_ary_push(array, val);                                       \
+            }                                                                  \
+        } else {                                                               \
+            while ((val = PEEK_LT_P(heap, max_score))) {                       \
+                DHEAP_DELETE_0(T, heap);                                       \
+                rb_funcall(array, id_lshift, 1, val);                          \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
 
 /*
  * @overload pop_all_below(max_score, receiver = [])
@@ -856,18 +935,12 @@ dheap_pop_all_below0(dheap_t *heap, SCORE max_score, VALUE array)
 static VALUE
 dheap_pop_all_below(int argc, VALUE *argv, VALUE self)
 {
-    dheap_t *heap = get_dheap_struct(self);
-    SCORE max_score;
-    VALUE array;
-    rb_check_frozen(self);
+    dheap_t *heap      = get_dheap_struct_unfrozen(self);
+    SCORE    max_score = (argc) ? VAL2SCORE(argv[0]) : 0.0;
+    VALUE    array     = (argc == 1) ? rb_ary_new() : argv[1];
     rb_check_arity(argc, 1, 2);
-    max_score = VAL2SCORE(argv[0]);
-    if (argc == 1) {
-        array = rb_ary_new();
-    } else {
-        array = argv[1];
-    }
-    return dheap_pop_all_below0(heap, max_score, array);
+    DHEAP_DISPATCH_STMT(heap, POP_ALL_BELOW, max_score, array);
+    return array;
 }
 
 /********************************************************************
@@ -876,6 +949,17 @@ dheap_pop_all_below(int argc, VALUE *argv, VALUE self)
  *
  ********************************************************************/
 
+static VALUE
+dheap_to_a(VALUE self)
+{
+    dheap_t *heap  = get_dheap_struct(self);
+    VALUE    array = rb_ary_new_capa(heap->size);
+    for (size_t i = 0; i < heap->size; i++) {
+        rb_ary_push(array, DHEAP_ENTRY_ARY(heap, i));
+    }
+    return array;
+}
+
 /*
  * Clears all values from the heap, leaving it empty.
  *
@@ -884,14 +968,64 @@ dheap_pop_all_below(int argc, VALUE *argv, VALUE self)
 static VALUE
 dheap_clear(VALUE self)
 {
-    dheap_t *heap = get_dheap_struct(self);
-    rb_check_frozen(self);
-    if (0 < heap->size) {
+    dheap_t *heap = get_dheap_struct_unfrozen(self);
+    if (!DHEAP_EMPTY_P(heap)) {
         heap->size = 0;
+#ifdef DHEAP_MAP
+        if (DHEAPMAP_P(heap)) rb_hash_clear(heap->indexes);
+#endif
     }
     return self;
 }
 
+/********************************************************************
+ *
+ * DHeap::Map methods
+ *
+ ********************************************************************/
+
+#ifdef DHEAP_MAP
+
+/*
+ * Retrieves the score that has been assigned to a heap member.
+ *
+ * Time complexity: <b>O(1)</b>
+ *
+ * @param object [Object] an object to lookup
+ * @return [Float,Integer,nil] the score associated with the object,
+ *                             or nil if the object isn't a member
+ */
+static VALUE
+dheapmap_aref(VALUE self, VALUE object)
+{
+    dheap_t *heap   = get_dheap_struct(self);
+    VALUE    idxval = rb_hash_lookup2(heap->indexes, object, Qfalse);
+    if (idxval) {
+        size_t index = NUM2ULONG(idxval);
+        return SCORE2NUM(DHEAP_SCORE(heap, index));
+    }
+    return Qnil;
+}
+
+/*
+ * Assign a score to an object, adding it to the heap or updating as necessary.
+ *
+ * Time complexity: <b>O(log n)</b> (score decrease will be faster than
+ * score increase)
+ *
+ * @param object [Object] an object to lookup
+ * @param score [Integer,#to_f] the score to set
+ * @return [Float,Integer] the score
+ */
+static VALUE
+dheapmap_aset(VALUE self, VALUE object, VALUE score)
+{
+    dheapmap_insert(self, score, object);
+    return score;
+}
+
+#endif
+
 /********************************************************************
  *
  * DHeap setup
@@ -902,14 +1036,26 @@ void
 Init_d_heap(void)
 {
     VALUE rb_cDHeap = rb_define_class("DHeap", rb_cObject);
+#ifdef DHEAP_MAP
+    VALUE rb_cDHeapMap = rb_define_class_under(rb_cDHeap, "Map", rb_cDHeap);
+#endif
 
-    id_cmp = rb_intern_const("<=>");
-    id_abs = rb_intern_const("abs");
+    id_cmp    = rb_intern_const("<=>");
+    id_abs    = rb_intern_const("abs");
     id_lshift = rb_intern_const("<<");
-    id_unary_minus = rb_intern_const("-@");
+    id_uminus = rb_intern_const("-@");
 
     rb_define_alloc_func(rb_cDHeap, dheap_s_alloc);
 
+#ifdef DHEAP_MAP
+#    define def_override_inherited(rb_name, c_name, argc)                      \
+        rb_define_method(rb_cDHeap, rb_name, dheap_##c_name, argc);            \
+        rb_define_method(rb_cDHeapMap, rb_name, dheapmap_##c_name, argc);
+#else
+#    define def_override_inherited(rb_name, c_name, argc)                      \
+        rb_define_method(rb_cDHeap, rb_name, dheap_##c_name, argc);
+#endif
+
     /*
      * This is based on INT_MAX. But it is very very unlikely you will want a
      * large value for d.  The tradeoff is that higher d values give faster push
@@ -917,12 +1063,12 @@ Init_d_heap(void)
      * stick with the default.  If you expect more pushes than pops, it might be
      * worthwhile to increase d.
      */
-    rb_define_const(rb_cDHeap, "MAX_D",        INT2NUM(DHEAP_MAX_D));
+    rb_define_const(rb_cDHeap, "MAX_D", INT2NUM(DHEAP_MAX_D));
 
     /*
      * d=4 uses the fewest comparisons for (worst case) insert + delete-min.
      */
-    rb_define_const(rb_cDHeap, "DEFAULT_D",    INT2NUM(DHEAP_DEFAULT_D));
+    rb_define_const(rb_cDHeap, "DEFAULT_D", INT2NUM(DHEAP_DEFAULT_D));
 
     /*
      * The default heap capacity.  The heap grows automatically as necessary, so
@@ -930,26 +1076,31 @@ Init_d_heap(void)
      */
     rb_define_const(rb_cDHeap, "DEFAULT_CAPA", INT2NUM(DHEAP_DEFAULT_CAPA));
 
-    rb_define_private_method(rb_cDHeap, "__init_without_kw__", dheap_initialize, 2);
+    rb_define_private_method(rb_cDHeap, "__init_without_kw__", dheap_init, 3);
     rb_define_method(rb_cDHeap, "initialize_copy", dheap_initialize_copy, 1);
 
-    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, "insert",  dheap_insert, 2);
-    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, "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, "to_a", dheap_to_a, 0);
 
-    rb_define_method(rb_cDHeap, "pop_lt",        dheap_pop_lt, 1);
-    rb_define_method(rb_cDHeap, "pop_lte",       dheap_pop_lte, 1);
+    rb_define_method(rb_cDHeap, "clear", dheap_clear, 0);
+    rb_define_method(rb_cDHeap, "peek", dheap_peek, 0);
+    rb_define_method(rb_cDHeap, "peek_score", dheap_peek_score, 0);
+    rb_define_method(rb_cDHeap, "peek_with_score", dheap_peek_with_score, 0);
     rb_define_method(rb_cDHeap, "pop_all_below", dheap_pop_all_below, -1);
 
-    rb_define_method(rb_cDHeap, "peek_score",      dheap_peek_score, 0);
-    rb_define_method(rb_cDHeap, "peek_with_score", dheap_peek_with_score, 0);
-    rb_define_method(rb_cDHeap, "pop_with_score",  dheap_pop_with_score, 0);
+    def_override_inherited("insert", insert, 2);
+    def_override_inherited("push", push, -1);
+    def_override_inherited("<<", lshift, 1);
 
+    def_override_inherited("pop", pop, 0);
+    def_override_inherited("pop_lt", pop_lt, 1);
+    def_override_inherited("pop_lte", pop_lte, 1);
+    def_override_inherited("pop_with_score", pop_with_score, 0);
+
+#ifdef DHEAP_MAP
+    rb_define_method(rb_cDHeapMap, "[]", dheapmap_aref, 1);
+    rb_define_method(rb_cDHeapMap, "[]=", dheapmap_aset, 2);
+#endif
 }