rbtree-ruby 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df8aaee3fedf309a0079082fa38c10e3748bc68873131800e13f30dee1202273
-  data.tar.gz: 5e6dd162b0ebb1b50929d9127c4ac57598c7391ecf63a7d1dca7e42107d4ca3a
+  metadata.gz: 2145d91a96cc64b7e65c65460716b678301f74d6decdffa2dbd077a914273c21
+  data.tar.gz: 66503c542ce07672a493830afbfcb66ebfea14d8563e67b1b2dd1d5ecd1d9c48
 SHA512:
-  metadata.gz: c1df7b56cad01d4a0725668f415510a3e65fd6409a0271143504ec1223d64a7e395a93a1dbd43881ceb75e5a36ea9328f60e86e95cdfcde653ab075fab81cb7b
-  data.tar.gz: cecad1db1c9fba3eb4c91b20493dc849cfbf70f8d2e1fede1c09e8b22d59d925e724e26788e06627a02b620de42c655afef4a8be51d31fdeaff5fa5158a2d192
+  metadata.gz: 7befca8277d78b75242a443c2ec155bded73f899222b32330c6416e6ffeaad8ec6bca01e11ce23c6047208871cf71cfb8c6a742732b4ae0b531f54e51a8e424e
+  data.tar.gz: eb77127897b535277717575afe27c47cd087ba15685f59b0df67516c55d393a8d7412cf08d667cea5494978746967c098294bb73e8e9771c2aee363762afcca9

data/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.3] - 2026-01-23
+
+### Optimized
+- **find_successor_node**: Optimized performance for scans starting from the beginning (or before `min_key`) when the `safe: true` option is used. Added a fast-path (short-circuit) when the given key is smaller than `min_key`.
+
+### Fixed
+- **MultiRBTree Aliases**: Fixed `delete`, `get`, and `[]` aliases in `MultiRBTree`. They now correctly point to the overridden methods in the derived class, ensuring correct value handling and size tracking.
+- **enum_for Syntax**: Syntactic corrections for `enum_for` to ensure robust keyword argument handling in enumerators.
+
+## [0.3.2] - 2026-01-15
+
+### Added
+- **Custom Node Allocator**: `RBTree#initialize` now accepts a `node_allocator:` keyword argument, allowing customization of the node pooling strategy.
+- **AutoShrinkNodePool**: Introduced `RBTree::AutoShrinkNodePool` as the default allocator. It automatically releases memory back to the GC when the pool size exceeds the fluctuation range of recent active node counts, preventing memory bloat in long-running processes with variable loads.
+- **Explicit Overwrite**: `overwrite: true` is now the explicit default for `initialize` and `insert`.
+
 ## [0.3.1] - 2026-01-15
 
 ### Added
@@ -191,6 +207,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - ASCII diagrams for tree rotation operations
 - MIT License (Copyright © 2026 Masahito Suzuki)
 
+[0.3.2]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.3.2
+[0.3.1]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.3.1
 [0.3.0]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.3.0
 [0.2.3]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.2.3
 [0.2.2]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.2.2

data/README.ja.md

@@ -6,11 +6,14 @@ Red-Black Tree（赤黒木）データ構造のピュアRuby実装です。挿
 
 ## 特徴
 
-- **自己平衡二分探索木**: 赤黒木の性質により最適なパフォーマンスを維持
-- **順序付き操作**: 効率的な範囲クエリ、最小/最大値の取得、ソート済みイテレーション
-- **複数値サポート**: `MultiRBTree`クラスで同一キーに複数の値を格納可能
-- **ピュアRuby**: C拡張不要、あらゆるRuby実装で動作
-- **充実したドキュメント**: 使用例付きの包括的なRDocドキュメント
+- **自己平衡二分探索木**: 赤黒木の性質により最適なパフォーマンスを維持。挿入・削除・検索がすべてO(log n)。
+- **順序付き操作**: ソート済みイテレーション、範囲クエリ（lt, gt, between）、最小/最大値取得が高速に実行可能。
+- **複数値サポート**: `MultiRBTree`クラスで同一キーに複数の値を格納。値は挿入順に保持され、最初または最後の値を個別にアクセス可能。
+- **ピュアRuby**: C拡張不要。MRI, JRuby, TruffleRubyなどあらゆるRuby実装で動作。
+- **ハイブリッドインデックス**: 内部ハッシュインデックスにより、キー検索と存在確認がO(1)の超高速アクセスを実現。
+- **メモリ効率**: ノードプールによるオブジェクト再利用と自動縮小機能でGC負荷を大幅に削減。長時間実行アプリにも適応。
+- **最近傍検索**: 数値キーに対して、最も近いキーペアをO(log n)で効率的に探索。
+- **安全なイテレーション**: `safe: true`オプションにより、イテレーション中に他の操作（削除・挿入）を安全に実行可能。
 
 ## インストール
 
