veb_tree 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e23be52707f931f14be4a781a5b3772bc222c23c3843c59313b074fd64eb2e9c
-  data.tar.gz: 626f915e7d226ae97e08b6d8c448326716d3cbc12f88a2af37ba7e62c65b9d81
+  metadata.gz: b518aea4b85123bdda532a06f561bcd24af252f724f64ded4e4089451f9273f7
+  data.tar.gz: 3527c4ebc1ebc586b90fabc57c3bcefc0650df20c53b399c21613229cd3a2fec
 SHA512:
-  metadata.gz: b90a39d5c9480a9b1ac3174b1d078421634cd70e361154c00599edf6906370c4250d2491ee69e166f1c149a45847ad910484e4b2fe9537c6d4f26cf9c74afe05
-  data.tar.gz: d8b9ee66e04ababef90de5f0cfe2f12c2d1da3bbc6146b97899219dfc592bcba95c47293026bc798cb74e505c19f67b409c7640cd64b9aeecf1e3fad5737ab46
+  metadata.gz: 85d0512562fb3c530b8d01ee6ca96ee1354ab7254ae6ed539d9e8530cc8f00533ce20279c4bd0082bcdaaf4f94536a20c2aa3250f5d190816c6da2fb5315ffa4
+  data.tar.gz: 67962e7fa31d7c63ce8d4144a822e2ed642f041f1d689ce65fda357bf8cb28705eab62d81921e8bf80ac123de3df3e9409ab2697bf98b6f10e395ba03764f3ef

data/CHANGELOG.md

@@ -5,7 +5,12 @@ 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.1.0] - 2025-01-XX
+## [0.1.1] - 2025-10-03
+
+### Added
+- Fix compatibility issues for ruby 2.7 and macos
+
+## [0.1.0] - 2025-10-03
 
 ### Added
 - Initial release of VebTree gem

data/README.md

@@ -1,32 +1,39 @@
 # VebTree - Van Emde Boas Tree
 
