data_structures_rmolinari 0.4.3 → 0.5.0

data/ext/c_segment_tree_template/segment_tree_template.c

@@ -0,0 +1,363 @@
+/*
+ * This is a C implementation of a Segment Tree data structure.
+ *
+ * More specifically, it is the C version of the SegmentTreeTemplate Ruby class, for which see elsewhere in the repo.
+ */
+
+#include "ruby.h"
+#include "shared.h"
+
+#define single_cell_val_at(seg_tree, idx) rb_funcall(seg_tree->single_cell_array_val_lambda, rb_intern("call"), 1, LONG2FIX(idx))
+#define combined_val(seg_tree, v1, v2) rb_funcall(seg_tree->combine_lambda, rb_intern("call"), 2, (v1), (v2))
+
+/**
+ * The C implementation of a generic Segment Tree
+ */
+
+typedef struct {
+  VALUE *tree; // The 1-based implicit binary tree in which the data structure lives
+  VALUE single_cell_array_val_lambda;
+  VALUE combine_lambda;
+  VALUE identity;
+  size_t size; // the size of the underlying data array
+  size_t tree_alloc_size; // the size of the VALUE* tree array
+} segment_tree_data;
+
+/************************************************************
+ * Memory Management
+ *
+ */
+
+/*
+ * Create one (on the heap).
+ */
+static segment_tree_data *create_segment_tree() {
+  segment_tree_data *segment_tree = malloc(sizeof(segment_tree_data));
+
+  // Allocate the structures
+  segment_tree->tree = NULL; // we don't yet know how much space we need
+
+  segment_tree->single_cell_array_val_lambda = 0;
+  segment_tree->combine_lambda = 0;
+  segment_tree->size = 0; // we don't know the right value yet
+
+  return segment_tree;
+}
+
+/*
+ * Free the memory associated with a segment_tree.
+ *
+ * This will end up getting triggered by the Ruby garbage collector. Ruby learns about it via the segment_tree_type struct below.
+ */
+static void segment_tree_free(void *ptr) {
+  if (ptr) {
+    segment_tree_data *segment_tree = ptr;
+    xfree(segment_tree->tree);
+    xfree(segment_tree);
+  }
+}
+
+/*
+ * How much memory (roughly) does a segment_tree_data instance consume?
+ *
+ * I guess the Ruby runtime can use this information when deciding how agressive to be during garbage collection and such.
+ */
+static size_t segment_tree_memsize(const void *ptr) {
+  if (ptr) {
+    const segment_tree_data *st = ptr;
+
+    // for the tree array plus the size of the segment_tree_data struct itself.
+    return sizeof( VALUE ) * st->tree_alloc_size * 4 + sizeof(segment_tree_data);
+  } else {
+    return 0;
+  }
+}
+
+/*
+ * Mark the Ruby objects we hold so that the Ruby garbage collector knows that they are still in use.
+ */
+static void segment_tree_mark(void *ptr) {
+  segment_tree_data *st = ptr;
+
+  rb_gc_mark(st->combine_lambda);
+  rb_gc_mark(st->single_cell_array_val_lambda);
+  rb_gc_mark(st->identity);
+
+  for (size_t i = 0; i < st->tree_alloc_size; i++) {
+    VALUE value = st->tree[i];
+    if (value) {
+      rb_gc_mark(value);
+    }
+  }
+}
+
+
+/*
+ * A configuration struct that tells the Ruby runtime how to deal with a segment_tree_data object.
+ *
+ * https://docs.ruby-lang.org/en/master/extension_rdoc.html#label-Encapsulate+C+data+into+a+Ruby+object
+ */
+static const rb_data_type_t segment_tree_type = {
+  .wrap_struct_name = "segment_tree_template",
+  { // help for the Ruby garbage collector
+    .dmark = segment_tree_mark, // dmark, for marking other Ruby objects.
+    .dfree = segment_tree_free, // how to free the memory associated with an object
+    .dsize = segment_tree_memsize, // roughly how much space does the object consume?
+  },
+  .data = NULL, // a data field we could use for something here if we wanted. Ruby ignores it
+  .flags = 0  // GC-related flag values.
+};
+
+/*
+ * End memory management functions.
+ ************************************************************/
+
+
+/************************************************************
+ * Wrapping and unwrapping the C struct and other things.
+ *
+ */
+
+/*
+ * Unwrap a Ruby-side disjoint union object to get the C struct inside.
+ *
+ * TODO: consider a macro in a shared header
+ */
+static segment_tree_data *unwrapped(VALUE self) {
+  segment_tree_data *segment_tree;
+  TypedData_Get_Struct((self), segment_tree_data, &segment_tree_type, segment_tree);
+  return segment_tree;
+}
+
+/*
+ * Allocate a segment_tree_data struct and wrap it for the Ruby runtime.
+ *
+ * This is for CSegmentTreeTemplate.allocate on the Ruby side.
+ */
+static VALUE segment_tree_alloc(VALUE klass) {
+  // Get one on the heap
+  segment_tree_data *segment_tree = create_segment_tree();
+  // ...and wrap it into a Ruby object
+  return TypedData_Wrap_Struct(klass, &segment_tree_type, segment_tree);
+}
+
+/*
+ * End wrapping and unwrapping functions.
+ ************************************************************/
+
+/************************************************************
+ * The Segment Tree API on the C side.
+ *
+ * We wrap these in the Ruby-ready functions below
+ */
+
+/*
+ * Recursively build the internal tree data structure.
+ *
+ * - tree_idx: the index into the tree array of the node being calculated
+ * - [tree_l, tree_r]: the sub-interval of the underlying array data corresponding to the tree node being calculated.
+ */
+static void build(segment_tree_data *segment_tree, size_t tree_idx, size_t tree_l, size_t tree_r) {
+  VALUE *tree = segment_tree->tree;
+
+  if (tree_l == tree_r) {
+    // Base case: the node corresponds to a subarray of length 1.
+    segment_tree->tree[tree_idx] = single_cell_val_at(segment_tree, tree_l);
+  } else {
+    // Build to two child nodes, and then combine their values for this node.
+    size_t mid = midpoint(tree_l, tree_r);
+    size_t left = left_child(tree_idx);
+    size_t right = right_child(tree_idx);
+
+    build(segment_tree, left, tree_l, mid);
+    build(segment_tree, right, mid + 1, tree_r);
+
+    VALUE comb_val = combined_val(segment_tree, tree[left], tree[right]);
+    segment_tree->tree[tree_idx] = comb_val;
+  }
+}
+
+/*
+ * Set up the internals with the arguments we get from #initialize.
+ *
+ * - combine: must be callable
+ * - single_cell_array_val: must be callable
+ * - size: must be a positive integer
+ * - identity: we don't care what it is.
+ *   - maybe we should check at least that it is not 0. But Qnil is fine.
+ */
+static void setup(segment_tree_data* seg_tree, VALUE combine, VALUE single_cell_array_val, VALUE size, VALUE identity) {
+  VALUE idCall = rb_intern("call");
+
+  if (!rb_obj_respond_to(combine, idCall, TRUE)) {
+    rb_raise(rb_eArgError, "wrong type argument %"PRIsVALUE" (should be callable)", rb_obj_class(combine));
+  }
+
+  if (!rb_obj_respond_to(single_cell_array_val, idCall, TRUE)) {
+    rb_raise(rb_eArgError, "wrong type argument %"PRIsVALUE" (should be callable)", rb_obj_class(single_cell_array_val));
+  }
+
+  seg_tree->combine_lambda = combine;
+  seg_tree->single_cell_array_val_lambda = single_cell_array_val;
+  seg_tree->identity = identity;
+  seg_tree->size = checked_nonneg_fixnum(size);
+
+  if (seg_tree->size == 0) {
+    rb_raise(rb_eArgError, "size must be positive.");
+  }
+
+  // Implicit binary tree with n leaves and straightforward left() and right() may use indices up to 4n.  But see here for a way to
+  // reduce the requirement to 2n: https://cp-algorithms.com/data_structures/segment_tree.html#memory-efficient-implementation
+  size_t tree_size = 1 + 4 * seg_tree->size;
+  seg_tree->tree = calloc(tree_size, sizeof(VALUE));
+  seg_tree->tree_alloc_size = tree_size;
+
+  build(seg_tree, TREE_ROOT, 0, seg_tree->size - 1);
+}
+
+
+/*
+ * Determine the value for the subarray A(left, right).
+ *
+ * - tree_idx: the index in the array of the node we are currently visiting
+ * - tree_l..tree_r: the subarray handled by the current node.
+ * - left..right: the subarray whose value we are currently looking for.
+ *
+ * As an invariant we have left..right \subset tree_l..tree_r.
+ *
+ * We start out with
+ * - tree_idx = TREE_ROOT
+ * - tree_l..tree_r = 0..(size - 1), and
+ * - left..right given by the client code's query
+ *
+ * If [tree_l, tree_r] = [left, right] then the current node gives the desired answer. Otherwise we decend the tree with one or two
+ * recursive calls.
+ *
+ * If left..right is contained the the bottom or top half of tree_l..tree_r we decend to the corresponding child with one recursive
+ * call. Otherwise we split left..right at the midpoint of tree_l..tree_r, make two recursive calls, and then combine the results.
+ */
+static VALUE determine_val(segment_tree_data* seg_tree, size_t tree_idx, size_t left, size_t right, size_t tree_l, size_t tree_r) {
+  // Does the current tree node exactly serve up the interval we're interested in?
+  if (left == tree_l && right == tree_r) {
+    return seg_tree->tree[tree_idx];
+  }
+
+  // We need to go further down the tree */
+  size_t mid = midpoint(tree_l, tree_r);
+  if (mid >= right) {
+    // Our interval is contained by the left child's interval
+    return determine_val(seg_tree, left_child(tree_idx),  left, right, tree_l,  mid);
+  } else if (mid + 1 <= left) {
+    // Our interval is contained by the right child's interval
+    return determine_val(seg_tree, right_child(tree_idx), left, right, mid + 1, tree_r);
+  } else {
+    // Our interval is split between the two, so we need to combine the results from the children.
+    return rb_funcall(
+                      seg_tree->combine_lambda, rb_intern("call"), 2,
+                      determine_val(seg_tree, left_child(tree_idx),  left,    mid,   tree_l,  mid),
+                      determine_val(seg_tree, right_child(tree_idx), mid + 1, right, mid + 1, tree_r)
+                      );
+  }
+}
+
+/*
+ * Update the structure to reflect the change in the underlying array at index idx.
+ *
+ * - idx: the index at which the underlying array data has changed.
+ * - tree_id: the index in the internal datastructure of the node we are currently visiting.
+ * - tree_l..tree_r: the range handled by the current node
+ */
+static void update_val_at(segment_tree_data *seg_tree, size_t idx, size_t tree_idx, size_t tree_l, size_t tree_r) {
+  if (tree_l == tree_r) {
+    // We have found the base case of our update
+    if (tree_l != idx) {
+      rb_raise(
+               eSharedInternalLogicError,
+               "tree_l == tree_r == %lu but they do not agree with the idx %lu holding the updated value",
+               tree_r, idx
+               );
+    }
+    seg_tree->tree[tree_idx] = single_cell_val_at(seg_tree, tree_l);
+  } else {
+    // Recursively update the appropriate subtree...
+    size_t mid = midpoint(tree_l, tree_r);
+    size_t left = left_child(tree_idx);
+    size_t right = right_child(tree_idx);
+    if (mid >= idx) {
+      update_val_at(seg_tree, idx, left, tree_l, mid);
+    } else {
+      update_val_at(seg_tree, idx, right, mid + 1, tree_r);
+    }
+    // ...and ourself to incorporate the change
+    seg_tree->tree[tree_idx] = combined_val(seg_tree, seg_tree->tree[left], seg_tree->tree[right]);
+  }
+}
+
+/*
+ * End C implementation of the Segment Tree API
+ ************************************************************/
+
+/**
+ * And now the wrappers around the C functionality.
+ */
+
+/*
+ * CSegmentTreeTemplate#c_initialize.
+ *
+ * (see CSegmentTreeTemplate#initialize).
+ */
+static VALUE segment_tree_init(VALUE self, VALUE combine, VALUE single_cell_array_val, VALUE size, VALUE identity) {
+  setup(unwrapped(self), combine, single_cell_array_val, size, identity);
+  return self;
+}
+
+/*
+ * (see SegmentTreeTemplate#query_on)
+ */
+static VALUE segment_tree_query_on(VALUE self, VALUE left, VALUE right) {
+  segment_tree_data* seg_tree = unwrapped(self);
+  size_t c_left = checked_nonneg_fixnum(left);
+  size_t c_right = checked_nonneg_fixnum(right);
+
+  if (c_right >= seg_tree->size) {
+    rb_raise(eSharedDataError, "Bad query interval %lu..%lu (size = %lu)", c_left, c_right, seg_tree->size);
+  }
+
+  if (left > right) {
+    // empty interval.
+    return seg_tree->identity;
+  }
+
+  return determine_val(seg_tree, TREE_ROOT, c_left, c_right, 0, seg_tree->size - 1);
+}
+
+/*
+ * (see SegmentTreeTemplate#update_at)
+ */
+static VALUE segment_tree_update_at(VALUE self, VALUE idx) {
+  segment_tree_data *seg_tree = unwrapped(self);
+  size_t c_idx = checked_nonneg_fixnum(idx);
+
+  if (c_idx >= seg_tree->size) {
+    rb_raise(eSharedDataError, "Cannot update value at index %lu, size = %lu", c_idx, seg_tree->size);
+  }
+
+  update_val_at(seg_tree, c_idx, TREE_ROOT, 0, seg_tree->size - 1);
+
+  return Qnil;
+}
+
+/*
+ * A generic Segment Tree template, written in C.
+ *
+ * (see SegmentTreeTemplate)
+ */
+void Init_c_segment_tree_template() {
+  VALUE mSegmentTree = rb_define_module_under(mDataStructuresRMolinari, "SegmentTree");
+  VALUE cSegmentTreeTemplate = rb_define_class_under(mSegmentTree, "CSegmentTreeTemplate", rb_cObject);
+
+  rb_define_alloc_func(cSegmentTreeTemplate, segment_tree_alloc);
+  rb_define_method(cSegmentTreeTemplate, "c_initialize", segment_tree_init, 4);
+  rb_define_method(cSegmentTreeTemplate, "query_on", segment_tree_query_on, 2);
+  rb_define_method(cSegmentTreeTemplate, "update_at", segment_tree_update_at, 1);
+}