@@ -236,12 +239,6 @@ tree.max(last: true)      # => [2, "b"]      (最大キーの最後の値)
 
 全要素のイテレーションはO(n)時間。
 
-### メモリ効率
-
-RBTreeは内部的な**メモリプール**を使用してノードオブジェクトを再利用:
-- 頻繁な挿入・削除時のGC負荷を大幅に削減
-- 100,000回の循環操作ベンチマークで**GC時間0.0秒**を達成
-
 ### RBTree vs Hash vs Array
 
 順序付き操作と空間的操作において、RBTreeは単に速いだけでなく、全く異なるクラスの性能を発揮。**50万件**でのベンチマーク:
@@ -254,6 +251,23 @@ RBTreeは内部的な**メモリプール**を使用してノードオブジェ
 | **ソート済みイテレーション** | **O(n)** | O(n log n) | **無料** | 常にソート済み vs 明示的な`sort` |
 | **キー検索** | **O(1)** | O(1) | **同等** | **ハイブリッドハッシュインデックスにより、Hashと同等のO(1)検索速度を実現** |
 
+### メモリ効率とカスタムアロケータ
+
+RBTreeは内部的な**メモリプール**を使用してノードオブジェクトを再利用します。
+- 頻繁な挿入・削除時のGC負荷を大幅に削減します。
+- **自動縮小**: デフォルトの `AutoShrinkNodePool` は、現在の使用量に対してプールが大きくなりすぎた場合、自動的に未使用ノードをRubyのGCに解放します。これにより、負荷が変動する長時間実行アプリケーションでのメモリ肥大化を防ぎます。
+- **カスタマイズ**: プールの動作をカスタマイズしたり、独自のアロケータを指定することができます:
+
+```ruby
+# 自動縮小パラメータのカスタマイズ
+pool = RBTree::AutoShrinkNodePool.new(
+  history_size: 60,       # 60秒の履歴
+  buffer_factor: 1.5,     # 変動幅の50%をバッファとして保持
+  reserve_ratio: 0.2      # 常に最大値の20%を予備として保持
+)
+tree = RBTree.new(node_allocator: pool)
+```
+
 ### RBTreeを使うべき場面
 
 ✅ **RBTreeが適している場合:**

data/README.md

@@ -6,11 +6,14 @@ A pure Ruby implementation of the Red-Black Tree data structure, providing effic
 
 ## Features
 
-- **Self-Balancing Binary Search Tree**: Maintains optimal performance through red-black tree properties
-- **Ordered Operations**: Efficient range queries, min/max retrieval, and sorted iteration
-- **Multi-Value Support**: `MultiRBTree` class for storing multiple values per key
-- **Pure Ruby**: No C extensions required, works on any Ruby implementation
-- **Well-Documented**: Comprehensive RDoc documentation with examples
+- **Self-Balancing Binary Search Tree**: Maintains optimal performance through red-black tree properties. All insertions, deletions, and lookups run in O(log n).
+- **Ordered Operations**: Efficient sorted iteration, range queries (`lt`, `gt`, `between`), min/max retrieval.
+- **Multi-Value Support**: `MultiRBTree` class stores multiple values per key, with access to first or last value individually.
+- **Pure Ruby**: No C extensions required. Works on MRI, JRuby, TruffleRuby, and all Ruby implementations.
+- **Hybrid Indexing**: Internal hash index enables O(1) key lookup and membership checks — matching standard Hash performance.
+- **Memory Efficiency**: Node recycling with auto-shrinking pool (`AutoShrinkNodePool`) drastically reduces GC pressure in long-running apps.
+- **Nearest Key Search**: Finds the closest numeric key in O(log n) time — ideal for spatial or temporal queries.
+- **Safe Iteration**: Use `safe: true` to safely modify the tree (insert/delete) during iteration.
 
 ## Installation
 
