data_structures_rmolinari 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f006234ee3b216d5607e9b10bb1958a6107ccfa0cc8c359f98383dc7fde14ee
-  data.tar.gz: f281ab0768e24e7c983cd046ba7b185dab8fd972fb3065fd73ff575782bf5486
+  metadata.gz: 87a44faaaa62f555546867230df704981671491f040f6be29eeed7db7eb22a0a
+  data.tar.gz: 0a0f1f6cf22bdde5d0510a818af9d8a6dbdbf11a6e69ce2e178bf6f336bb3d92
 SHA512:
-  metadata.gz: e274a97f177fad44bad20ecf24ecca1385fee3c217e7e42aac076c24377970c6444dfdbadc6fd3e1e201555177429c9f8eddaee211e463dd60f6b36e74004eec
-  data.tar.gz: 293fc0b2973a8d851c27f4e64177dbf7b9a25b2bb7eb9efb4b33abdb07c4e006f80f4450996ef99da7e8bb1516ca8aa89ab893258960d9127d101995906254ed
+  metadata.gz: 990fc38cbc64c20290317bf2858ff6f2813f832d0046f249faea32c7f88f389e8c8c2db892f8288a0747aa9446181864a3e62435e4846a230411b6afa4b75faf
+  data.tar.gz: f1e641b03d30c4726268c1c8da6d6364f635251152230f89aba2b551f0355d37ce843dba8e631c2fbd4a20e87ae94c78cf30b46dc3d472f1a1b55add258de32a

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+### Changed
+
+- MaxPrioritySearchTree
+  - Duplicate y values are now allowed. Ties are broken with a preference for smaller values of x.
+  - Method names have changed
+    - Instead of "highest", "leftmost", "rightmost" we use "largest_y", "smallest_x", "largest_x"
+    - For example, +highest_ne+ is now +largest_y_in_nw+
+- DisjointUnion
+  - the size argument to initializer is optional. The default value is 0.
+  - elements can be added to the "universe" of known values with +make_set+
+
+### Removed
+- MinmaxPrioritySearchTree is no longer available
+  - it was only a partial implementation anyway
+
 ## [0.3.0] 2023-01-06
 
 ### Added

data/lib/data_structures_rmolinari/disjoint_union.rb

@@ -10,34 +10,48 @@
 # See https://en.wikipedia.org/wiki/Disjoint-set_data_structure for a good introduction.
 #
 # The code uses several ideas from Tarjan and van Leeuwen for efficiency. We use "union by rank" in +unite+ and path-halving in
-# +find+. Together, these make the amortized cost for each of n such operations effectively constant.
+# +find+. Together, these make the amortized cost of each opperation effectively constant.
 #
-# - Tarjan, Robert E., van Leeuwen, Jan (1984). "Worst-case analysis of set union algorithms". Journal of the ACM. 31 (2): 245–281.
+# - Tarjan, Robert E., van Leeuwen, Jan (1984). _Worst-case analysis of set union algorithms_. Journal of the ACM. 31 (2): 245–281.
 #
 # @todo
 #   - allow caller to expand the size of the universe. This operation is called "make set".
 #     - All we need to do is increase the size of @d, set the parent pointers, define the new ranks (zero), and update @size.
 class DataStructuresRMolinari::DisjointUnion
+  include Shared
+
   # The number of subsets in the partition.
   attr_reader :subset_count
 
-  # @param size the size of the universe, which must be known at the time of construction. The elements 0, 1, ..., size - 1 start
-  #   out in disjoint singleton subsets.
-  def initialize(size)
-    @size = size
+  # @param initial_size the initial size of the universe. The elements 0, 1, ..., initial_size - 1 start out in disjoint singleton
+  # subsets.
+  def initialize(initial_size = 0)
     # Initialize to
-    @d = (0...size).to_a
-    @rank = [0] * size
+    @d = (0...initial_size).to_a
+    @rank = [0] * initial_size
+
+    @subset_count = initial_size
+  end
+
+  # Add a new subset to the universe containing the element +new_v+
+  # @param new_v the new element, starting in its own singleton subset
+  #   - it must be a non-negative integer, not already part of the universe of elements.
+  def make_set(new_v)
+    raise DataError, "Element #{new_v} must be a non-negative integer" unless new_v.is_a?(Integer) && !new_v.negative?
+    raise DataError, "Element #{new_v} is already present" if @d[new_v]
 
-    @subset_count = size
+    @d[new_v] = new_v
+    @rank[new_v] = 0
+    @subset_count += 1
   end
 
   # Declare that e and f are equivalent, i.e., in the same subset. If they are already in the same subset this is a no-op.
   #
-  # Each argument must be one of 0, 1, ..., size-1.
+  # Each argument must be in the universe of elements
   def unite(e, f)
     check_value(e)
     check_value(f)
+
     raise 'Uniting an element with itself is meaningless' if e == f
 
     e_root = find(e)
@@ -50,9 +64,11 @@ class DataStructuresRMolinari::DisjointUnion
 
   # The canonical representative of the subset containing e. Two elements d and e are in the same subset exactly when find(d) ==
   # find(e).
-  # @param e must be one of 0, 1, ..., size-1.
-  # @return (Integer) one of 0, 1, ..., size-1.
+  # @param e must be in the universe of elements
+  # @return (Integer) one of the universe of elements
   def find(e)
+    check_value(e)
+
     # We implement find with "halving" to shrink the length of paths to the root. See Tarjan and van Leeuwin p 252.
     x = e
     x = @d[x] = @d[@d[x]] while @d[@d[x]] != @d[x]
@@ -60,7 +76,7 @@ class DataStructuresRMolinari::DisjointUnion
   end
 
   private def check_value(v)
-    raise DataError, "Value must be given and be in (0..#{@size - 1})" unless v && v.between?(0, @size - 1)
+    raise Shared::DataError, "Value #{v} is not part of the univserse." unless @d[v]
   end
 
   private def link(e, f)

data/lib/data_structures_rmolinari/generic_segment_tree.rb

@@ -1,7 +1,7 @@
 require_relative 'shared'
 
-# A Segment Tree, which can be used for various interval-related purposes, like efficiently finding the sum (or min or max) on a
-# arbitrary subarray of a given array.
+# The template of Segment Tree, which can be used for various interval-related purposes, like efficiently finding the sum (or min or
+# max) on a arbitrary subarray of a given array.
 #
 # There is an excellent description of the data structure at https://cp-algorithms.com/data_structures/segment_tree.html. The
 # Wikipedia article (https://en.wikipedia.org/wiki/Segment_tree) appears to describe a different data structure which is sometimes