data/ext/shared.c

@@ -0,0 +1,32 @@
+#include "shared.h"
+
+/*
+ * Arithmetic for in-array binary tree
+ */
+size_t midpoint(size_t left, size_t right) {
+  return (left + right) / 2;
+}
+
+size_t left_child(size_t i) {
+  return i << 1;
+}
+
+size_t right_child(size_t i) {
+  return 1 + (i << 1);
+}
+
+/*
+ * Check that a Ruby value is a non-negative Fixnum and convert it to a C unsigned long
+ */
+unsigned long checked_nonneg_fixnum(VALUE val) {
+  Check_Type(val, T_FIXNUM);
+  long c_val = FIX2LONG(val);
+
+  if (c_val < 0) {
+    rb_raise(eSharedDataError, "Value must be non-negative");
+  }
+
+  return c_val;
+}
+
+

data/lib/data_structures_rmolinari/algorithms.rb

@@ -1,4 +1,4 @@
-# A collection of algorithms that use the module's data structures but don't belong as a method on one of the data structures
+# Algorithms that use the module's data structures but don't belong as a method on one of the data structures
 module DataStructuresRMolinari::Algorithms
   include Shared
 
@@ -11,12 +11,12 @@ module DataStructuresRMolinari::Algorithms
   #
   # A _maximal empty rectangle_ (MER) for P is an empty rectangle for P not properly contained in any other.
   #