@@ -236,12 +239,6 @@ All major operations run in **O(log n)** time:
 
 Iteration over all elements takes O(n) time.
 
-### Memory Efficiency
-
-RBTree uses an internal **Memory Pool** to recycle node objects. 
-- Significantly reduces Garbage Collection (GC) pressure during frequent insertions and deletions (e.g., in high-throughput queues).
-- In benchmarks with 100,000 cyclic operations, **GC time was 0.0s** compared to significant pauses without pooling.
-
 ### RBTree vs Hash vs Array (Overwhelming Power)
 
 For ordered and spatial operations, RBTree is not just faster—it is in a completely different class. The following benchmarks were conducted with **500,000 items**:
@@ -254,6 +251,23 @@ For ordered and spatial operations, RBTree is not just faster—it is in a compl
 | **Sorted Iteration** | **O(n)** | O(n log n) | **FREE** | Always sorted vs explicit `sort` |
 | **Key Lookup** | **O(1)** | O(1) | **Equal** | **Hybrid Hash Index provides O(1) access like standard Hash** |
 
+### Memory Efficiency & Custom Allocators
+
+RBTree uses an internal **Memory Pool** to recycle node objects. 
+- Significantly reduces Garbage Collection (GC) pressure during frequent insertions and deletions.
+- **Auto-Shrinking**: The default `AutoShrinkNodePool` automatically releases unused nodes back to Ruby's GC when the pool gets too large relative to current usage, preventing memory leaks in long-running applications with fluctuating workloads.
+- **Customization**: You can customize the pool behavior or provide your own allocator:
+
+```ruby
+# Customize auto-shrink parameters
+pool = RBTree::AutoShrinkNodePool.new(
+  history_size: 60,       # 1 minute history
+  buffer_factor: 1.5,     # Keep 50% buffer above fluctuation
+  reserve_ratio: 0.2      # Always keep 20% reserve
+)
+tree = RBTree.new(node_allocator: pool)
+```
+
 ### When to Use RBTree
 
 ✅ **Use RBTree when you need:**

data/lib/rbtree/version.rb

@@ -2,5 +2,5 @@
 
 class RBTree
   # The version of the rbtree-ruby gem
-  VERSION = "0.3.1"
+  VERSION = "0.3.3"
 end

data/lib/rbtree.rb

@@ -77,6 +77,7 @@ class RBTree
   #
   # @param args [Hash, Array, nil] optional initial data
   # @param overwrite [Boolean] whether to overwrite existing keys (default: true)
+  # @param node_allocator [NodeAllocator] allocator instance to use (default: AutoShrinkNodePool.new)
   # @yieldreturn [Object] optional initial data
   #   - If a Hash is provided, each key-value pair is inserted into the tree
   #   - If an Array is provided, it should contain [key, value] pairs
@@ -91,7 +92,7 @@ class RBTree
   #   tree = RBTree.new([[1, 'one'], [2, 'two']])
   # @example Create with overwrite: false
   #   tree = RBTree.new([[1, 'one'], [1, 'uno']], overwrite: false)
-  def initialize(*args, overwrite: true, &block)
+  def initialize(*args, overwrite: true, node_allocator: AutoShrinkNodePool.new, &block)
     @nil_node = Node.new
     @nil_node.color = Node::BLACK
     @nil_node.left = @nil_node
@@ -99,9 +100,11 @@ class RBTree
     @root = @nil_node
     @min_node = @nil_node
     @hash_index = {}  # Hash index for O(1) key lookup
-    @node_pool = []   # Memory pool for recycling nodes
+    @node_allocator = node_allocator
     @key_count = 0
 
+    @overwrite = overwrite
+
     if args.size > 0 || block_given?
       insert(*args, overwrite: overwrite, &block)
     end
@@ -303,7 +306,7 @@ class RBTree
   #   tree.insert({1 => 'one', 2 => 'two'})
   # @example Bulk insert from Array
   #   tree.insert([[1, 'one'], [2, 'two']])
-  def insert(*args, overwrite: true, &block)
+  def insert(*args, overwrite: @overwrite, &block)
     if args.size == 2
       key, value = args
       insert_entry(key, value, overwrite: overwrite)
@@ -429,7 +432,7 @@ class RBTree
   #     tree.delete(k) if k.even?
   #   end
   def keys(reverse: false, safe: false, &block)