@@ -16,7 +16,7 @@ require_relative 'shared'
 # initializer and the definitions of concrete realisations like MaxValSegmentTree.
 #
 # We do O(n) work to build the internal data structure at initialization. Then we answer queries in O(log n) time.
-class DataStructuresRMolinari::GenericSegmentTree
+class DataStructuresRMolinari::SegmentTreeTemplate
   include Shared::BinaryTreeArithmetic
 
   # Construct a concrete instance of a Segment Tree. See details at the links above for the underlying concepts here.

data/lib/data_structures_rmolinari/max_priority_search_tree.rb

@@ -1,3 +1,4 @@
+require 'must_be'
 require 'set'
 require_relative 'shared'
 
@@ -9,18 +10,18 @@ require_relative 'shared'
 # operations. It is their approach that we have implemented.
 #
 # The PST structure is an implicit, balanced binary tree with the following properties:
-# * The tree is a _max-heap_ in the y coordinate. That is, the point at each node has a y-value less than its parent.
+# * The tree is a _max-heap_ in the y coordinate. That is, the point at each node has a y-value no greater than its parent.
 # * For each node p, the x-values of all the nodes in the left subtree of p are less than the x-values of all the nodes in the right
 #   subtree of p. Note that this says nothing about the x-value at the node p itself. The tree is thus _almost_ a binary search tree
 #   in the x coordinate.
 #
 # Given a set of n points, we can answer the following questions quickly:
 #
-# - +leftmost_ne+: for x0 and y0, what is the leftmost point (x, y) in P satisfying x >= x0 and y >= y0?
-# - +rightmost_nw+: for x0 and y0, what is the rightmost point (x, y) in P satisfying x <= x0 and y >= y0?
-# - +highest_ne+: for x0 and y0, what is the highest point (x, y) in P satisfying x >= x0 and y >= y0?
-# - +highest_nw+: for x0 and y0, what is the highest point (x, y) in P satisfying x <= x0 and y >= y0?
-# - +highest_3_sided+: for x0, x1, and y0, what is the highest point (x, y) in P satisfying x >= x0, x <= x1 and y >= y0?
+# - +smallest_x_in_ne+: for x0 and y0, what is the leftmost point (x, y) in P satisfying x >= x0 and y >= y0?
+# - +largest_x_in_nw+: for x0 and y0, what is the rightmost point (x, y) in P satisfying x <= x0 and y >= y0?
+# - +largest_y_in_ne+: for x0 and y0, what is the highest point (x, y) in P satisfying x >= x0 and y >= y0?
+# - +largest_y_in_nw+: for x0 and y0, what is the highest point (x, y) in P satisfying x <= x0 and y >= y0?
+# - +largest_y_in_3_sided+: for x0, x1, and y0, what is the highest point (x, y) in P satisfying x >= x0, x <= x1 and y >= y0?
 # - +enumerate_3_sided+: for x0, x1, and y0, enumerate all points in P satisfying x >= x0, x <= x1 and y >= y0.
 #
 # (Here, "leftmost/rightmost" means "minimal/maximal x", and "highest" means "maximal y".)
@@ -29,8 +30,8 @@ require_relative 'shared'
 #
 # The final operation (enumerate) takes O(m + log n) time, where m is the number of points that are enumerated.
 #
-# In the current implementation no two points can share an x-value and no two points can share a y-value. This (rather severe)
-# restriction can be relaxed with some more complicated code.
+# In the current implementation no two points can share an x-value. This (rather severe) restriction can be relaxed with some more
+# complicated code, but it hasn't been written yet. See issue #9.
 #
 #
 # There is a related data structure called the Min-max priority search tree so we have called this a "Max priority search tree", or
@@ -49,7 +50,7 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   # @param data [Array] the set P of points presented as an array. The tree is built in the array in-place without cloning.
   #   - Each element of the array must respond to +#x+ and +#y+.
   #     - This is not checked explicitly but a missing method exception will be thrown when we try to call one of them.
-  #   - The +x+ values must be distinct, as must the +y+ values. We raise a +Shared::DataError+ if this isn't the case.
+  #   - The +x+ values must be distinct. We raise a +Shared::DataError+ if this isn't the case.
   #     - This is a restriction that simplifies some of the algorithm code. It can be removed as the cost of some extra work. Issue
   #       #9.
   #
@@ -60,9 +61,8 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     @size = @data.size
 
     construct_pst
-    return unless verify
 
-    verify_properties
+    verify_properties if verify
   end
 
   ########################################
@@ -74,11 +74,11 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   # structure. Define p* as
   #
   # - (infty, -infty) if Q \intersect P is empty and
-  # - the highest (max-x) point in Q \intersect P otherwise.
+  # - the highest (max-y) point in Q \intersect P otherwise, breaking ties by preferring smaller values of x
   #
   # This method returns p* in O(log n) time and O(1) extra space.
-  def highest_ne(x0, y0)
-    highest_in_quadrant(x0, y0, :ne)
+  def largest_y_in_ne(x0, y0)
+    largest_y_in_quadrant(x0, y0, :ne)
   end
 
   # Return the highest point in P to the "northwest" of (x0, y0).
@@ -87,17 +87,17 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   # structure. Define p* as
   #
   # - (-infty, -infty) if Q \intersect P is empty and
-  # - the highest (max-y) point in Q \intersect P otherwise.
+  # - the highest (max-y) point in Q \intersect P otherwise, breaking ties by preferring smaller values of x
   #
   # This method returns p* in O(log n) time and O(1) extra space.
-  def highest_nw(x0, y0)
-    highest_in_quadrant(x0, y0, :nw)
+  def largest_y_in_nw(x0, y0)
+    largest_y_in_quadrant(x0, y0, :nw)
   end
 
-  # The basic algorithm is from De et al. section 3.1. We have generalaized it slightly to allow it to calculate both highest_ne and
-  # highest_nw
+  # The basic algorithm is from De et al. section 3.1. We have generalaized it slightly to allow it to calculate both largest_y_in_ne and
+  # largest_y_in_nw
   #
-  # Note that highest_ne(x0, y0) = highest_3_sided(x0, infinty, y0) so we don't really need this. But it's a bit faster than the
+  # Note that largest_y_in_ne(x0, y0) = largest_y_in_3_sided(x0, infinty, y0) so we don't really need this. But it's a bit faster than the
   # general case and is a simple algorithm that introduces a typical way that an algorithm interacts with the data structure.
   #
   # From the paper:
@@ -108,7 +108,7 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   #     - If Q intersect P is empty then p* = best
   #
   # Here, P is the set of points in our data structure and T_p is the subtree rooted at p
-  private def highest_in_quadrant(x0, y0, quadrant)
+  private def largest_y_in_quadrant(x0, y0, quadrant)
     quadrant.must_be_in [:ne, :nw]
 
     p = root
@@ -135,10 +135,10 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     #
     #   takes as input a point t and does the following: if t \in Q and y(t) > y(best) then it assignes best = t
     #
-    # Note that the paper identifies a node in the tree with its value. We need to grab the correct node.
+    # We break ties by preferring points with smaller x values
     update_highest = lambda do |node|
       t = @data[node]
-      if in_q.call(t) && t.y > best.y
+      if in_q.call(t) && (t.y > best.y || (t.y == best.y && t.x < best.x))
         best = t
       end
     end
@@ -194,7 +194,7 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   # - the leftmost (min-x) point in Q \intersect P otherwise.
   #
   # This method returns p* in O(log n) time and O(1) extra space.
-  def leftmost_ne(x0, y0)
+  def smallest_x_in_ne(x0, y0)
     extremal_in_x_dimension(x0, y0, :ne)
   end
 
@@ -207,14 +207,14 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   # - the leftmost (min-x) point in Q \intersect P otherwise.
   #
   # This method returns p* in O(log n) time and O(1) extra space.
-  def rightmost_nw(x0, y0)
+  def largest_x_in_nw(x0, y0)
     extremal_in_x_dimension(x0, y0, :nw)
   end
 
-  # A genericized version of the paper's leftmost_ne that can calculate either leftmost_ne or rightmost_nw as specifies via a
+  # A genericized version of the paper's smallest_x_in_ne that can calculate either smallest_x_in_ne or largest_x_in_nw as specifies via a
   # parameter.
   #
-  # Quadrant is either :ne (which gives leftmost_ne) or :nw (which gives rightmost_nw).
+  # Quadrant is either :ne (which gives smallest_x_in_ne) or :nw (which gives largest_x_in_nw).
   #
   # From De et al:
   #
@@ -245,7 +245,7 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     #   takes as input a point t and does the following: if t \in Q and x(t) < x(best) then it assignes best = t
     #
     # Note that the paper identifies a node in the tree with its value. We need to grab the correct node.
-    update_leftmost = lambda do |node|
+    update_best = lambda do |node|
       t = @data[node]
       if in_q.call(t) && sign * t.x < sign * best.x
         best = t
@@ -261,13 +261,13 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     #
     # - If x0 <= x(c1) then all subtrees have large enough x values and we look for the leftmost node in c with a large enough y
     #   value. Both p and q are sent into that subtree.
-    # - If x0 >= x(ck) the the rightmost subtree is our only hope the rightmost subtree.
+    # - If x0 >= x(ck) the the rightmost subtree is our only hope
     # - Otherwise, x(c1) < x0 < x(ck) and we let i be least so that x(ci) <= x0 < x(c(i+1)). Then q becomes the lefmost cj in c not
     #   to the left of ci such that y(cj) >= y0, if any. p becomes ci if y(ci) >= y0 and q otherwise. If there is no such j, we put
     #   q = p. This may leave both of p, q undefined which means there is no useful way forward and we return nils to signal this to
     #   calling code.
     #
-    # The same logic applies to rightmost_nw, though everything is "backwards"
+    # The same logic applies to largest_x_in_nw, though everything is "backwards"
     # - membership of Q depends on having a small-enough value of x, rather than a large-enough one
     # - among the ci, values towards the end of the array tend not to be in Q while values towards the start of the array tend to be
     #  in Q
@@ -302,14 +302,14 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
       new_p ||= new_q # if nodes[i] is no good, send p along with q
       new_q ||= new_p # but if there is no worthwhile value for q we should send it along with p
 
-      return [new_q, new_p] if quadrant == :nw # swap for the rightmost_nw case.
+      return [new_q, new_p] if quadrant == :nw # swap for the largest_x_in_nw case.
 
       [new_p, new_q]
     end
 
     until leaf?(p)
-      update_leftmost.call(p)
-      update_leftmost.call(q)
+      update_best.call(p)
+      update_best.call(q)
 
       if p == q
         if one_child?(p)
@@ -324,7 +324,7 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
           q = p # p itself is just one layer above the leaves, or is itself a leaf
         elsif one_child?(q)
           # This generic approach is not as fast as the bespoke checks described in the paper. But it is easier to maintain the code
-          # this way and allows easy implementation of rightmost_nw
+          # this way and allows easy implementation of largest_x_in_nw
           p, q = determine_next_nodes.call(left(p), right(p), left(q))
         else
           p, q = determine_next_nodes.call(left(p), right(p), left(q), right(q))
@@ -332,8 +332,8 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
         break unless p # we've run out of useful nodes
       end
     end
-    update_leftmost.call(p) if p
-    update_leftmost.call(q) if q
+    update_best.call(p) if p
+    update_best.call(q) if q
     best
   end
 
@@ -346,10 +346,10 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   # MaxPST. (Note that Q is empty if x1 < x0.) Define p* as
   #
   # - (infty, -infty) if Q \intersect P is empty and
-  # - the highest (max-x) point in Q \intersect P otherwise.
+  # - the highest (max-y) point in Q \intersect P otherwise, breaking ties by preferring smaller x values.
   #
   # This method returns p* in O(log n) time and O(1) extra space.
-  def highest_3_sided(x0, x1, y0)
+  def largest_y_in_3_sided(x0, x1, y0)
     # From the paper:
     #
     #    The three real numbers x0, x1, and y0 define the three-sided range Q = [x0,x1] X [y0,∞). If Q \intersect P̸ is not \empty,
@@ -389,7 +389,7 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     # Note that the paper identifies a node in the tree with its value. We need to grab the correct node.
     update_highest = lambda do |node|
       t = @data[node]
-      if in_q.call(t) && t.y > best.y
+      if in_q.call(t) && (t.y > best.y || (t.y == best.y && t.x < best.x))
         best = t
       end
     end
@@ -570,7 +570,7 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     # My high-level understanding of the algorithm
     # --------------------------------------------
     #