-  # We enumerate all maximal empty rectangles for P, yielding each as (left, right, bottom, top) to a block. The algorithm is due to
-  # De, M., Maheshwari, A., Nandy, S. C., Smid, M., _An In-Place Min-max Priority Search Tree_, Computational Geometry, v46 (2013),
-  # pp 310-327.
+  # We enumerate all maximal empty rectangles for P, yielding each as (left, right, bottom, top). The algorithm is due to De, M.,
+  # Maheshwari, A., Nandy, S. C., Smid, M., _An In-Place Min-max Priority Search Tree_, Computational Geometry, v46 (2013), pp
+  # 310-327.
   #
   # It runs in O(m log n) time, where m is the number of MERs enumerated and n is the number of points in P.  (Contructing the
-  # MaxPST below takes O(n log^2 n) time, but m = O(n^2) so we are still O(m log n) overall.)
+  # MaxPST takes O(n log^2 n) time, but m = O(n^2) so we are still O(m log n) overall.)
   #
   # @param points [Array] an array of points in the x-y plane. Each must respond to +x+ and +y+.
   def self.maximal_empty_rectangles(points)

data/lib/data_structures_rmolinari/c_segment_tree_template_impl.rb

@@ -0,0 +1,15 @@
+require 'must_be'
+
+require_relative 'shared'
+require_relative 'c_segment_tree_template'
+
+# The underlying functionality of the Segment Tree data type, implemented in C as a Ruby extension.
+#
+# See SegmentTreeTemplate for more information.
+class DataStructuresRMolinari::CSegmentTreeTemplate
+  # (see SegmentTreeTemplate::initialize)
+  def initialize(combine:, single_cell_array_val:, size:, identity:)
+    # having sorted out the keyword arguments, pass them more easily to the C layer.
+    c_initialize(combine, single_cell_array_val, size, identity)
+  end
+end