-A high-performance Van Emde Boas (vEB) tree implementation for Ruby with a C++ core, providing **O(log log U)** time complexity for integer set operations.
+[![Tests](https://github.com/abhinvv1/Van-Emde-Boas-tree/workflows/Tests/badge.svg)](https://github.com/abhinvv1/Van-Emde-Boas-tree/actions)
+[![Gem Version](https://badge.fury.io/rb/veb_tree.svg)](https://badge.fury.io/rb/veb_tree)
 
-## Features
+A high-performance **Van Emde Boas (vEB) tree** implementation for Ruby with a C++17 core.  
+Provides **O(log log U)** time complexity for integer set operations, making it exponentially faster than balanced BSTs for many workloads.
 
-- **Blazing Fast**: O(log log U) operations for insert, delete, search, successor, and predecessor
-- **Native Performance**: Core algorithm implemented in C++17
-- **Simple API**: Clean, idiomatic Ruby interface
-- **Memory Efficient**: Lazy cluster allocation
-- **Battle Tested**: Comprehensive test suite
+---
 
-## Installation
+## ✨ Features
 
-### Requirements
+- ⚡ **Blazing Fast** — `O(log log U)` operations for insert, delete, search, successor, and predecessor  
+- 🖥 **Native Performance** — core implemented in **C++17**  
+- 🧑‍💻 **Simple API** — clean, idiomatic Ruby interface  
+- 🧩 **Memory Efficient** — lazy cluster allocation to minimize space usage  
+- ✅ **Battle Tested** — comprehensive test suite included  
+
+---
+
+## 📦 Installation
 
-- Ruby 2.7 or higher
-- C++17 compatible compiler:
-  - **Linux**: GCC 7+ or Clang 5+
-  - **macOS**: Xcode Command Line Tools
-  - **Windows**: MinGW-w64 or MSVC 2017+
+### Requirements
+- **Ruby**: 2.7 or higher  
+- **C++17** compatible compiler:  
+  - **Linux**: GCC 7+ or Clang 5+  
+  - **macOS**: Xcode Command Line Tools  
+  - **Windows**: MinGW-w64 or MSVC 2017+  
 
 ### Install via RubyGems
 ```bash
 gem install veb_tree
 ```
 
-## Install from Source
-```
+### Install from Source
+```bash
 git clone https://github.com/yourusername/veb_tree.git
 cd veb_tree
 bundle install
@@ -36,11 +43,14 @@ gem build veb_tree.gemspec
 gem install veb_tree-*.gem
 ```
 
-### Quick Start
-```
+---
+
+## 🚀 Quick Start
+
+```ruby
 require 'veb_tree'
 
-# Create a tree with universe size (will round to next power of 2)
+# Create a tree with universe size (rounded to next power of 2)
 tree = VebTree::Tree.new(1000)  # Actual size: 1024
 
 # Insert elements
@@ -49,21 +59,21 @@ tree.insert(100)
 tree.insert(7)
 tree.insert(500)
 
-# Check membership - O(log log U)
+# Membership check
 tree.include?(42)   # => true
 tree.include?(99)   # => false
 
-# Min/Max - O(1)
+# Min/Max
 tree.min  # => 7
 tree.max  # => 500
 
-# Successor/Predecessor - O(log log U)
+# Successor / Predecessor
 tree.successor(42)    # => 100
 tree.predecessor(100) # => 42
 
-# Size and empty check
-tree.size     # => 4
-tree.empty?   # => false
+# Size & emptiness
+tree.size   # => 4
+tree.empty? # => false
 
 # Iterate in sorted order
 tree.each { |key| puts key }
@@ -74,23 +84,244 @@ tree.to_a  # => [7, 42, 100, 500]
 
 # Delete elements
 tree.delete(42)  # => true
-tree.delete(42)  # => false (not present)
+tree.delete(42)  # => false (already removed)
 
 # Clear all elements
 tree.clear
 ```
 
-### API Reference
-```VebTree::Tree.new(universe_size)```
+---
 
-Creates a new Van Emde Boas tree.
-- universe_size (Integer): Maximum value that can be stored (exclusive). Will be 
-- rounded up to the next power of 2.
-- Returns: New VebTree::Tree instance
-- Raises: ArgumentError if universe_size is not positive
+## 📖 API Reference
 
-#### Example
+### Constructor
+```ruby
+VebTree::Tree.new(universe_size)
 ```
-tree = VebTree::Tree.new(100)  # Actual universe: 128
+
+- **universe_size (Integer)** — maximum value that can be stored (exclusive).  
+  Automatically rounded up to the next power of 2.  
+- **Returns**: `VebTree::Tree` instance  
+- **Raises**: `ArgumentError` if universe_size ≤ 0  
+
+**Example:**
+```ruby
+tree = VebTree::Tree.new(100) 
 tree.universe_size  # => 128
 ```
+
+---
+
+### Core Operations
+
+#### Insert
+```ruby
+tree.insert(key) → Boolean
+```
+- Inserts a key.  
+- **Time**: O(log log U)  
+- Returns `true` if inserted, `false` if already present.  
+
+#### Delete
+```ruby
+tree.delete(key) → Boolean
+```
+- Removes a key.  
+- **Time**: O(log log U)  
+- Returns `true` if deleted, `false` if not found.  
+
+#### Membership
+```ruby
+tree.include?(key) → Boolean
+tree.member?(key)  # alias
+```
+- Checks if key exists.  
+- **Time**: O(log log U)  
+
+#### Min / Max
+```ruby
+tree.min → Integer or nil
+tree.max → Integer or nil
+```
+- Returns smallest or largest key.  
+- **Time**: O(1)  
+
+#### Successor / Predecessor
+```ruby
+tree.successor(key)    → Integer or nil
+tree.predecessor(key)  → Integer or nil
+```
+- Finds next higher or next lower key.  
+- **Time**: O(log log U)  
+
+---
+
+### Utility Methods
+
+- `tree.size` → number of elements (**O(1)**)  
+- `tree.empty?` → true/false (**O(1)**)  
+- `tree.universe_size` → current universe size  
+- `tree.clear` → removes all elements  
+
+---
+
+### Enumeration
+
+The tree includes `Enumerable`, so all Ruby iteration helpers work:
+
+```ruby
+tree.each { |key| puts key }
+tree.to_a       # => [7, 42, 100, 500]
+tree.map { |x| x * 2 }  # => [14, 84, 200, 1000]
+tree.select { |x| x > 50 } # => [100, 500]
+tree.count  # => 4
+```
+
+---
+
+## 📊 Performance
+
+| Operation   | vEB Tree | Balanced BST |
+|-------------|----------|--------------|
+| Insert      | O(log log U) | O(log n) |
+| Delete      | O(log log U) | O(log n) |
+| Search      | O(log log U) | O(log n) |
+| Successor   | O(log log U) | O(log n) |
+| Predecessor | O(log log U) | O(log n) |
+| Min/Max     | O(1)         | O(log n) |
+
+- **U** = universe size (max key)  
+- **n** = number of stored elements  
+
+vEB trees are best for **bounded integer sets** with frequent `successor/predecessor/min/max` queries.  
+
+⚠️ Avoid when:  
+- Universe size is **huge (> 2^24)**  
+- Need arbitrary objects (only integers supported)  
+- Extremely memory constrained  
+
+---
+
+## 💾 Space Complexity
+
+- **Theoretical**: O(U)  
+- **Optimized** with lazy allocation: only used clusters consume memory  
+
+**Practical Usage:**  
+- Universe `2^16` (65K): ~hundreds of KB  
+- Universe `2^20` (1M): ~few MB  
+- Universe `2^24` (16M): ~tens of MB  
+
+---
+
+## ⚠️ Thread Safety
+
+This implementation is **NOT thread-safe**.  
+For concurrency, wrap operations with a `Mutex`:  
+
+```ruby
+require 'thread'
+
+tree = VebTree::Tree.new(1000)
+mutex = Mutex.new
+
+mutex.synchronize do
+  tree.insert(42)
+end
+```
+
+---
+
+## 🛑 Error Handling
+
+```ruby
+tree = VebTree::Tree.new(0)      # ArgumentError: Universe size must be > 0
+tree.insert(-1)                  # ArgumentError: Key must be non-negative
+tree.insert(200)                 # ArgumentError: Key exceeds universe size
+
+tree.include?(999)               # => false
+tree.successor(999)              # => nil
+```
+
+---
+
+## 🧪 Examples
+
+### Range Query Simulation
+```ruby
+tree = VebTree::Tree.new(10000)
+
+100.times { tree.insert(rand(10000)) }
+
+current = tree.successor(999)  # first ≥ 1000
+result = []
+while current && current <= 2000
+  result << current
+  current = tree.successor(current)
+end
+```
+
+### K-th Smallest Element
+```ruby
+def kth_smallest(tree, k)
+  current = tree.min
+  (k - 1).times do
+    return nil unless current
+    current = tree.successor(current)
+  end
+  current
+end
+
+tree = VebTree::Tree.new(1000)
+[5, 10, 3, 50].each { |x| tree.insert(x) }
+
+kth_smallest(tree, 2)  # => 5
+```
+
+---
+
+## 🔧 Development
+
+```bash
+# Clone repo
+git clone https://github.com/yourusername/veb_tree.git
+cd veb_tree
+
+# Install dependencies
+bundle install
+
+# Compile extension
+rake compile
+
+# Run tests
+rake test
+
+# Clean build
+rake clean
+```
+
+---
+
+## 🤝 Contributing
+
+Bug reports and pull requests are welcome at:  
+👉 [https://github.com/abhinvv1/Van-Emde-Boas-tree](https://github.com/abhinvv1/Van-Emde-Boas-tree)
+
+---
+
+## 📜 License
+
+This gem is available as open source under the **MIT License**.  
+
+---
+
+## 📚 References & Credits
+
+- Based on the **Van Emde Boas tree** described by *Peter van Emde Boas (1975)*  
+- *Cormen, T. H., et al. (2009). Introduction to Algorithms (3rd ed.), Chapter 20*  
+
+---
+
+## 🗒️ Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history.

data/ext/veb_tree/extconf.rb

@@ -7,34 +7,38 @@ unless find_executable("g++") || find_executable("clang++")
   abort "C++ compiler not found. Please install a C++ compiler."
 end
 
-# Set C++ compiler
-RbConfig::MAKEFILE_CONFIG["CXX"] = ENV["CXX"] || "g++"
-
-# C++17 standard
-$CXXFLAGS << " -std=c++17 -Wall -Wextra -O3"
-
-# Enable optimizations
-$CXXFLAGS << " -march=native" if ENV["NATIVE_ARCH"] == "1"
-
-# Debug flags if requested
-if ENV["DEBUG"] == "1"
-  $CXXFLAGS << " -g -O0 -DDEBUG"
+# Determine the C++ compiler
+if RUBY_PLATFORM =~ /darwin/
+  RbConfig::MAKEFILE_CONFIG["CXX"] = "clang++"
+  RbConfig::MAKEFILE_CONFIG["LDSHAREDXX"] = "clang++ -dynamic -bundle"
+  
+  if RUBY_VERSION < "3.0"
+    $CXXFLAGS << " -D_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION"
+    $CXXFLAGS << " -Wno-error=implicit-function-declaration"
+  end
 else
-  $CXXFLAGS << " -DNDEBUG"
+  RbConfig::MAKEFILE_CONFIG["CXX"] = ENV["CXX"] || "g++"
 end
 
+# C++17 standard
+$CXXFLAGS << " -std=c++17 -Wall -Wextra -O2"
+
 # Platform-specific settings
 case RUBY_PLATFORM
 when /darwin/
-  # macOS specific flags
   $CXXFLAGS << " -stdlib=libc++"
+  $LDFLAGS << " -stdlib=libc++"
 when /linux/
-  # Linux specific flags
   $LDFLAGS << " -lstdc++"
 when /mingw|mswin/
-  # Windows specific flags
   $CXXFLAGS << " -static-libgcc -static-libstdc++"
 end
 
-# Create Makefile
+# Debug flags if requested
+if ENV["DEBUG"] == "1"
+  $CXXFLAGS << " -g -O0 -DDEBUG"
+else
+  $CXXFLAGS << " -DNDEBUG"
+end
+
 create_makefile("veb_tree/veb_tree")

data/ext/veb_tree/veb_tree_ext.cpp

@@ -1,6 +1,30 @@
-#include "veb_tree_ext.h"
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <cmath>
+#include <vector>
+#include <limits>
 #include <algorithm>
 
+#include <ruby.h>
+
+#if defined(__APPLE__) && defined(RUBY_API_VERSION_CODE)
+  #if RUBY_API_VERSION_CODE < 30000
+    // Ruby 2.7's missing.h pollutes the global namespace
+    #ifdef finite
+      #undef finite
+    #endif
+    #ifdef isnan
+      #undef isnan
+    #endif
+    #ifdef isinf
+      #undef isinf
+    #endif
+  #endif
+#endif
+
+#include "veb_tree_ext.h"
+
 namespace VebTree {
 
 // ============================================================================
@@ -326,6 +350,9 @@ std::vector<uint64_t> VEBTree::to_vector() const {
 // Ruby Wrapper Implementation
 // ============================================================================
 
+// Ruby 2.x vs 3.x compatibility
+#if RUBY_API_VERSION_CODE >= 30000
+// Ruby 3.0+
 static const rb_data_type_t veb_tree_type = {
     "VebTree::Tree",
     {
@@ -338,6 +365,24 @@ static const rb_data_type_t veb_tree_type = {
     nullptr, // data
     RUBY_TYPED_FREE_IMMEDIATELY
 };
+#else
+// Ruby 2.7
+static void veb_tree_free(void* ptr) {
+    delete static_cast<VEBTree*>(ptr);
+}
+
+static const rb_data_type_t veb_tree_type = {
+    "VebTree::Tree",
+    {
+        nullptr, // dmark
+        veb_tree_free, // dfree
+        nullptr, // dsize
+    },
+    nullptr, // parent
+    nullptr, // data
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+#endif
 
 VEBTree* TreeWrapper::get_tree(VALUE self) {
     VEBTree* tree;

data/lib/veb_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VebTree
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: veb_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - pixelcaliber
@@ -58,7 +58,6 @@ files:
 - ext/veb_tree/veb_tree_ext.cpp
 - ext/veb_tree/veb_tree_ext.h
 - lib/veb_tree.rb
-- lib/veb_tree/pure_ruby.rb
 - lib/veb_tree/version.rb
 homepage: https://github.com/abhinvv1/Van-Emde-Boas-tree
 licenses:

data/lib/veb_tree/pure_ruby.rb

@@ -1,277 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module VebTree
-  class PureRuby
-    attr_reader :universe_size, :size
-    
-    NIL_VALUE = -1
-    
-    def initialize(universe_size)
-      raise ArgumentError, "Universe size must be positive" if universe_size <= 0
-      
-      @universe_size = next_power_of_2(universe_size)
-      warn "Universe size #{universe_size} rounded up to #{@universe_size}" if @universe_size != universe_size
-      
-      @size = 0
-      @min = NIL_VALUE
-      @max = NIL_VALUE
-      
-      # Base case
-      if @universe_size <= 2
-        @base_case = true
-        return
-      end
-      
-      @base_case = false
-      
-      # Calculate sqrt
-      log_u = Math.log2(@universe_size).to_i
-      @sqrt_size = 1 << (log_u / 2)
-      @num_clusters = @universe_size / @sqrt_size
-      
-      # Lazy allocation
-      @clusters = Array.new(@num_clusters)
-      @summary = nil
-    end
-    
-    def insert(key)
-      validate_key(key)
-      return false if include?(key)
-      
-      # Empty tree
-      if @min == NIL_VALUE
-        @min = @max = key
-        @size += 1
-        return true
-      end
-      
-      # Base case
-      if @base_case
-        @min = key if key < @min
-        @max = key if key > @max
-        @size += 1
-        return true
-      end
-      
-      # Ensure key is not min
-      if key < @min
-        key, @min = @min, key
-      end
-      
-      @max = key if key > @max
-      
-      # Recursive insert
-      h = high(key)
-      l = low(key)
-      
-      # Lazy create cluster
-      @clusters[h] ||= PureRuby.new(@sqrt_size)
-      
-      # If cluster was empty, update summary
-      if @clusters[h].min == NIL_VALUE
-        @summary ||= PureRuby.new(@num_clusters)
-        @summary.insert(h)
-        @clusters[h].instance_variable_set(:@min, l)
-        @clusters[h].instance_variable_set(:@max, l)
-        @clusters[h].instance_variable_set(:@size, 1)
-      else
-        @clusters[h].insert(l)
-      end
-      
-      @size += 1
-      true
-    end
-    
-    def delete(key)
-      return false unless include?(key)
-      
-      # Base case
-      if @base_case
-        if key == @min && key == @max
-          @min = @max = NIL_VALUE
-        elsif key == @min
-          @min = @max
-        else
-          @max = @min
-        end
-        @size -= 1
-        return true
-      end
-      
-      # Only one element
-      if @size == 1
-        @min = @max = NIL_VALUE
-        @size = 0
-        return true
-      end
-      
-      # Replace min with successor if deleting min
-      if key == @min
-        first_cluster = @summary.min
-        key = index(first_cluster, @clusters[first_cluster].min)
-        @min = key
-      end
-      
-      # Recursive delete
-      h = high(key)
-      l = low(key)
-      
-      @clusters[h].delete(l) if @clusters[h]
-      
-      # If cluster is empty, remove from summary
-      if @clusters[h] && @clusters[h].min == NIL_VALUE
-        @summary.delete(h)
-        @clusters[h] = nil
-        
-        # Update max if necessary
-        if key == @max
-          summary_max = @summary.max
-          if summary_max == NIL_VALUE
-            @max = @min
-          else
-            @max = index(summary_max, @clusters[summary_max].max)
-          end
-        end
-      elsif key == @max && @clusters[h]
-        @max = index(h, @clusters[h].max)
-      end
-      
-      @size -= 1
-      true
-    end
-    
-    def include?(key)
-      return false if key < 0 || key >= @universe_size
-      return true if key == @min || key == @max
-      return false if @base_case
-      
-      h = high(key)
-      @clusters[h] && @clusters[h].include?(low(key))
-    end
-    alias member? include?
-    
-    def min
-      @min == NIL_VALUE ? nil : @min
-    end
-    
-    def max
-      @max == NIL_VALUE ? nil : @max
-    end
-    
-    def successor(key)
-      return nil if @min == NIL_VALUE
-      
-      # Base case
-      if @base_case
-        return @min if key < @min
-        return @max if key < @max
-        return nil
-      end
-      
-      return @min if key < @min
-      
-      h = high(key)
-      l = low(key)
-      
-      # Check same cluster
-      if @clusters[h] && l < @clusters[h].max
-        offset = @clusters[h].successor(l)
-        return index(h, offset)
-      end
-      
-      # Next cluster
-      succ_cluster = @summary.successor(h)
-      return nil if succ_cluster == NIL_VALUE
-      
-      offset = @clusters[succ_cluster].min
-      index(succ_cluster, offset)
-    end
-    
-    def predecessor(key)
-      return nil if @max == NIL_VALUE
-      
-      # Base case
-      if @base_case
-        return @max if key > @max
-        return @min if key > @min
-        return nil
-      end
-      
-      return @max if key > @max
-      
-      h = high(key)
-      l = low(key)
-      
-      # Check same cluster
-      if @clusters[h] && l > @clusters[h].min
-        offset = @clusters[h].predecessor(l)
-        return index(h, offset)
-      end
-      
-      # Previous cluster
-      pred_cluster = @summary.predecessor(h)
-      return @min if pred_cluster == NIL_VALUE && key > @min
-      return nil if pred_cluster == NIL_VALUE
-      
-      offset = @clusters[pred_cluster].max
-      index(pred_cluster, offset)
-    end
-    
-    def empty?
-      @size == 0
-    end
-    
-    def clear
-      @min = @max = NIL_VALUE
-      @size = 0
-      unless @base_case
-        @summary&.clear
-        @clusters.fill(nil)
-      end
-      self
-    end
-    
-    def each
-      return enum_for(:each) unless block_given?
-      
-      current = @min
-      while current && current != NIL_VALUE
-        yield current
-        break if current == @max
-        current = successor(current)
-      end
-      
-      self
-    end
-    
-    def to_a
-      each.to_a
-    end
-    
-    private
-    
-    def high(x)
-      x / @sqrt_size
-    end
-    
-    def low(x)
-      x % @sqrt_size
-    end
-    
-    def index(high, low)
-      high * @sqrt_size + low
-    end
-    
-    def validate_key(key)
-      raise ArgumentError, "Key must be non-negative" if key < 0
-      raise ArgumentError, "Key #{key} exceeds universe size #{@universe_size}" if key >= @universe_size
-    end
-    
-    def next_power_of_2(n)
-      return 1 if n <= 1
-      2 ** (Math.log2(n).ceil)
-    end
-  end
-end