-    return enum_for(:keys, reverse: reverse, safe: safe) { @key_count } unless block_given?
+    return enum_for(__method__, reverse: reverse, safe: safe) { @key_count } unless block_given?
     each(reverse: reverse, safe: safe) { |key, _| yield key }
     self
   end
@@ -456,7 +459,7 @@ class RBTree
   #     tree.delete(k) if k.even?
   #   end
   def each(reverse: false, safe: false, &block)
-    return enum_for(:each, reverse: reverse, safe: safe) { size } unless block_given?
+    return enum_for(__method__, reverse: reverse, safe: safe) { size } unless block_given?
     if reverse
       traverse_all_desc(@root, safe: safe, &block)
     else
@@ -485,7 +488,7 @@ class RBTree
   # @return [Enumerator, RBTree] an Enumerator if no block is given, self otherwise
   # @see #each
   def reverse_each(safe: false, &block)
-    return enum_for(:reverse_each, safe: safe) { size } unless block_given?
+    return enum_for(__method__, safe: safe) { size } unless block_given?
     each(reverse: true, safe: safe, &block)
   end
 
@@ -502,7 +505,7 @@ class RBTree
   #   tree.lt(3, reverse: true).first  # => [2, "two"]
   #   tree.lt(3, safe: true) { |k, _| tree.delete(k) if k.even? }  # safe to delete
   def lt(key, reverse: false, safe: false, &block)
-    return enum_for(:lt, key, reverse: reverse, safe: safe) unless block_given?
+    return enum_for(__method__, key, reverse: reverse, safe: safe) unless block_given?
     if reverse
       traverse_lt_desc(@root, key, safe: safe, &block)
     else
@@ -523,7 +526,7 @@ class RBTree
   #   tree.lte(3).to_a  # => [[1, "one"], [2, "two"], [3, "three"]]
   #   tree.lte(3, reverse: true).first  # => [3, "three"]
   def lte(key, reverse: false, safe: false, &block)
-    return enum_for(:lte, key, reverse: reverse, safe: safe) unless block_given?
+    return enum_for(__method__, key, reverse: reverse, safe: safe) unless block_given?
     if reverse
       traverse_lte_desc(@root, key, safe: safe, &block)
     else
@@ -544,7 +547,7 @@ class RBTree
   #   tree.gt(2).to_a  # => [[3, "three"], [4, "four"]]
   #   tree.gt(2, reverse: true).first  # => [4, "four"]
   def gt(key, reverse: false, safe: false, &block)
-    return enum_for(:gt, key, reverse: reverse, safe: safe) unless block_given?
+    return enum_for(__method__, key, reverse: reverse, safe: safe) unless block_given?
     if reverse
       traverse_gt_desc(@root, key, safe: safe, &block)
     else
@@ -565,7 +568,7 @@ class RBTree
   #   tree.gte(2).to_a  # => [[2, "two"], [3, "three"], [4, "four"]]
   #   tree.gte(2, reverse: true).first  # => [4, "four"]
   def gte(key, reverse: false, safe: false, &block)
-    return enum_for(:gte, key, reverse: reverse, safe: safe) unless block_given?
+    return enum_for(__method__, key, reverse: reverse, safe: safe) unless block_given?
     if reverse
       traverse_gte_desc(@root, key, safe: safe, &block)
     else
@@ -589,7 +592,7 @@ class RBTree
   #   tree.between(2, 4).to_a  # => [[2, "two"], [3, "three"], [4, "four"]]
   #   tree.between(2, 4, reverse: true).first  # => [4, "four"]
   def between(min, max, include_min: true, include_max: true, reverse: false, safe: false, &block)
-    return enum_for(:between, min, max, include_min: include_min, include_max: include_max, reverse: reverse, safe: safe) unless block_given?
+    return enum_for(__method__, min, max, include_min: include_min, include_max: include_max, reverse: reverse, safe: safe) unless block_given?
     if reverse
       traverse_between_desc(@root, min, max, include_min, include_max, safe: safe, &block)
     else
@@ -1191,6 +1194,8 @@ class RBTree
   # @param key [Object] the reference key
   # @return [Node] the successor node, or @nil_node if none exists
   def find_successor_node(key)
+    # If key is smaller than min_key, return min_node
+    return @min_node if min_key && key < min_key
     # Check if key exists using O(1) hash lookup
     if (node = @hash_index[key])
       # Key exists: find successor in subtree or ancestors