-    # We need to find all elements of Q \intersect P, so it isn't enough, as it was in highest_3_sided simply to keep track of p and
+    # We need to find all elements of Q \intersect P, so it isn't enough, as it was in largest_y_in_3_sided simply to keep track of p and
     # q. We need to track four nodes, p, p', q', and q which are (with a little handwaving) respectively
     #
     # - the rightmost node to the left of Q' = [x0, x1] X [-infinity, infinity],
@@ -692,8 +692,6 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     # The four key helpers described in the paper
 
     # Handle the next step of the subtree at p
-    #
-    # I need to go through this with paper, pencil, and some diagrams.
     enumerate_left = lambda do
       if leaf?(p)
         left = false
@@ -999,13 +997,14 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
 
   private def construct_pst
     raise DataError, 'Duplicate x values are not supported' if contains_duplicates?(@data, by: :x)
-    raise DataError, 'Duplicate y values are not supported' if contains_duplicates?(@data, by: :y)
 
-    # We follow the algorithm in the paper by De, Maheshwari et al.
+    # We follow the algorithm in the paper by De, Maheshwari et al, which takes O(n log^2 n) time. Their follow-up paper that
+    # defines the Min-max PST, describes how to do the construction in O(n log n) time, but it is more complex and probably not
+    # worth the trouble of both a bespoke heapsort the special sorting algorithm of Katajainen and Pasanen.
 
-    # Since we are building an implicit binary tree, things are simpler if the array is 1-based. This probably requires a malloc and
-    # data copy, which isn't great, but it's in the C layer so cheap compared to the O(n log^2 n) work we need to do for
-    # construction. In fact, we are probably doing O(n^2) work because of all the calls to #index_with_largest_y_in.
+    # Since we are building an implicit binary tree, things are simpler if the array is 1-based. This requires a malloc (perhaps)
+    # and memcpy (for sure), which isn't great, but it's in the C layer so cheap compared to the O(n log^2 n) work we need to do for
+    # construction.
     @data.unshift nil
 
     h = Math.log2(@size).floor
@@ -1052,63 +1051,14 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
     end
   end
 
-  ########################################
-  # Tree arithmetic
-
-  # # First element and root of the tree structure
-  # private def root
-  #   1
-  # end
-
-  # # Indexing is from 1
-  # private def parent(i)
-  #   i >> 1
-  # end
-
-  # private def left(i)
-  #   i << 1
-  # end
-
-  # private def right(i)
-  #   1 + (i << 1)
-  # end
-
-  # private def level(i)
-  #   l = 0
-  #   while i > root
-  #     i >>= 1
-  #     l += 1
-  #   end
-  #   l
-  # end
-
-  # # i has no children
-  # private def leaf?(i)
-  #   i > @last_non_leaf
-  # end
-
-  # # i has exactly one child (the left)
-  # private def one_child?(i)
-  #   i == @parent_of_one_child
-  # end
-
-  # # i has two children
-  # private def two_children?(i)
-  #   i <= @last_parent_of_two_children
-  # end
-
-  # # i is the left child of its parent.
-  # private def left_child?(i)
-  #   (i & 1).zero?
-  # end
-
   private def swap(index1, index2)
     return if index1 == index2
 
     @data[index1], @data[index2] = @data[index2], @data[index1]
   end
 
-  # The index in @data[l..r] having the largest value for y
+  # The index in @data[l..r] having the largest value for y, breaking ties with the smaller x value. Since we are already sorted by
+  # x we don't actually need to check this.
   private def index_with_largest_y_in(l, r)
     return nil if r < l
 
@@ -1134,7 +1084,8 @@ class DataStructuresRMolinari::MaxPrioritySearchTree
   private def verify_properties
     # It's a max-heap in y
     (2..@size).each do |node|
-      raise InternalLogicError, "Heap property violated at child #{node}" unless @data[node].y < @data[parent(node)].y
+      byebug unless @data[node].y <= @data[parent(node)].y
+      raise InternalLogicError, "Heap property violated at child #{node}" unless @data[node].y <= @data[parent(node)].y
     end
 
     # Left subtree has x values less than all of the right subtree

data/lib/data_structures_rmolinari.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require_relative 'data_structures_rmolinari/shared'
 
 module DataStructuresRMolinari
@@ -10,14 +12,13 @@ require_relative 'data_structures_rmolinari/disjoint_union'
 require_relative 'data_structures_rmolinari/generic_segment_tree'
 require_relative 'data_structures_rmolinari/heap'
 require_relative 'data_structures_rmolinari/max_priority_search_tree'
-require_relative 'data_structures_rmolinari/minmax_priority_search_tree'
 
 # A namespace to hold the provided classes. We want to avoid polluting the global namespace with names like "Heap"
 module DataStructuresRMolinari
   ########################################
   # Concrete instances of Segment Tree
   #
-  # @todo consider moving these into generic_segment_tree.rb
+  # @todo consider moving these into generic_segment_tree.rb and renaming that file
 
   # A segment tree that for an array A(0...n) answers questions of the form "what is the maximum value in the subinterval A(i..j)?"
   # in O(log n) time.
@@ -30,7 +31,7 @@ module DataStructuresRMolinari
     # @param data an object that contains values at integer indices based at 0, via +data[i]+.
     #   - This will usually be an Array, but it could also be a hash or a proc.
     def initialize(data)