data/lib/data_structures_rmolinari/disjoint_union.rb

@@ -89,5 +89,7 @@ class DataStructuresRMolinari::DisjointUnion
     else
       @d[e] = f
     end
+
+    nil
   end
 end

data/lib/data_structures_rmolinari/segment_tree.rb

@@ -0,0 +1,126 @@
+require_relative 'shared'
+
+# A namespace to hold the various bits and bobs related to the SegmentTree implementation
+module DataStructuresRMolinari::SegmentTree
+end
+
+require_relative 'segment_tree_template'   # Ruby implementation of the generic API
+require_relative 'c_segment_tree_template' # C implementation of the generic API
+
+# Segment Tree: various concrete implementations
+#
+# 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
+# called an "interval tree."
+#
+# For more details (and some close-to-metal analysis of run time, especially for large datasets) see
+# https://en.algorithmica.org/hpc/data-structures/segment-trees/. In particular, this shows how to do a bottom-up implementation,
+# which is faster, at least for large datasets and cache-relevant compiled code. These issues don't really apply to code written in
+# Ruby.
+#
+# Here we provide several concrete segment tree implementations built on top of the template (generic) versions. Each instance is
+# backed either by the pure Ruby SegmentTreeTemplate or its C-based sibling CSegmentTreeTemplate
+module DataStructuresRMolinari
+  module SegmentTree
+    # A convenience method to construct a Segment Tree that, for a given array A(0...size), answers questions of the kind given by
+    # operation, using the template written in lang
+    #
+    # - @param data: the array A.
+    #   - It must respond to +#size+ and to +#[]+ with non-negative integer arguments.
+    # - @param operation: a supported "style" of Segment Tree
+    #   - for now, must be one of these (but you can write your own concrete version)
+    #     - +:max+: implementing +max_on(i, j)+, returning the maximum value in A(i..j)
+    #     - +:index_of_max+: implementing +index_of_max_val_on(i, j)+, returning an index corresponding to the maximum value in
+    #       A(i..j).
+    # - @param lang: the language in which the underlying "template" is written
+    #   - +:c+ or +:ruby+
+    #   - the C version will run faster but for now may be buggier and harder to debug
+    module_function def construct(data, operation, lang)
+      operation.must_be_in [:max, :index_of_max]
+      lang.must_be_in [:ruby, :c]
+
+      klass = operation == :max ? MaxValSegmentTree : IndexOfMaxValSegmentTree
+      template = lang == :ruby ? SegmentTreeTemplate : CSegmentTreeTemplate
+
+      klass.new(template, data)
+    end
+
+    # 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.
+    class MaxValSegmentTree
+      extend Forwardable
+
+      # Tell the tree that the value at idx has changed
+      def_delegator :@structure, :update_at
+
+      # @param template_klass the "template" class that provides the generic implementation of the Segment Tree functionality.
+      # @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(template_klass, data)
+        data.must_be_a Enumerable
+
+        @structure = template_klass.new(
+          combine:               ->(a, b) { [a, b].max },
+          single_cell_array_val: ->(i) { data[i] },
+          size:                  data.size,
+          identity:              -Shared::INFINITY
+        )
+      end
+
+      # The maximum value in A(i..j).
+      #
+      # The arguments must be integers in 0...(A.size)
+      # @return the largest value in A(i..j) or -Infinity if i > j.
+      def max_on(i, j)
+        @structure.query_on(i, j)
+      end
+    end
+
+    # A segment tree that for an array A(0...n) answers questions of the form "what is the index of the maximal value in the
+    # subinterval A(i..j)?" in O(log n) time.
+    class IndexOfMaxValSegmentTree
+      extend Forwardable
+
+      # Tell the tree that the value at idx has changed
+      def_delegator :@structure, :update_at
+
+      # @param (see MaxValSegmentTree#initialize)
+      def initialize(template_klass, data)
+        data.must_be_a Enumerable
+
+        @structure = template_klass.new(
+          combine:               ->(p1, p2) { p1[1] >= p2[1] ? p1 : p2 },
+          single_cell_array_val: ->(i) { [i, data[i]] },
+          size:                  data.size,
+          identity:              nil
+        )
+      end
+
+      # The index of the maximum value in A(i..j)
+      #
+      # The arguments must be integers in 0...(A.size)
+      # @return (Integer, nil) the index of the largest value in A(i..j) or +nil+ if i > j.
+      #   - If there is more than one entry with that value, return one the indices. There is no guarantee as to which one.
+      #   - Return +nil+ if i > j
+      def index_of_max_val_on(i, j)
+        @structure.query_on(i, j)&.first # discard the value part of the pair, which is a bookkeeping
+      end
+    end
+
+    # The underlying functionality of the Segment Tree data type, implemented in C as a Ruby extension.
+    #
+    # See SegmentTreeTemplate for more information.
+    #
+    # Implementation note
+    #
+    # The functionality is entirely written in C. But we write the constructor in Ruby because keyword arguments are difficult to
+    # parse on the C side.
+    class CSegmentTreeTemplate
+      # (see SegmentTreeTemplate::initialize)
+      def initialize(combine:, single_cell_array_val:, size:, identity:)
+        # having sorted out the keyword arguments, pass them more easily to the C layer.
+        c_initialize(combine, single_cell_array_val, size, identity)
+      end
+    end
+  end
+end