@@ -1326,30 +1331,17 @@ class RBTree
   # Allocates a new node or recycles one from the pool.
   # @return [Node]
   def allocate_node(key, value, color, left, right, parent)
-    node = @node_pool.pop
-    if node
-      node.key = key
-      node.value = value
-      node.color = color
-      node.left = left
-      node.right = right
-      node.parent = parent
-      node
-    else
-      node = Node.new(key, value, color, left, right, parent)
-    end
+    node = @node_allocator.allocate(key, value, color, left, right, parent)
     @key_count += 1
     node
   end
 
+  # Releases a node back to the pool.
+  # @param node [Node] the node to release
   # Releases a node back to the pool.
   # @param node [Node] the node to release
   def release_node(node)
-    node.left = nil
-    node.right = nil
-    node.parent = nil
-    node.value = nil # Help GC
-    @node_pool << node
+    @node_allocator.release(node)
     @key_count -= 1
   end
 
@@ -1506,6 +1498,8 @@ class MultiRBTree < RBTree
   #   tree.get(1)              # => "first"
   #   tree.get(1, last: true)  # => "second"
   def value(key, last: false) = @hash_index[key]&.value&.send(last ? :last : :first)
+  alias :get :value
+  alias :[] :value
 
   # Retrieves the first value associated with the given key.
   #
@@ -1531,7 +1525,7 @@ class MultiRBTree < RBTree
   #   tree.insert(1, 'second')
   #   tree.values(1).to_a   # => ["first", "second"]
   def values(key, reverse: false)
-    return enum_for(:values, key) { value_count(key) } unless block_given?
+    return enum_for(__method__, key) { value_count(key) } unless block_given?
     @hash_index[key]&.value&.send(reverse ? :reverse_each : :each) { |v| yield v }
   end
   alias :get_all :values
@@ -1632,6 +1626,7 @@ class MultiRBTree < RBTree
     delete_indexed_node(z.key)
     value
   end
+  alias :delete :delete_key
 
   # Removes and returns the first key-value pair.
   #
@@ -1790,3 +1785,203 @@ class RBTree::Node
   # @return [Array(Object, Object)] the key-value pair
   def pair = [key, value]
 end
