data_structures_rmolinari 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02563eb882aace27085e0db092d5a266c413c1864fe3c74d23d9c2af194f2d87
-  data.tar.gz: 2153f481d92569fbee02caea9df2177d9f7465d18e39d3764c4e92fc65a7cae6
+  metadata.gz: da4fc2b27a4f5c1071af7965dac6d3363cbfcb350f1ff391e88e6f7145561822
+  data.tar.gz: 114c9f4fb025ded31a2a42832aa7376333be03e58fe72e94ff3a1822a0e433d3
 SHA512:
-  metadata.gz: dbe47a34b03026dd0f82e5a3ba75a31c2a24a03b1d4d32fe94c0b9760e53c9171a964bec7fa04a7cc675bd980c938781c75e4f09817f4cac6b866f1aebf2483a
-  data.tar.gz: 9a80a2984dd8ed2caa63393b0a363c3e3e7414a79217bbb5daf1015a9c17b0842ff534d366eef05adb311ed7ef889a171140af282e3aee71619be3d9483e93c7
+  metadata.gz: f13b0ab86555fcb9d0cef6bdb788c20a4335ad2e08e17e2a58993bffa2bc0eec8beb7299af4a61ec6c033931534c14dd270cb157640c5402ddb7e6a1fa676156
+  data.tar.gz: b620688430c178d7e865b1cafd7b1628f0a9fb37bbb5aaba8879ab8b5f9563fa27f8c7c4368516940ede905a5bef5b02f3fb2c3e0263845d4103c6cb14492a5f

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [0.5.8] 2025-12-08
+
+- Algorithms
+  - #first_k: the smallest k elements of an enumerable, using a Heap internally
+
 ## [0.5.7] 2024-01-04
 
 - Heap

data/README.md

@@ -57,7 +57,7 @@ operations:
 - `top_priority`, return the _priority_ of the top element
 - `pop`, return the element with smallest priority and remove it from the structure
 - `update(item, priority)`, update the priority of the given item, which must already be in the heap
-- `update_by_delta(item, delta)`, update the priorityof the given item by adding delta to the priority; the item must already be in the heap
+- `update_by_delta(item, delta)`, update the priority of the given item by adding delta to the priority; the item must already be in the heap
 
 `top` and `top_priority` are O(1). The others are O(log n) where n is the number of items in the heap.
 
@@ -123,7 +123,7 @@ regions.
 By default these data structures are immutable: once constructed they cannot be changed. But there is a constructor option that
 makes the instance "dynamic". This allows us to delete the element at the root of the tree - the one with largest y value (smallest
 for MinPST) - with the `delete_top!` method. This operation is important in certain algorithms, such as enumerating all maximal
-empty rectangles (see the second paper by De et al[[DMNS2013]](#references)). Note that points can still not be added to the PST in
+empty rectangles (see the second paper by De et al [[DMNS2013]](#references)). Note that points can still not be added to the PST in
 any case, and choosing the dynamic option makes certain internal bookkeeping operations slower.
 
 In [[DMNS2013]](#references) De et al. generalize the in-place structure to a _Min-max Priority Search Tree_ (MinmaxPST) that can
@@ -161,7 +161,7 @@ initializer. Figuring out the details requires some knowledge of the internal me
 cp-algorithms.com is very helpful. See the implementations of the concrete classes `MaxValSegmentTree` and
 `IndexOfMaxValSegmentTree` for examples.
 
-Since there are several concrete "types" and two underlying generic implementions there is a convenience method on the `SegmentTree`
+Since there are several concrete "types" and two underlying generic implementations there is a convenience method on the `SegmentTree`
 module to get instances.
 
 ``` ruby
@@ -173,7 +173,7 @@ data = [1, -3, 2, 1, 5, -9]
 # Get a segment tree instance that will answer "max over this subinterval?" questions about data.
 # Here we get one using the ruby implementation of the generic functionality.
 #
-# Put :index_of_max in place of :map to get an instance that returns "an index of the maximum value
+# Put :index_of_max in place of :max to get an instance that returns "an index of the maximum value
 # over this subinterval".
 #
 # To use the generic code written in C, put :c instead of :ruby.
@@ -195,6 +195,10 @@ The Algorithms submodule contains some algorithms using the data structures.
     [left, right, bottom, top].
   - The algorithm is due to [[DMNS2013]](#references).
 
+- `first_k(enumerable, k)
+  - Given an enumerable, return the first k elements in sorted order.  That is, return the first k (smallest) elements of the sorted
+    version of the enumerable. We use a heap.  Run time is O(n log k), where n is the size of the enumerable.
+
 # C Extensions
 
 As another learning process I have implemented several of these data structures as C extensions. The APIs are the same.
@@ -218,7 +222,7 @@ I'm a bit suprised the improvement isn't larger, but remember that the C code mu
 in the underlying data array, and must access and combine them via Ruby lambdas.
 
 # References
-- [Allan] Allan, J., _CC: Convenient Containers_, https://github.com/JacksonAllan/CC, (retrieved 2023-02-01).
+- [Allan] Allan, J., _CC: Convenient Containers_, https://github.com/JacksonAllan/CC, (retrieved 2024-12-04).
 - [TvL1984] Tarjan, Robert E., van Leeuwen, J., _Worst-case Analysis of Set Union Algorithms_, Journal of the ACM, v31:2 (1984), pp
   245–281, https://dl.acm.org/doi/10.1145/62.2160 (retrieved 2022-02-01).
 - [EEK2017] Edelkamp, S., Elmasry, A., Katajainen, J., _Optimizing Binary Heaps_, Theory Comput Syst (2017), vol 61, pp 606-636, DOI