-      @structure = GenericSegmentTree.new(
+      @structure = SegmentTreeTemplate.new(
         combine:               ->(a, b) { [a, b].max },
         single_cell_array_val: ->(i) { data[i] },
         size:                  data.size,
@@ -57,7 +58,7 @@ module DataStructuresRMolinari
 
     # @param (see MaxValSegmentTree#initialize)
     def initialize(data)
-      @structure = GenericSegmentTree.new(
+      @structure = SegmentTreeTemplate.new(
         combine:               ->(p1, p2) { p1[1] >= p2[1] ? p1 : p2 },
         single_cell_array_val: ->(i) { [i, data[i]] },
         size:                  data.size,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_structures_rmolinari
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Rory Molinari
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-06 00:00:00.000000000 Z
+date: 2023-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: must_be
@@ -86,7 +86,6 @@ files:
 - lib/data_structures_rmolinari/generic_segment_tree.rb
 - lib/data_structures_rmolinari/heap.rb
 - lib/data_structures_rmolinari/max_priority_search_tree.rb
-- lib/data_structures_rmolinari/minmax_priority_search_tree.rb
 - lib/data_structures_rmolinari/shared.rb
 homepage: https://github.com/rmolinari/data_structures
 licenses:

data/lib/data_structures_rmolinari/minmax_priority_search_tree.rb

@@ -1,668 +0,0 @@
-require 'must_be'
-
-require_relative 'shared'
-
-# THIS CLASS IS INCOMPLETE AND NOT USABLE
-#
-# A priority search tree (PST) stores points in two dimensions (x,y) and can efficiently answer certain questions about the set of
-# point.
-#
-# The structure was introduced by McCreight [1].
-#
-# See more: https://en.wikipedia.org/wiki/Priority_search_tree
-#
-# It is possible to build such a tree in place, given an array of pairs. See [2]. In a follow-up paper, [3], the authors show how to
-# construct a more flexible data structure,
-#
-#   "[T]he Min-Max Priority Search tree for a set P of n points in R^2. It is a binary tree T with the following properties:
-#
-#    * For each internal node u, all points in the left subtree of u have an x-coordinate which is less than the x-coordinate of any
-#      point in the right subtree of u.
-#    * The y-coordinate values of the nodes on even (resp. odd) levels are smaller (resp. greater) than the y-coordinate values of
-#      their descendants (if any), where the root is at level zero.
-#
-#    "The first property implies that T is a binary search three on the x-coordinates of the points in P, excepts that there is no
-#     relation between the x-coordinates of the points stored at u and any of its children. The second property implies that T is a
-#     min-max heap on the y-coordinates of the points in P."
-#
-# I started implementing the in-place PST. Then, finding the follow-up paper [3], decided to do that one instead, as the paper says
-# it is more flexible. The point is to learn a new data structure and its associated algorithms.
-#
-# The algorithms are rather bewildering. Highest3SidedUp is complicated, and only two of the functions CheckLeft, CheckLeftIn,
-# CheckRight, CheckRightIn are given; the other two are "symmetric". But it's not really clear what the first are actually doing, so
-# it's hard to know what the others actually do.
-#
-# The implementation is incomplete. The pseduo-code in the paper is buggy (see the code below), which makes progress difficult.
-#
-# [1] E. McCreight, _Priority Search Trees_, SIAM J. Computing, v14, no 3, May 1985, pp 257-276.
-# [2] De, Maheshwari, Nandy, Smid, _An in-place priority search tree_, 23rd Annual Canadian Conference on Computational Geometry.
-# [3] De, Maheshwari, Nandy, Smid, _An in-place min-max priority search tree_, Computational Geometry, v46 (2013), pp 310-327.
-# [4] Atkinson, Sack, Santoro, Strothotte, _Min-max heaps and generalized priority queues_, Commun. ACM 29 (10) (1986), pp 996-1000.
-class DataStructuresRMolinari::MinmaxPrioritySearchTree
-  include Shared
-
-  # The array of pairs is turned into a minmax PST in-place without cloning. So clone before passing it in, if you care.
-  #
-  # Each element must respond to #x and #y. Use Point (above) if you like.
-  def initialize(data, verify: false)
-    @data = data
-    @size = @data.size
-
-    construct_pst
-    return unless verify
-
-    # puts "Validating tree structure..."
-    verify_properties
-  end
-
-  # Let Q = [x0, infty) X [y0, infty) be the northeast "quadrant" defined by the point (x0, y0) and let P be the points in this data
-  # structure. Define p* as
-  #
-  # - (infty, infty) if Q \intersect P is empty and
-  # - the leftmost (i.e., min-x) point in Q \intersect P otherwise
-  #
-  # This method returns p*.
-  #
-  # From De et al:
-  #
-  #   [t]he variables best, p, and q satisfy the folling invariant:
-  #
-  #     - if Q \intersect P is nonempty then  p* \in {best} \union T(p) \union T(q)
-  #     - if Q \intersect P is empty then p* = best
-  #     - p and q are at the same level of T and x(p) <= x(q)
-  #
-  # Here T(x) is the subtree rooted at x
-  def leftmost_ne(x0, y0)
-    best = Point.new(INFINITY, INFINITY)
-    p = q = root
-
-    in_q = ->(pair) { pair.x >= x0 && pair.y >= y0 }
-
-    # From the paper:
-    #
-    #   takes as input a point t \in P and updates best as follows: if t \in Q and x(t) < x(best) then it assignes best = t
-    #
-    # Note that the paper identifies a node in the tree with its value. We need to grab the correct node.
-    update_leftmost = lambda do |node|
-      t = val_at(node)
-      if in_q.call(t) && t.x < best.x
-        best = t
-      end
-    end
-
-    # Generalize the c1,...,c4 idea from the paper in line with the BUG 2 IN PAPER notes, below.
-    #
-    # Given: 0 or more nodes n1, ..., nk in the tree. All are at the same level, which is a "max level" in our MinmaxPST, such that
-    # x(n1) <= x(n2) <= ... <= x(nk). (Note: it is expected that the nj are either children or grandchildren of p and q, though we
-    # don't check that.)
-    #
-    # If k = 0 return nil. Otherwise...
-    #
-    # We return two values p_goal, q_goal (possibly equal) from among the nj such that
-    #
-    #    - p_goal is not to the right of q_goal in the tree and so, in particular x(p_goal) <= x(q_goal)
-    #    - if and when the auction reaches p = p_goal and q = q_goal the algorithm invariant will be satisfied.
-    #
-    # As a special case, we return nil if we detect that none of the subtrees T(nj) contain any points in Q. This is a sign to
-    # terminate the algorithm.
-    #
-    # See the notes at "BUG 2 IN PAPER" below for more details about what is going on.
-    determine_goal_nodes = lambda do |nodes|
-      node_count = nodes.size
-      return nil if node_count.zero?
-
-      if val_at(nodes.last).x <= x0
-        # Only the rightmost subtree can possibly have anything Q, assuming that all the x-values are distinct.
-        return [nodes.last, nodes.last]
-      end
-
-      if val_at(nodes.first).x > x0
-        # All subtrees have x-values large enough to provide elements of Q. Since we are at a max-level the y-values help us work
-        # out which subtree to focus on.
-        leftmost = nodes.find { |node| val_at(node).y >= y0 }
-
-        return nil unless leftmost # nothing left to find
-
-        # Otherwise we explore the leftmost subtree. Its root is in Q and can't be beaten by anything to its right.
-        return [leftmost, leftmost]
-      end
-
-      values = nodes.map { |n| val_at(n) }
-
-      # Otherwise x(n1) <= x0 < x(nk). Thus i is well-defined.
-      i = (0...node_count).select { |j| values[j].x <= x0 && x0 < values[j + 1].x }.min
-
-      # these nodes all have large-enough x-values and so this finds the ones in the set Q.
-      new_q = nodes[(i + 1)..].select { |node| val_at(node).y >= y0 }.min # could be nil
-      new_p = nodes[i] if values[i].y >= y0 # The leftmost subtree is worth exploring if the y-value is big enough. Otherwise not
-      new_p ||= new_q # if nodes[i] is no good we send p along with q
-      new_q ||= new_p # but if there was no worthwhile value for q we should send it along with p
-
-      return nil unless new_p
-
-      [new_p, new_q]
-    end
-
-    until leaf?(p)
-      level = Math.log2(p).floor # TODO: don't calculate log every time!
-
-      update_leftmost.call(p)
-      update_leftmost.call(q)
-
-      if p == q
-        if one_child?(p)
-          p = q = left(p)
-        else
-          q = right(p)
-          p = left(p)
-        end
-      else
-        # p != q
-        if leaf?(q)
-          q = p # p itself is just one layer above the leaves, or is itself a leaf
-        elsif one_child?(q)
-          # Note that p has two children
-          if val_at(left(q)).x < x0
-            # x-values below p are too small
-            p = q = left(q)
-          elsif val_at(right(p)).x <= x0
-            # x-values in T(right(p)) are too small. DISTINCT-X
-            p = right(p)
-            q = left(q)
-          else
-            # BUG 1 IN PAPER.
-            #
-            # So, x(q_l) >= x0 and x(p_r) > x0. But how can we be sure that the child of q isn't the winner?. Should we be trying
-            # it in this case?
-            #
-            # Yes: otherwise it never gets checked.
-
-            update_leftmost.call(left(q))
-            q = right(p)
-            p = left(p)
-          end
-        else
-          # p and q both have two children
-
-          # BUG 2 IN PAPER.
-          #
-          # Define c as the paper does:
-          #
-          #   (c1, c2, c3, c4) = (left(p), right(p), left(q), right(q))
-          #
-          # Because of the PST property on x and the invariant x(p) <= x(q) we know that
-          #
-          #   x(c1) <= x(c2) <= x(c3) <= x(c4)
-          #
-          # Similarly, the sets of values x(T(ci)) are pairwise ordered in the same sense.
-          #
-          # Suppose further that x(ci) <= x0 <= x(c(i+i)). Then we know several things
-          #
-          #   - there might be a "winner" (point in Q) in T(ci), perhaps ci itself.
-          #   - there are not any winners in T(cj) for j < i, becasue the x-values there aren't big enough
-          #   - any winner in ck, for k >= i, will be the left of and thus beat any winner in c(k+1), because of the ordering of
-          #     x-values
-          #
-          # If x(c4) <= x0 then the rightmost subtree T(c4) is the only one worth checking and we set p = q = c4.
-          # If x(c1) > x0 then we take i = 0 and ignore the logic on ci in what follows and setting p = q.
-          #
-          # Pretend for the moment that we are using a MaxPST instead of a MinmaxPST. Then we can look at y values to learn more.
-          #
-          #   - if y(ci) >= y0 then we need to search T(ci), so we will update p = ci
-          #   - but if y(ci) < y0 then there are no winners in T(ci) because the y-values are too small.
-          #   - similarly, if y(c(i+i)) >= y0 then we need to search T(c(i+1)). Indeed c(i+1) itself is in Q and beats any winner in
-          #     subtrees further to the right
-          #   - so, let k > i be minimal such that y(ck) >= y0, if there is any. Note that ck is itself a winner. Then
-          #     - if y(ci) >= y0,
-          #       - set p = ci, and q = ck (or q = ci if there is no such k)
-          #     - otherwise (T(ci) has no winners because its y-values are too small)
-          #       - if k is defined set p = q = ck. Otherwise HALT (there are no more winners)
-          #
-          # But we are working with a MinmaxPST rather than a MaxPST, so we have to work harder. If c1, ..., c4 (the children of p
-          # and q) are in a "max-level" of the tree - that is, an even level - then the logic above still applies. But if they are
-          # at a min level things are trickier and we need to go another layer down.
-          #
-          # The paper knows that we need to look a further layer down, but the logic is too simplistic. It looks at cj for j > i and
-          # checks if cj or either of its children are in Q. But that's not good enough. For the same reason that in a MaxPST we may
-          # need to explore below T(ci) even if ci isn't in Q, we may need to decend through one of the grandchilden of p or q even
-          # if that grandchild isn't in Q.
-          #
-          # Getting a bit handwavey especially over what happens near the leaves...
-          #
-          # Consider the children d1, d2, ..., dm, of ci, ..., c4 (and so grandchildren of p and q). They are at a max-level and so
-          # the logic described applies to the dk. If ci happens to be a winner we can set p = ci and work out what to do with q by
-          # looking at the children of c(i+1), ..., c4. Otherwise we look at all the dj values (up to 8 of them), apply the logic
-          # above to work out that we want to head for, say, p = ds and q = dt, and in this cycle update p = parent(ds), q =
-          # parent(dt).  (We also need to submit the values c(i+1)..c4 to UpdateLeftmost.)
-          #
-          # In other words, we can use the MaxPST logic on d1,...,dm to decide where we need to go, and then step to the relevant
-          # parents among the cj.
-
-          c = [left(p), right(p), left(q), right(q)]
-          if level.odd?
-            # the elements of c are at an even level, and hence their y values are maxima for the subtrees. We can learn what we
-            # need to know from them
-            p, q = determine_goal_nodes.call(c)
-            if p && !q
-              # byebug
-              # determine_goal_nodes.call(c)
-              raise 'bad logic'
-            end
-          else
-            # They are at an odd level and so aren't helpful in working out what to do next: we look at their children, which are in
-            # a max-level. We need to check the elements of c against best since we are otherwise ignoring them.
-            c.each { |n| update_leftmost.call(n) }
-
-            d = c.map { [left(_1), right(_1)]}.flatten.select { |n| n <= @size }
-
-            # Note that we are jumping down two levels here!
-            p, q = determine_goal_nodes.call(d)
-            if p && !q
-              # byebug
-              # determine_goal_nodes.call(c)
-              raise 'bad logic'
-            end
-
-            p
-          end
-
-          return best unless p # nothing more to do
-        end
-      end
-    end
-    update_leftmost.call(p)
-    update_leftmost.call(q)
-    best
-  end
-
-  # Let Q be the "three-sided query range" [x0, x1] X [y0, infty) and let P_Q be P \intersect Q.
-  #
-  # If P_Q is empty then p* = (infty, -infty).
-  # Otherwise, p* is the point in P_Q with maximal y value.
-  #
-  # This method returns p*
-  # def highest_3_sided_up(x0, x1, y0)
-  #   best = Point.new(INFINITY, -INFINITY)
-
-  #   in_q = lambda do |pair|
-  #     pair.x >= x0 && pair.x <= x1 && pair.y >= y0
-  #   end
-
-  #   # From the paper:
-  #   #
-  #   #   takes as input a point t and does the following: if t \in Q and y(t) > y(best) then it assignes best = t
-  #   #
-  #   # Note that the paper identifies a node in the tree with its value. We need to grab the correct node.
-  #   #
-  #   # The algorithm is complicated. From the paper:
-  #   #
-  #   #   Since Q is bounded by two vertical sides, we use four index variables p, p', q and q' to guide the search path. In addition,
-  #   #   we use four bits L, L', R and R'; these correspond to the subtrees of T rooted at the nodes p, p', q, and q', respectively;
-  #   #   if a bit is equal to one, then the corresonding node is referred to as an _active node_ (for example, if L = 1 then p is an
-  #   #   active node), and the subtree rooted at that node may contain a candidate point for p*. So the search is required to be
-  #   #   performed in the subtree rooted at all active nodes. More formally, at any instant of time the variables satisfy the folling
-  #   #   invariants:
-  #   #
-  #   #     - If L  = 1 the x(p) < x0.
-  #   #     - If L' = 1 then x0 <= x(p') <= x1.
-  #   #     - If R  = 1 then x(q) > x1.
-  #   #     - If R' = 1 then x0 <= x(q') <= x1.
-  #   #     - If L' = 1 and R' = 1 then x(p') <= x(q').
-  #   #     - If P_Q is non-empty then p* = best or p* is in the subtree rooted at any one of the active nodes.
-  #   #
-  #   # There are more details in the paper
-  #   update_highest = lambda do |node|
-  #     t = val_at(node)
-  #     if in_q.call(t) && t.y > best.y
-  #       best = t
-  #     end
-  #   end
-
-  #   ex_update_highest = lambda do |node|
-  #     update_highest.call(node)
-  #     update_highest.call(left(node)) unless leaf?(node)
-  #     update_highest.call(right(node)) unless one_child?(node)
-  #   end
-
-  #   if val_at(root).x < x0
-  #     p = root
-  #     l = true
-  #     l_prime = r = r_prime = false
-  #   elsif val_at(root).x < x1
-  #     p_prime = root
-  #     l_prime = true
-  #     l = r = r_prime = false
-  #   else
-  #     q = root
-  #     r = true
-  #     l = l_prime = r_prime = false
-  #   end
-
-  #   set_z = lambda do
-  #     r = []
-  #     r << p if l
-  #     r << p_prime if l_prime
-  #     r << q if r
-  #     r << q_prime if r_primg
-  #     r
-  #   end
-
-  #   check_left = lambda do
-  #     if leaf?(p)
-  #       l = false
-  #     elsif one_child?(p)
-  #       p_l_x = val_at(left(p))
-  #       if x0 <= p_l_x && p_l_x <= x1
-  #         update_highest.call(left(p))
-  #         if l_prime && r_prime
-  #           ex_update_highest.call(p_prime)
-  #         elsif l_prime
-  #           q_prime = p_prime
-  #           r_prime = true
-  #         end
-  #         p_prime = left(p)
-  #         l_prime = true
-  #         l = false
-  #       elsif p_l_x < x0
-  #         p = left(p)
-  #       else
-  #         q = left(p)
-  #         r = true
-  #         l = false
-  #       end
-  #     else
-  #       # p has two children
-
-  #   end
-
-  #   while l || l_prime || r || r_prime
-  #     z_star = set_z.call.min_by(4) { level(_1) }
-  #     if z_star.include? p_prime
-  #       check_left_in(p_prime)
-  #     elsif z_star.include? q_prime
-  #       check_right_in(q_prime)
-  #     elsif z_star.include? p
-  #       check_left(p)
-  #     else
-  #       check_right(q)
-  #     end
-  #   end
-  # end
-
-  # Find the "highest" (max-y) point that is "northeast" of (x, y).
-  #
-  # That is, the point p* in Q = [x, infty) X [y, infty) with the largest y value, or (infty, -infty) if there is no point in that
-  # quadrant.
-  #
-  # Algorithm is from De et al. section 3.1
-  def highest_ne(x0, y0)
-    raise "Write me"
-    # From the paper:
-    #
-    #   The algorithm uses two variables best and p, which satisfy the following invariant
-    #
-    #     - If Q intersect P is nonempty then p* in {best} union T_p
-    #     - If Q intersect P is empty then p* = best
-    #
-    # Here, P is the set of points in our data structure and T_p is the subtree rooted at p
-    best = Point.new(INFINITY, -INFINITY)
-    p = root # root of the whole tree AND the pair stored there
-
-    in_q = lambda do |pair|
-      pair.x >= x0 && pair.y >= y0
-    end
-
-    # From the paper:
-    #
-    #   takes as input a point t and does the following: if t \in Q and y(t) > y(best) then it assignes best = t
-    #
-    # Note that the paper identifies a node in the tree with its value. We need to grab the correct node.
-    update_highest = lambda do |node|
-      t = val_at(node)
-      if in_q.call(t) && t.y > best.y
-        best = t
-      end
-    end
-
-    # We could make this code more efficient. But since we only have O(log n) steps we won't actually gain much so let's keep it
-    # readable and close to the paper's pseudocode for now.
-    until leaf?(p)
-      p_val = val_at(p)
-      if in_q.call(p_val)
-        # p \in Q and nothing in its subtree can beat it because of the max-heap
-        update_highest.call(p)
-        return best
-
-        # p = left(p) <- from paper
-      elsif p_val.y < y0
-        # p is too low for Q, so the entire subtree is too low as well
-        return best
-
-        # p = left(p)
-      elsif one_child?(p)
-        # With just one child we need to check it
-        p = left(p)
-      elsif val_at(right(p)).x <= x0
-        # right(p) might be in Q, but nothing in the left subtree can be, by the PST property on x.
-        p = right(p)
-      elsif val_at(left(p)).x >= x0
-        # Both children are in Q, so try the higher of them. Note that nothing in either subtree will beat this one.
-        higher = left(p)
-        if val_at(right(p)).y > val_at(left(p)).y
-          higher = right(p)
-        end
-        p = higher
-      elsif val_at(right(p)).y < y0
-        # Nothing in the right subtree is in Q, but maybe we'll find something in the left
-        p = left(p)
-      else
-        # At this point we know that right(p) \in Q so we need to check it. Nothing in its subtree can beat it so we don't need to
-        # look there. But there might be something better in the left subtree.
-        update_highest.call(right(p))
-        p = left(p)
-      end
-    end
-    update_highest.call(p) # try the leaf
-    best
-  end
-
-  # O(n log^2 n)
-  private def construct_pst
-    # We follow the algorithm in [3]. Indexing is from 1 there and we follow that here. The algorithm is almost exactly the same as
-    # for the (max) PST.
-    h = Math.log2(@size).floor
-    a = @size - (2**h - 1) # the paper calls it A
-    sort_subarray(1, @size)
-    level = 0 # TODO: isn't level always equal to i in the loop?
-
-    (0...h).each do |i|
-      sense = level.even? ? :max : :min
-      pow_of_2 = 2**i
-
-      k = a / (2**(h - i))
-      k1 = 2**(h + 1 - i) - 1
-      k2 = (1 - k) * 2**(h - i) - 1 + a
-      k3 = 2**(h - i) - 1
-      (1..k).each do |j|
-        l = index_with_extremal_y_in(pow_of_2 + (j - 1) * k1, pow_of_2 + j * k1 - 1, sense:)
-        swap(l, pow_of_2 + j - 1)
-      end
-
-      if k < pow_of_2
-        l = index_with_extremal_y_in(pow_of_2 + k * k1, pow_of_2 + k * k1 + k2 - 1, sense:)
-        swap(l, pow_of_2 + k)
-
-        m = pow_of_2 + k * k1 + k2
-        (1..(pow_of_2 - k - 1)).each do |j|
-          l = index_with_extremal_y_in(m + (j - 1) * k3, m + j * k3 - 1, sense:)
-          swap(l, pow_of_2 + k + j)
-        end
-      end
-      sort_subarray(2 * pow_of_2, @size)
-      level += 1
-    end
-  end
-
-  ########################################
-  # Indexing the data structure as though it were from 1, even though the underlying @data is indexed from zero.
-
-  # First element and root of the tree structure
-  private def root
-    1
-  end
-
-  private def val_at(idx)
-    @data[idx - 1]
-  end
-
-  # Indexing is from 1
-  private def parent(i)
-    i >> 1
-  end
-
-  private def left(i)
-    i << 1
-  end
-
-  private def right(i)
-    1 + (i << 1)
-  end
-
-  private def leaf?(i)
-    left(i) > @size
-  end
-
-  private def one_child?(i)
-    left(i) <= @size && right(i) > @size
-  end
-
-  private def swap(index1, index2)
-    return if index1 == index2
-
-    @data[index1 - 1], @data[index2 - 1] = @data[index2 - 1], @data[index1 - 1]
-  end
-
-  private def level(i)
-    count = 0
-    while i > root
-      i >>= 1
-      count += 1
-    end
-    count
-  end
-
-  # The index in @data[l..r] having the largest/smallest value for y
-  # The sense argument should be :min or :max
-  private def index_with_extremal_y_in(l, r, sense:)
-    return nil if r < l
-
-    case sense
-    when :min
-      (l..r).min_by { |idx| val_at(idx).y }
-    when :max
-      (l..r).max_by { |idx| val_at(idx).y }
-    else
-      raise "Bad comparison sense #{sense}"
-    end
-  end
-
-  # Sort the subarray @data[l..r]. This is much faster than a Ruby-layer heapsort because it is mostly happening in C.
-  private def sort_subarray(l, r)
-    # heapsort_subarray(l, r)
-    return if l == r # 1-array already sorted!
-
-    l -= 1
-    r -= 1
-    @data[l..r] = @data[l..r].sort_by(&:x)
-  end
-
-  ########################################
-  # Debugging support
-  #
-  # These methods are not written for speed
-
-  # Check that our data satisfies the requirements of a Priority Search Tree:
-  # - max-heap in y
-  # - all the x values in the left subtree are less than all the x values in the right subtree
-  def verify_properties
-    # It's a min-max heap in y
-    (2..@size).each do |node|
-      level = Math.log2(node).floor
-      parent_level = level - 1
-
-      _, _, min_y, max_y = minmax_in_subtree(node)
-      parent_y = val_at(parent(node)).y
-
-      it_is_fine = if parent_level.even?
-                     # max!
-                     parent_y > max_y
-                   else
-                     parent_y < min_y
-                   end
-
-      raise "Heap property violated at child #{node}" unless it_is_fine
-    end
-
-    # Left subtree has x values less than all of the right subtree
-    (1..@size).each do |node|
-      next if right(node) >= @size
-
-      left_max = max_x_in_subtree(left(node))
-      right_min = min_x_in_subtree(right(node))
-
-      raise "Left-right property of x-values violated at #{node}" unless left_max < right_min
-    end
-
-    nil
-  end
-
-  private def max_x_in_subtree(root)
-    minmax_in_subtree(root)[1]
-  end
-
-  private def min_x_in_subtree(root)
-    minmax_in_subtree(root)[0]
-  end
-
-  # Return min_x, max_x, min_y, max_y in subtree rooted at and including root
-  private def minmax_in_subtree(root)
-    @minmax_vals ||= []
-    @minmax_vals[root] ||= calc_minmax_at(root).freeze
-  end
-
-  # No memoization
-  private def calc_minmax_at(root)
-    return [INFINITY, -INFINITY, INFINITY, -INFINITY] if root > @size
-
-    pair = val_at(root)
-
-    return [pair.x, pair.x, pair.y, pair.y] if leaf?(root)
-
-    left = left(root)
-    left_min_max = minmax_in_subtree(left)
-    return left_min_max if one_child?(root)
-
-    right = right(root)
-    right_min_max = minmax_in_subtree(right)
-
-    [
-      [pair.x, left_min_max[0], right_min_max[0]].min,
-      [pair.x, left_min_max[1], right_min_max[1]].max,
-      [pair.y, left_min_max[2], right_min_max[2]].min,
-      [pair.y, left_min_max[3], right_min_max[3]].max
-    ]
-  end
-
-  private def output_quasi_dot
-    (2..@size).to_a.reverse.map do |node|
-      "#{val_at(parent(node)).fmt} -- #{val_at(node).fmt}"
-    end.join("\n")
-  end
-
-  private def pair_to_s
-  end
-
-  ########################################
-  # Dead code
-
-end