+
+# Allocator for RBTree nodes.
+#
+# @api private
+class RBTree::NodeAllocator
+  # Allocates a new node.
+    #
+  # @param key [Object] the key
+  # @param value [Object] the value
+  # @param color [Boolean] the color (true=red, false=black)
+  # @param left [Node] the left child
+  # @param right [Node] the right child
+  # @param parent [Node] the parent node
+  def allocate(key, value, color, left, right, parent) = RBTree::Node.new(key, value, color, left, right, parent)
+
+  # Releases a node.
+  #
+  # @param node [Node] the node to release
+  def release(node) = nil
+end
+
+# Internal node pool for RBTree.
+#
+# Manages recycling of Node objects to reduce object allocation overhead.
+#
+# @api private
+class RBTree::NodePool < RBTree::NodeAllocator
+  def initialize
+    @pool = []
+  end
+
+  # Allocates a new node or recycles one from the pool.
+  #
+  # @param key [Object] the key
+  # @param value [Object] the value
+  # @param color [Boolean] the color (true=red, false=black)
+  # @param left [Node] the left child
+  # @param right [Node] the right child
+  # @param parent [Node] the parent node
+  def allocate(key, value, color, left, right, parent)
+    node = @pool.pop
+    if node
+      node.key = key
+      node.value = value
+      node.color = color
+      node.left = left
+      node.right = right
+      node.parent = parent
+      node
+    else
+      super
+    end
+  end
+
+  # Releases a node back to the pool.
+  #
+  # @param node [Node] the node to release
+  def release(node)
+    node.left = node.right = node.parent = node.value = node.key = nil
+    @pool << node
+  end
+end
+
+# Internal node pool for RBTree.
+#
+# Manages recycling of Node objects to reduce object allocation overhead.
+# Includes an auto-shrink mechanism to release memory back to GC when
+# the pool size exceeds the fluctuation range of recent active node count.
+#
+# This class can be used to customize the node allocation strategy by passing
+# an instance to {RBTree#initialize}.
+class RBTree::AutoShrinkNodePool < RBTree::NodePool
+  # Initializes a new AutoShrinkNodePool.
+  #
+  # @param max_maintenance_interval [Integer] maximum interval between maintenance checks (default: 1000)
+  # @param target_check_interval [Float] target interval in seconds for maintenance checks (default: 1.0)
+  # @param history_size [Integer] duration in seconds to keep history for fluctuation analysis (default: 120)
+  # @param buffer_factor [Float] buffer factor to apply to observed fluctuation (default: 1.25)
+  # @param reserve_ratio [Float] minimum reserve capacity as a ratio of max active nodes (default: 0.1)
+  def initialize(
+      max_maintenance_interval: 1000,
+      target_check_interval: 1.0,
+      history_size: 120,
+      buffer_factor: 1.25,
+      reserve_ratio: 0.1)
+    @pool = []
+    
+    @max_maintenance_interval = max_maintenance_interval
+    @target_check_interval = target_check_interval
+    @history_limit = history_size
+    @buffer_ratio = buffer_factor
+    @reserve_ratio = reserve_ratio
+    
+    @maintenance_count = 0
+    @check_interval = 1000
+    @check_count = 0
+    @avg_release_rate = nil
+    @last_check_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    
+    @active_nodes = 0
+    @global_max_active = 0
+    @global_min_active = 0
+    @max_active_in_interval = 0
+    @min_active_in_interval = 0
+    @history = []
+    @current_target_capacity = Float::INFINITY
+  end
+
+  # Allocates a new node or recycles one from the pool.
+  #
+  # @param key [Object] the key
+  # @param value [Object] the value
+  # @param color [Boolean] the color (true=red, false=black)
+  # @param left [Node] the left child
+  # @param right [Node] the right child
+  # @param parent [Node] the parent node
+  def allocate(key, value, color, left, right, parent)
+    @active_nodes += 1
+    @max_active_in_interval = @active_nodes if @active_nodes > @max_active_in_interval
+    super
+  end
+
+  # Releases a node back to the pool.
+  #
+  # Checks auto-shrink logic to decide whether to keep the node or let it be GC'd.
+  #
+  # @param node [Node] the node to release
+  def release(node)
+    @active_nodes -= 1
+    @min_active_in_interval = @active_nodes if @active_nodes < @min_active_in_interval
+
+    @check_count += 1
+    
+    perform_maintenance if @check_count >= @check_interval
+
+    super if @pool.size < @current_target_capacity
+  end
+
+  private
+
+  def perform_maintenance
+    @maintenance_count += 1
+    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    elapsed = now - @last_check_time
+    return if elapsed <= 0
+    
+    current_rate = @check_count / elapsed
+    
+    if @avg_release_rate.nil?
+      @avg_release_rate = current_rate
+    else
+      @avg_release_rate = (@avg_release_rate * 3 + current_rate) / 4
+    end
+    
+    @check_interval = [[(@avg_release_rate * @target_check_interval).to_i, 1].max, @max_maintenance_interval].min
+    
+    expired_min = false
+    expired_max = false
+    needs_recalc = false
+
+    cutoff_time = now - @history_limit
+    while !@history.empty? && @history.first[0] < cutoff_time
+      if !expired_min && @history.first[1] == @global_min_active
+        expired_min = true
+        needs_recalc = true
+      end
+      if !expired_max && @history.first[2] == @global_max_active
+        expired_max = true
+        needs_recalc = true
+      end
+      @history.shift
+    end
+
+    @history << [now, @min_active_in_interval, @max_active_in_interval]
+
+    if @min_active_in_interval < @global_min_active
+      @global_min_active = @min_active_in_interval
+      expired_min = false
+      needs_recalc = true
+    end
+    if @max_active_in_interval > @global_max_active
+      @global_max_active = @max_active_in_interval
+      expired_max = false
+      needs_recalc = true
+    end
+
+    @global_min_active = @history.map { |_, min, _| min }.min if expired_min
+    @global_max_active = @history.map { |_, _, max| max }.max if expired_max
+    if needs_recalc
+      fluctuation = @global_max_active - @global_min_active
+      reserve = (@reserve_ratio * @global_max_active).to_i
+      @current_target_capacity = [(fluctuation * @buffer_ratio).to_i, reserve].max
+    end
+    
+    @check_count = 0
+    @last_check_time = now
+    @max_active_in_interval = @active_nodes
+    @min_active_in_interval = @active_nodes
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbtree-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Masahito Suzuki