data/lib/data_structures_rmolinari/segment_tree_template.rb

@@ -1,7 +1,7 @@
 require_relative 'shared'
 
-# 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.
+# A generic implementation 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,8 @@ 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::SegmentTreeTemplate
+class DataStructuresRMolinari::SegmentTree::SegmentTreeTemplate
+  include Shared
   include Shared::BinaryTreeArithmetic
 
   # Construct a concrete instance of a Segment Tree. See details at the links above for the underlying concepts here.
@@ -47,27 +48,29 @@ class DataStructuresRMolinari::SegmentTreeTemplate
   end
 
   # The desired value (max, sum, etc.) on the subinterval left..right.
+  #
   # @param left the left end of the subinterval.
   # @param right the right end (inclusive) of the subinterval.
   #
+  # It must be that left..right is contained in 0...size.
+  #
   # The type of the return value depends on the concrete instance of the segment tree. We return the _identity_ element provided at
   # construction time if the interval is empty.
   def query_on(left, right)
-    raise DataError, "Bad query interval #{left}..#{right}" if left.negative? || right >= @size
+    raise DataError, "Bad query interval #{left}..#{right} (size = #{@size})" unless (0...@size).cover?(left..right)
 
     return @identity if left > right # empty interval
 
     determine_val(root, left, right, 0, @size - 1)
   end
 
-  # Update the value in the underlying array at the given idx
+  # Reflect the fact that the underlying array has been updated at the given idx
   #
   # @param idx an index in the underlying data array.
   #
   # Note that we don't need the updated value itself. We get that by calling the lambda +single_cell_array_val+ supplied at
   # construction.
   def update_at(idx)
-    raise DataError, 'Cannot update an index outside the initial range of the underlying data' unless (0...@size).cover?(idx)
 
     update_val_at(idx, root, 0, @size - 1)
   end
@@ -105,9 +108,9 @@ class DataStructuresRMolinari::SegmentTreeTemplate
       left = left(tree_idx)
       right = right(tree_idx)
       if mid >= idx
-        update_val_at(idx, left(tree_idx), tree_l, mid)
+        update_val_at(idx, left, tree_l, mid)
       else
-        update_val_at(idx, right(tree_idx), mid + 1, tree_r)
+        update_val_at(idx, right, mid + 1, tree_r)
       end
       @tree[tree_idx] = @combine.call(@tree[left], @tree[right])
     end